Merge lp:~unity-team/unity/y-sru1 into lp:unity/yakkety

[Marco Trevisan (Treviño)]

Releasing SRU1 for yakkety

[Andrea Azzarone (azzar1)]

+1 Thanks

review: Approve

=== modified file 'UnityCore/GnomeSessionManager.cpp'
--- UnityCore/GnomeSessionManager.cpp	2016-09-01 17:18:03 +0000
+++ UnityCore/GnomeSessionManager.cpp	2016-11-11 14:53:10 +0000
@@ -101,32 +101,37 @@
   });
 
   {
-    const char* session_id = test_mode_ ? "id0" : g_getenv("XDG_SESSION_ID");
-
-    login_proxy_ = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.login1",
-                                                     "/org/freedesktop/login1/session/" + glib::gchar_to_string(session_id),
-                                                     "org.freedesktop.login1.Session",
-                                                     test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
-                                                     G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES);
-
-    login_proxy_->Connect("Lock", [this](GVariant*){
-      manager_->PromptLockScreen();
-    });
-
-    login_proxy_->Connect("Unlock", [this](GVariant*){
-      manager_->unlock_requested.emit();
-    });
-
-    login_proxy_->ConnectProperty("Active", [this] (GVariant* variant) {
-      bool active = glib::Variant(variant).GetBool();
-      manager_->is_session_active.changed.emit(active);
-      if (active)
-        manager_->screensaver_requested.emit(false);
-    });
-
-    manager_->is_session_active.SetGetterFunction([this] {
-      return login_proxy_->GetProperty("Active").GetBool();
-    });
+    std::string session_id = test_mode_ ? "id0" : glib::gchar_to_string(g_getenv("XDG_SESSION_ID"));
+
+    if (!session_id.empty())
+    {
+      CallLogindMethod("GetSession", g_variant_new("(s)", session_id.c_str()), [this, session_id] (GVariant* variant, glib::Error const& err) {
+        std::string session_path;
+
+        if (!err && variant)
+          session_path = glib::Variant(variant).GetObjectPath();
+
+        if (session_path.empty())
+          session_path = "/org/freedesktop/login1/session/" + session_id;
+
+        SetupLogin1Proxy(session_path);
+      });
+    }
+    else
+    {
+      auto proxy = std::make_shared<glib::DBusProxy>("org.freedesktop.login1",
+                                                     "/org/freedesktop/login1/user/self",
+                                                     "org.freedesktop.login1.User",
+                                                     G_BUS_TYPE_SYSTEM);
+
+      proxy->GetProperty("Display", [this, proxy] (GVariant *variant) {
+        if (!variant || g_variant_n_children(variant) < 2)
+          return;
+
+        glib::Variant tmp(g_variant_get_child_value(variant, 1), glib::StealRef());
+        SetupLogin1Proxy(tmp.GetObjectPath());
+      });
+    }
   }
 
   {
@@ -221,6 +226,34 @@
   ClosedDialog();
 }
 
+void GnomeManager::Impl::SetupLogin1Proxy(std::string const& session_path)
+{
+  login_proxy_ = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.login1",
+                                                   session_path,
+                                                   "org.freedesktop.login1.Session",
+                                                   test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
+                                                   G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES);
+
+  login_proxy_->Connect("Lock", [this](GVariant*){
+    manager_->PromptLockScreen();
+  });
+
+  login_proxy_->Connect("Unlock", [this](GVariant*){
+    manager_->unlock_requested.emit();
+  });
+
+  login_proxy_->ConnectProperty("Active", [this] (GVariant* variant) {
+    bool active = glib::Variant(variant).GetBool();
+    manager_->is_session_active.changed.emit(active);
+    if (active)
+      manager_->screensaver_requested.emit(false);
+  });
+
+  manager_->is_session_active.SetGetterFunction([this] {
+    return login_proxy_->GetProperty("Active").GetBool();
+  });
+}
+
 bool GnomeManager::Impl::InteractiveMode()
 {
   bool schema_found = false;

=== modified file 'UnityCore/GnomeSessionManagerImpl.h'
--- UnityCore/GnomeSessionManagerImpl.h	2015-12-03 05:57:00 +0000
+++ UnityCore/GnomeSessionManagerImpl.h	2016-11-11 14:53:10 +0000
@@ -46,6 +46,8 @@
   Impl(GnomeManager* parent, bool test_mode = false);
   ~Impl();
 
+  void SetupLogin1Proxy(std::string const& session_path);
+
   void ConfirmLogout();
   void ConfirmReboot();
   void ConfirmShutdown();

=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2013-11-19 20:28:13 +0000
+++ UnityCore/Variant.cpp	2016-11-11 14:53:10 +0000
@@ -174,6 +174,36 @@
   return result ? result : "";
 }
 
+std::string Variant::GetObjectPath() const
+{
+  const gchar *result = nullptr;
+
+  if (!variant_)
+    return "";
+
+  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_OBJECT_PATH))
+  {
+    // g_variant_get_string doesn't duplicate the string
+    result = g_variant_get_string(variant_, nullptr);
+  }
+  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(o)")))
+  {
+    // As we're using the '&' prefix we don't need to free the string!
+    g_variant_get(variant_, "(&o)", &result);
+  }
+  else
+  {
+    auto const& variant = get_variant(variant_);
+    if (variant)
+      return variant.GetObjectPath();
+
+    LOG_ERROR(logger) << "You're trying to extract a 'o' from a variant which is of type '"
+                      << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'";
+  }
+
+  return result ? result : "";
+}
+
 template <typename TYPE, typename GTYPE>
 TYPE get_numeric_value(GVariant *variant_, const char *type_str, const char *fallback_type_str)
 {

=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2013-11-19 20:28:13 +0000
+++ UnityCore/Variant.h	2016-11-11 14:53:10 +0000
@@ -68,6 +68,7 @@
   ~Variant();
 
   std::string GetString() const;
+  std::string GetObjectPath() const;
   unsigned char GetByte() const;
   int16_t GetInt16() const;
   uint16_t GetUInt16() const;

=== modified file 'debian/changelog'
--- debian/changelog	2016-09-06 14:19:16 +0000
+++ debian/changelog	2016-11-11 14:53:10 +0000
@@ -1,3 +1,20 @@
+unity (7.5.0+16.10.20160906.1-0ubuntu2) UNRELEASED; urgency=medium
+
+  [ Marco Trevisan (Treviño) ]
+  * LockScreenController: ignore icon_paths_changed signal in
+    menumanager for Lockscreen (LP: #1635625)
+
+  [ Andrea Azzarone ]
+  * Properly handle the file manager copy dialog in
+    FileManagerLauncherIcon and in StorageLauncherIcon. (LP: #1575452,
+    LP: #1609845)
+  * Correctly position the force quit dialog when scaling is different
+    than 1.0 (LP: #1637991)
+  * GnomeSession: Retrieve the session id using dbus if $XDG_SESSION_ID
+    is not set (LP: #1633749)
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Fri, 11 Nov 2016 14:45:03 +0100
+
 unity (7.5.0+16.10.20160906.1-0ubuntu1) yakkety; urgency=medium
 
   [ Marco Trevisan (Treviño), Ted Gould ]

=== modified file 'decorations/DecorationsForceQuitDialog.cpp'
--- decorations/DecorationsForceQuitDialog.cpp	2016-08-06 16:24:55 +0000
+++ decorations/DecorationsForceQuitDialog.cpp	2016-11-11 14:53:10 +0000
@@ -478,9 +478,11 @@
 
   void UpdateDialogPosition()
   {
+    gint scale = gtk_widget_get_scale_factor(dialog_);
+    scale = std::max<gint>(1, scale);
     auto const& win_geo = win_->inputRect();
-    nux::Size walloc(gtk_widget_get_allocated_width(dialog_), gtk_widget_get_allocated_height(dialog_));
-    gtk_window_move(GTK_WINDOW(dialog_), win_geo.centerX() - walloc.width/2, win_geo.centerY() - walloc.height/2);
+    nux::Size walloc(gtk_widget_get_allocated_width(dialog_) * scale, gtk_widget_get_allocated_height(dialog_) * scale);
+    gtk_window_move(GTK_WINDOW(dialog_), (win_geo.centerX() - walloc.width/2) / scale, (win_geo.centerY() - walloc.height/2) / scale);
   }
 
   ForceQuitDialog* parent_;

=== modified file 'launcher/FileManagerLauncherIcon.cpp'
--- launcher/FileManagerLauncherIcon.cpp	2016-07-05 13:35:56 +0000
+++ launcher/FileManagerLauncherIcon.cpp	2016-11-11 14:53:10 +0000
@@ -49,6 +49,11 @@
   SetQuirk(Quirk::VISIBLE, false);
   SkipQuirkAnimation(Quirk::VISIBLE);
 
+  signals_conn_.Add(app_->window_opened.connect([this](ApplicationWindowPtr const& win) {
+    signals_conn_.Add(win->monitor.changed.connect([this] (int) { UpdateStorageWindows(); }));
+    UpdateStorageWindows();
+  }));
+
   signals_conn_.Add(app_->desktop_file.changed.connect([this](std::string const& desktop_file) {
     LOG_DEBUG(logger) << tooltip_text() << " desktop_file now " << desktop_file;
     UpdateDesktopFile();
@@ -134,5 +139,30 @@
   return StorageLauncherIcon::OnShouldHighlightOnDrag(dnd_data);
 }
 
+bool FileManagerLauncherIcon::IsUserVisible() const
+{
+  return ApplicationLauncherIcon::IsUserVisible();
+}
+
+WindowList FileManagerLauncherIcon::WindowsOnViewport()
+{
+  WindowFilterMask filter = 0;
+  filter |= WindowFilter::MAPPED;
+  filter |= WindowFilter::ON_CURRENT_DESKTOP;
+  filter |= WindowFilter::ON_ALL_MONITORS;
+
+  return WindowedLauncherIcon::GetWindows(filter);
+}
+
+WindowList FileManagerLauncherIcon::WindowsForMonitor(int monitor)
+{
+  WindowFilterMask filter = 0;
+  filter |= WindowFilter::MAPPED;
+  filter |= WindowFilter::ON_CURRENT_DESKTOP;
+
+  return WindowedLauncherIcon::GetWindows(filter, monitor);
+}
+
+
 } // namespace launcher
 } // namespace unity

=== modified file 'launcher/FileManagerLauncherIcon.h'
--- launcher/FileManagerLauncherIcon.h	2015-12-09 12:02:48 +0000
+++ launcher/FileManagerLauncherIcon.h	2016-11-11 14:53:10 +0000
@@ -32,8 +32,16 @@
 class FileManagerLauncherIcon : public ApplicationLauncherIcon, public StorageLauncherIcon
 {
 public:
+  typedef nux::ObjectPtr<FileManagerLauncherIcon> Ptr;
+
   FileManagerLauncherIcon(ApplicationPtr const&, DeviceLauncherSection::Ptr const&, FileManager::Ptr const& = nullptr);
 
+  bool IsUserVisible() const override;
+
+protected:
+  WindowList WindowsOnViewport() override;
+  WindowList WindowsForMonitor(int monitor) override;
+
 private:
   WindowList GetManagedWindows() const override;
   WindowList GetStorageWindows() const override;

=== modified file 'launcher/StorageLauncherIcon.cpp'
--- launcher/StorageLauncherIcon.cpp	2015-12-08 14:31:30 +0000
+++ launcher/StorageLauncherIcon.cpp	2016-11-11 14:53:10 +0000
@@ -36,7 +36,7 @@
   bool active = false;
   bool urgent = false;
   bool check_visibility = (GetIconType() == IconType::APPLICATION);
-  bool visible = IsSticky();
+  bool visible = false;
 
   managed_windows_ = GetStorageWindows();
   windows_connections_.Clear();
@@ -54,13 +54,8 @@
     if (!urgent && win->urgent())
       urgent = true;
 
-    if (check_visibility)
-    {
-      windows_connections_.Add(win->visible.changed.connect([this] (bool) { OnWindowStateChanged(); }));
-
-      if (!visible && win->visible())
-        visible = true;
-    }
+    if (check_visibility && !visible)
+      visible = true;
   }
 
   SetQuirk(Quirk::RUNNING, !managed_windows_.empty());
@@ -68,7 +63,7 @@
   SetQuirk(Quirk::URGENT, urgent);
 
   if (check_visibility)
-    SetQuirk(Quirk::VISIBLE, visible);
+    SetQuirk(Quirk::VISIBLE, visible || IsSticky());
 
   EnsureWindowsLocation();
 }
@@ -83,7 +78,7 @@
   bool active = false;
   bool urgent = false;
   bool check_visibility = (GetIconType() == IconType::APPLICATION);
-  bool visible = IsSticky();
+  bool visible = false;
 
   for (auto const& win : managed_windows_)
   {
@@ -93,7 +88,7 @@
     if (!urgent && win->urgent())
       urgent = true;
 
-    if (check_visibility && !visible && win->visible())
+    if (check_visibility && !visible)
       visible = true;
   }
 
@@ -101,7 +96,7 @@
   SetQuirk(Quirk::URGENT, urgent);
 
   if (check_visibility)
-    SetQuirk(Quirk::VISIBLE, visible);
+    SetQuirk(Quirk::VISIBLE, visible || IsSticky());
 }
 
 bool StorageLauncherIcon::OnShouldHighlightOnDrag(DndData const& dnd_data)

=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2016-09-02 13:36:37 +0000
+++ lockscreen/LockScreenController.cpp	2016-11-11 14:53:10 +0000
@@ -467,6 +467,7 @@
 void Controller::LockScreen()
 {
   menu_manager_ = std::make_shared<menu::Manager>(std::make_shared<indicator::LockScreenDBusIndicators>(), key_grabber_);
+  menu_manager_->Indicators()->icon_paths_changed.clear(); // Ignore custom icon themes for lockscreen, see bug #1635625
   upstart_wrapper_->Emit("desktop-lock");
   systemd_wrapper_->Start(SYSTEMD_LOCK_TARGET);
 

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2016-07-20 15:55:32 +0000
+++ tests/CMakeLists.txt	2016-11-11 14:53:10 +0000
@@ -224,6 +224,7 @@
                  test_error_preview.cpp
                  test_edge_barrier_controller.cpp
                  test_expo_launcher_icon.cpp
+                 test_file_manager_launcher_icon.cpp
                  test_filter_widgets.cpp
                  test_glib_dbus_server.cpp
                  test_gnome_session_manager.cpp

=== added file 'tests/test_file_manager_launcher_icon.cpp'
--- tests/test_file_manager_launcher_icon.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_file_manager_launcher_icon.cpp	2016-11-11 14:53:10 +0000
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gmock/gmock.h>
+using namespace testing;
+
+#include "FileManagerLauncherIcon.h"
+#include "UnityCore/DesktopUtilities.h"
+
+#include "test_mock_devices.h"
+#include "test_mock_filemanager.h"
+#include "mock-application.h"
+
+using namespace unity;
+using namespace unity::launcher;
+using namespace testmocks;
+
+namespace
+{
+
+const std::string TRASH_URI = "trash:";
+const std::string TRASH_PATH = "file://" + DesktopUtilities::GetUserTrashDirectory();
+
+struct TestFileManagerLauncherIcon : public Test
+{
+  TestFileManagerLauncherIcon()
+    : app_(std::make_shared<MockApplication::Nice>())
+    , fm_(std::make_shared<MockFileManager::Nice>())
+    , dev_ (std::make_shared<MockDeviceLauncherSection>(2))
+    , icon_(new FileManagerLauncherIcon(app_, dev_, fm_))
+  {
+  }
+
+  MockApplication::Ptr app_;
+  MockFileManager::Ptr fm_;
+  DeviceLauncherSection::Ptr dev_;
+  FileManagerLauncherIcon::Ptr icon_;
+};
+
+TEST_F(TestFileManagerLauncherIcon, IconType)
+{
+  EXPECT_EQ(icon_->GetIconType(), AbstractLauncherIcon::IconType::APPLICATION);
+}
+
+TEST_F(TestFileManagerLauncherIcon, NoWindow)
+{
+  EXPECT_FALSE(icon_->IsVisible());
+}
+
+TEST_F(TestFileManagerLauncherIcon, NoManagedWindow_TrashUri)
+{
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(1);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return(TRASH_URI));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  EXPECT_FALSE(icon_->IsVisible());
+  EXPECT_FALSE(icon_->IsRunning());
+}
+
+TEST_F(TestFileManagerLauncherIcon, NoManagedWindow_TrashPath)
+{
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(1);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return(TRASH_PATH));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  EXPECT_FALSE(icon_->IsVisible());
+  EXPECT_FALSE(icon_->IsRunning());
+}
+
+TEST_F(TestFileManagerLauncherIcon, NoManagedWindow_Device)
+{
+  auto const& device_icons = dev_->GetIcons();
+  ASSERT_EQ(2, device_icons.size());
+
+  device_icons.at(0)->Activate(ActionArg());
+
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(1);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return(device_icons.at(0)->GetVolumeUri()));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  EXPECT_FALSE(icon_->IsVisible());
+  EXPECT_FALSE(icon_->IsRunning());
+}
+
+TEST_F(TestFileManagerLauncherIcon, ManagedWindows)
+{
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(1);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return("/usr/bin"));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  EXPECT_TRUE(icon_->IsVisible());
+  EXPECT_TRUE(icon_->IsRunning());
+}
+
+TEST_F(TestFileManagerLauncherIcon, ManagedWindows_EmptyLocation)
+{
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(1);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return(""));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  EXPECT_TRUE(icon_->IsVisible());
+  EXPECT_TRUE(icon_->IsRunning());
+}
+
+TEST_F(TestFileManagerLauncherIcon, ManagedWindows_CopyDialog)
+{
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(1);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return(""));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  win->visible_ = false;
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  EXPECT_TRUE(icon_->IsVisible());
+  EXPECT_TRUE(icon_->IsRunning());
+}
+
+
+TEST_F(TestFileManagerLauncherIcon, ManagedWindows_CopyDialogAndManagedWindow)
+{
+  EXPECT_CALL(*fm_, LocationForWindow(_)).Times(3);
+  ON_CALL(*fm_, LocationForWindow(_)).WillByDefault(Return(""));
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  win->visible_ = false;
+  app_->windows_.push_back(win);
+  app_->window_opened.emit(win);
+
+  EXPECT_TRUE(icon_->IsVisible());
+  EXPECT_TRUE(icon_->IsRunning());
+  EXPECT_EQ(2, icon_->WindowsVisibleOnMonitor(0));
+}
+
+TEST_F(TestFileManagerLauncherIcon, ManagedWindows_CopyDialogAndNoManagedWindow)
+{
+  {
+    InSequence s;
+
+    EXPECT_CALL(*fm_, LocationForWindow(_))
+      .Times(1)
+      .WillOnce(Return(""));
+
+    EXPECT_CALL(*fm_, LocationForWindow(_))
+      .Times(1)
+      .WillOnce(Return(""));
+
+    EXPECT_CALL(*fm_, LocationForWindow(_))
+      .Times(1)
+      .WillOnce(Return(TRASH_PATH));
+  }
+
+  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  app_->windows_ = { win };
+  app_->window_opened.emit(win);
+
+  win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
+  win->visible_ = false;
+  app_->windows_.push_back(win);
+  app_->window_opened.emit(win);
+
+  EXPECT_TRUE(icon_->IsVisible());
+  EXPECT_TRUE(icon_->IsRunning());
+  EXPECT_EQ(1, icon_->WindowsVisibleOnMonitor(0));
+}
+
+}

=== modified file 'tests/test_gnome_session_manager.cpp'
--- tests/test_gnome_session_manager.cpp	2016-05-17 02:14:33 +0000
+++ tests/test_gnome_session_manager.cpp	2016-11-11 14:53:10 +0000
@@ -70,6 +70,9 @@
 const std::string LOGIND_MANAGER =
 R"(<node>
   <interface name="org.freedesktop.login1.Manager">
+    <method name="GetSession">
+      <arg type="s" name="result" direction="out"/>
+    </method>
     <method name="CanSuspend">
       <arg type="s" name="result" direction="out"/>
     </method>
@@ -186,7 +189,11 @@
     logind_->AddObjects(introspection::LOGIND_MANAGER, LOGIND_MANAGER_PATH);
     logind_->AddObjects(introspection::LOGIND_SESSION, LOGIND_SESSION_PATH);
     logind_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
-      if (method == "CanSuspend")
+      if (method == "GetSession")
+      {
+        return g_variant_new("(o)", "id0");
+      }
+      else if (method == "CanSuspend")
       {
         suspend_called = true;
         return g_variant_new("(s)", can_suspend_ ? "yes" : "no");