Merge lp:~3v1n0/unity/volume-filemanager-in-icon into lp:unity

[Marco Trevisan (Treviño)]

Volume: remove FileManager instance, handle opened status in VolumeLauncherIcon

Don't mix the Volume wrapper with the filemanager handling of it, we should do this in the icon itself.

Some various cleanup (as moved the connection::handle to a more generic action::handle), unit tests updated. This is a prerequisite for fixing bug #838731

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3565
http://10.97.0.26:8080/job/unity-ci/422/
Executed test runs:
    SUCCESS: http://10.97.0.26:8080/job/unity-saucy-amd64-ci/311
    SUCCESS: http://10.97.0.26:8080/job/unity-saucy-armhf-ci/309
    SUCCESS: http://10.97.0.26:8080/job/unity-saucy-i386-ci/310

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/422/rebuild

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

Works. +1

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3566
http://10.97.0.26:8080/job/unity-ci/423/
Executed test runs:
    SUCCESS: http://10.97.0.26:8080/job/unity-saucy-amd64-ci/312
    SUCCESS: http://10.97.0.26:8080/job/unity-saucy-armhf-ci/310
    SUCCESS: http://10.97.0.26:8080/job/unity-saucy-i386-ci/311

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity-ci/423/rebuild

review: Approve (continuous-integration)

=== added file 'UnityCore/ActionHandle.h'
--- UnityCore/ActionHandle.h	1970-01-01 00:00:00 +0000
+++ UnityCore/ActionHandle.h	2013-10-07 17:26:52 +0000
@@ -0,0 +1,57 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 warranty of
+* MERCHANTABILITY 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
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* Authored by: Marco Trevisan <[e-mail]>
+*/
+
+#ifndef UNITY_ACTION_HANDLE_H
+#define UNITY_ACTION_HANDLE_H
+
+#include <memory>
+
+namespace unity
+{
+namespace action
+{
+struct handle
+{
+  constexpr handle() : handle_(0) {}
+  constexpr handle(uint64_t val) : handle_(val) {}
+  constexpr operator uint64_t() const { return handle_; }
+  inline handle& operator++() { ++handle_; return *this; }
+  inline handle operator++(int) { auto tmp = *this; ++handle_; return tmp; }
+  inline handle& operator--() { --handle_; return *this; }
+  inline handle operator--(int) { auto tmp = *this; --handle_; return tmp; }
+
+private:
+  uint64_t handle_;
+};
+} // action namespace
+} // unity namespace
+
+namespace std
+{
+// Template specialization, needed for unordered_map
+template<> struct hash<unity::action::handle>
+{
+  std::size_t operator()(unity::action::handle const& h) const
+  {
+    return std::hash<uint64_t>()(h);
+  }
+};
+}
+
+#endif // UNITY_ACTION_HANDLE_H

=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2013-09-25 12:15:03 +0000
+++ UnityCore/CMakeLists.txt	2013-10-07 17:26:52 +0000
@@ -13,6 +13,7 @@
 # Headers & Sources
 #
 set (CORE_HEADERS
+     ActionHandle.h
      ApplicationPreview.h
      AppmenuIndicator.h
      Categories.h

=== modified file 'UnityCore/ConnectionManager.h'
--- UnityCore/ConnectionManager.h	2013-07-01 21:48:01 +0000
+++ UnityCore/ConnectionManager.h	2013-10-07 17:26:52 +0000
@@ -23,43 +23,13 @@
 #include <memory>
 #include <unordered_map>
 #include <sigc++/sigc++.h>
-
-namespace unity
-{
-namespace connection
-{
-struct handle
-{
-  handle() : handle_(0) {}
-  handle(uint64_t val) : handle_(val) {}
-  operator uint64_t() const { return handle_; }
-  handle& operator++() { ++handle_; return *this; }
-  handle operator++(int) { auto tmp = *this; ++handle_; return tmp; }
-  handle& operator--() { --handle_; return *this; }
-  handle operator--(int) { auto tmp = *this; --handle_; return tmp; }
-
-private:
-  uint64_t handle_;
-};
-} // connection namespace
-} // unity namespace
-
-namespace std
-{
-// Template specialization, needed for unordered_map
-template<> struct hash<unity::connection::handle>
-{
-  std::size_t operator()(unity::connection::handle const& h) const
-  {
-    return std::hash<uint64_t>()(h);
-  }
-};
-}
-
-namespace unity
-{
-namespace connection
-{
+#include "ActionHandle.h"
+
+namespace unity
+{
+namespace connection
+{
+typedef unity::action::handle handle;
 
 class Wrapper
 {

=== modified file 'launcher/DeviceLauncherSection.cpp'
--- launcher/DeviceLauncherSection.cpp	2013-03-27 19:53:00 +0000
+++ launcher/DeviceLauncherSection.cpp	2013-10-07 17:26:52 +0000
@@ -19,8 +19,9 @@
 
 #include "DeviceLauncherSection.h"
 #include "DeviceNotificationDisplayImp.h"
-#include "DevicesSettings.h"
+#include "DevicesSettingsImp.h"
 #include "VolumeImp.h"
+#include "VolumeMonitorWrapper.h"
 #include "unity-shared/GnomeFileManager.h"
 
 namespace unity
@@ -28,12 +29,13 @@
 namespace launcher
 {
 
-DeviceLauncherSection::DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr volume_monitor,
-                                             DevicesSettings::Ptr devices_settings)
-  : monitor_(volume_monitor)
-  , devices_settings_(devices_settings)
+DeviceLauncherSection::DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr const& vm,
+                                             DevicesSettings::Ptr const& ds,
+                                             DeviceNotificationDisplay::Ptr const& notify)
+  : monitor_(vm ? vm : std::make_shared<VolumeMonitorWrapper>())
+  , devices_settings_(ds ? ds : std::make_shared<DevicesSettingsImp>())
   , file_manager_(GnomeFileManager::Get())
-  , device_notification_display_(std::make_shared<DeviceNotificationDisplayImp>())
+  , device_notification_display_(notify ? notify : std::make_shared<DeviceNotificationDisplayImp>())
 {
   monitor_->volume_added.connect(sigc::mem_fun(this, &DeviceLauncherSection::OnVolumeAdded));
   monitor_->volume_removed.connect(sigc::mem_fun(this, &DeviceLauncherSection::OnVolumeRemoved));
@@ -43,7 +45,7 @@
 
 void DeviceLauncherSection::PopulateEntries()
 {
-  for (auto volume : monitor_->GetVolumes())
+  for (auto const& volume : monitor_->GetVolumes())
     TryToCreateAndAddIcon(volume);
 }
 
@@ -57,8 +59,8 @@
   if (map_.find(volume) != map_.end())
     return;
 
-  auto vol = std::make_shared<VolumeImp>(volume, file_manager_, device_notification_display_);
-  VolumeLauncherIcon::Ptr icon(new VolumeLauncherIcon(vol, devices_settings_));
+  auto vol = std::make_shared<VolumeImp>(volume);
+  VolumeLauncherIcon::Ptr icon(new VolumeLauncherIcon(vol, devices_settings_, device_notification_display_, file_manager_));
 
   map_[volume] = icon;
   icon_added.emit(icon);

=== modified file 'launcher/DeviceLauncherSection.h'
--- launcher/DeviceLauncherSection.h	2013-03-21 16:22:34 +0000
+++ launcher/DeviceLauncherSection.h	2013-10-07 17:26:52 +0000
@@ -37,8 +37,9 @@
 class DeviceLauncherSection : public sigc::trackable
 {
 public:
-  DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr volume_monitor,
-                        DevicesSettings::Ptr devices_settings);
+  DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr const& volume_monitor = nullptr,
+                        DevicesSettings::Ptr const& devices_settings = nullptr,
+                        DeviceNotificationDisplay::Ptr const& notifications = nullptr);
 
   std::vector<VolumeLauncherIcon::Ptr> GetIcons() const;
 

=== modified file 'launcher/LauncherController.cpp'
--- launcher/LauncherController.cpp	2013-09-24 20:18:42 +0000
+++ launcher/LauncherController.cpp	2013-10-07 17:26:52 +0000
@@ -108,7 +108,6 @@
   : parent_(parent)
   , model_(std::make_shared<LauncherModel>())
   , xdnd_manager_(xdnd_manager)
-  , device_section_(std::make_shared<VolumeMonitorWrapper>(), std::make_shared<DevicesSettingsImp>())
   , expo_icon_(new ExpoLauncherIcon())
   , desktop_icon_(new DesktopLauncherIcon())
   , edge_barriers_(edge_barriers)

=== modified file 'launcher/LauncherControllerPrivate.h'
--- launcher/LauncherControllerPrivate.h	2013-09-24 20:18:42 +0000
+++ launcher/LauncherControllerPrivate.h	2013-10-07 17:26:52 +0000
@@ -28,7 +28,6 @@
 
 #include "AbstractLauncherIcon.h"
 #include "DeviceLauncherSection.h"
-#include "DevicesSettingsImp.h"
 #ifdef USE_X11
 #include "EdgeBarrierController.h"
 #endif
@@ -39,7 +38,6 @@
 #include "LauncherModel.h"
 #include "SoftwareCenterLauncherIcon.h"
 #include "unity-shared/UBusWrapper.h"
-#include "VolumeMonitorWrapper.h"
 #include "XdndManager.h"
 
 namespace unity

=== modified file 'launcher/Volume.h'
--- launcher/Volume.h	2013-05-17 22:53:57 +0000
+++ launcher/Volume.h	2013-10-07 17:26:52 +0000
@@ -44,18 +44,21 @@
   virtual std::string GetName() const = 0;
   virtual std::string GetIconName() const = 0;
   virtual std::string GetIdentifier() const = 0;
+  virtual std::string GetUri() const = 0;
   virtual bool HasSiblings() const = 0;
   virtual bool IsMounted() const = 0;
-  virtual bool IsOpened() const = 0;
 
-  virtual void EjectAndShowNotification() = 0;
-  virtual void MountAndOpenInFileManager(uint64_t timestamp = 0) = 0;
+  virtual void Eject() = 0;
+  virtual void Mount() = 0;
   virtual void StopDrive() = 0;
   virtual void Unmount() = 0;
 
   sigc::signal<void> changed;
   sigc::signal<void> removed;
-  sigc::signal<void, bool> opened;
+  sigc::signal<void> mounted;
+  sigc::signal<void> unmounted;
+  sigc::signal<void> ejected;
+  sigc::signal<void> stopped;
 
 private:
   Volume(Volume const&) = delete;

=== modified file 'launcher/VolumeImp.cpp'
--- launcher/VolumeImp.cpp	2013-05-17 22:53:57 +0000
+++ launcher/VolumeImp.cpp	2013-10-07 17:26:52 +0000
@@ -35,16 +35,9 @@
 class VolumeImp::Impl : public sigc::trackable
 {
 public:
-  Impl(glib::Object<GVolume> const& volume,
-       FileManager::Ptr const& file_manager,
-       DeviceNotificationDisplay::Ptr const& device_notification_display,
-       VolumeImp* parent)
+  Impl(glib::Object<GVolume> const& volume, VolumeImp* parent)
     : parent_(parent)
-    , opened_(false)
-    , open_timestamp_(0)
     , volume_(volume)
-    , file_manager_(file_manager)
-    , device_notification_display_(device_notification_display)
   {
     signal_volume_changed_.Connect(volume_, "changed", [this] (GVolume*) {
       parent_->changed.emit();
@@ -53,19 +46,6 @@
     signal_volume_removed_.Connect(volume_, "removed", [this] (GVolume*) {
       parent_->removed.emit();
     });
-
-    file_manager_->locations_changed.connect(sigc::mem_fun(this, &Impl::OnLocationChanged));
-  }
-
-  void OnLocationChanged()
-  {
-    bool opened = file_manager_->IsPrefixOpened(GetUri());
-
-    if (opened_ != opened)
-    {
-      opened_ = opened;
-      parent_->opened.emit(opened_);
-    }
   }
 
   bool CanBeEjected() const
@@ -126,67 +106,29 @@
     return static_cast<bool>(mount);
   }
 
-  bool IsOpened() const
-  {
-    return opened_;
-  }
-
-  void EjectAndShowNotification()
+  void Eject()
   {
     if (!CanBeEjected())
       return;
 
     glib::Object<GMountOperation> mount_op(gtk_mount_operation_new(nullptr));
 
-    g_volume_eject_with_operation(volume_,
-                                  (GMountUnmountFlags)0,
-                                  mount_op,
-                                  cancellable_,
-                                  (GAsyncReadyCallback)OnEjectReady,
-                                  this);
-  }
-
-  static void OnEjectReady(GObject* object, GAsyncResult* result, Impl* self)
-  {
-    if (g_volume_eject_with_operation_finish(self->volume_, result, nullptr))
-    {
-      self->device_notification_display_->Display(self->GetIconName(), self->GetName());
-    }
-  }
-
-  void MountAndOpenInFileManager(uint64_t timestamp)
-  {
-    open_timestamp_ = timestamp;
-
-    if (!IsMounted())
-      MountAndOnFinishOpenInFileManager();
-    else
-      OpenInFileManager();
-  }
-
-  void MountAndOnFinishOpenInFileManager()
+    g_volume_eject_with_operation(volume_, G_MOUNT_UNMOUNT_NONE, mount_op, cancellable_,
+    [] (GObject* object, GAsyncResult* res, gpointer data) {
+      if (g_volume_eject_with_operation_finish(G_VOLUME(object), res, nullptr))
+        static_cast<Impl*>(data)->parent_->ejected.emit();
+    }, this);
+  }
+
+  void Mount()
   {
     glib::Object<GMountOperation> mount_op(gtk_mount_operation_new(nullptr));
 
-    g_volume_mount(volume_,
-                   (GMountMountFlags) 0,
-                   mount_op,
-                   cancellable_,
-                   (GAsyncReadyCallback) &Impl::OnMountFinish,
-                   this);
-  }
-
-  static void OnMountFinish(GObject* object,
-                            GAsyncResult* result,
-                            Impl* self)
-  {
-    if (g_volume_mount_finish(self->volume_, result, nullptr))
-      self->OpenInFileManager();
-  }
-
-  void OpenInFileManager()
-  {
-    file_manager_->OpenActiveChild(GetUri(), open_timestamp_);
+    g_volume_mount(volume_, G_MOUNT_MOUNT_NONE, mount_op, cancellable_,
+    [] (GObject* object, GAsyncResult* res, gpointer data) {
+      if (g_volume_mount_finish(G_VOLUME(object), res, nullptr))
+        static_cast<Impl*>(data)->parent_->mounted.emit();
+    }, this);
   }
 
   std::string GetUri() const
@@ -212,10 +154,11 @@
     glib::Object<GDrive> drive(g_volume_get_drive(volume_));
     glib::Object<GMountOperation> mount_op(gtk_mount_operation_new(NULL));
 
-    g_drive_stop(drive,
-                 (GMountUnmountFlags)0,
-                 mount_op,
-                 cancellable_, nullptr, nullptr);
+    g_drive_stop(drive, G_MOUNT_UNMOUNT_NONE, mount_op, cancellable_,
+    [] (GObject* object, GAsyncResult* res, gpointer data) {
+      if (g_drive_stop_finish(G_DRIVE(object), res, nullptr))
+        static_cast<Impl*>(data)->parent_->stopped.emit();
+    }, this);
   }
 
   void Unmount()
@@ -226,22 +169,16 @@
     glib::Object<GMount> mount(g_volume_get_mount(volume_));
     glib::Object<GMountOperation> op(gtk_mount_operation_new(nullptr));
 
-    g_mount_unmount_with_operation(mount, (GMountUnmountFlags) 0, op, cancellable_,
-                                   &VolumeImp::Impl::FinishUmount, nullptr);
-  }
-
-  static void FinishUmount(GObject* object, GAsyncResult* res, gpointer)
-  {
-    g_mount_unmount_with_operation_finish(G_MOUNT(object), res, nullptr);
+    g_mount_unmount_with_operation(mount, G_MOUNT_UNMOUNT_NONE, op, cancellable_,
+    [] (GObject* object, GAsyncResult* res, gpointer data) {
+      if (g_mount_unmount_with_operation_finish(G_MOUNT(object), res, nullptr))
+        static_cast<Impl*>(data)->parent_->unmounted.emit();
+    }, this);
   }
 
   VolumeImp* parent_;
-  bool opened_;
-  uint64_t open_timestamp_;
   glib::Cancellable cancellable_;
   glib::Object<GVolume> volume_;
-  FileManager::Ptr file_manager_;
-  DeviceNotificationDisplay::Ptr device_notification_display_;
 
   glib::Signal<void, GVolume*> signal_volume_changed_;
   glib::Signal<void, GVolume*> signal_volume_removed_;
@@ -251,10 +188,8 @@
 // End private implementation
 //
 
-VolumeImp::VolumeImp(glib::Object<GVolume> const& volume,
-                     FileManager::Ptr const& file_manager,
-                     DeviceNotificationDisplay::Ptr const& device_notification_display)
-  : pimpl(new Impl(volume, file_manager, device_notification_display, this))
+VolumeImp::VolumeImp(glib::Object<GVolume> const& volume)
+  : pimpl(new Impl(volume, this))
 {}
 
 VolumeImp::~VolumeImp()
@@ -290,6 +225,11 @@
   return pimpl->GetIdentifier();
 }
 
+std::string VolumeImp::GetUri() const
+{
+  return pimpl->GetUri();
+}
+
 bool VolumeImp::HasSiblings() const
 {
   return pimpl->HasSiblings();
@@ -300,19 +240,14 @@
   return pimpl->IsMounted();
 }
 
-bool VolumeImp::IsOpened() const
-{
-  return pimpl->IsOpened();
-}
-
-void VolumeImp::MountAndOpenInFileManager(uint64_t timestamp)
-{
-  pimpl->MountAndOpenInFileManager(timestamp);
-}
-
-void VolumeImp::EjectAndShowNotification()
-{
-  pimpl->EjectAndShowNotification();
+void VolumeImp::Mount()
+{
+  pimpl->Mount();
+}
+
+void VolumeImp::Eject()
+{
+  pimpl->Eject();
 }
 
 void VolumeImp::StopDrive()

=== modified file 'launcher/VolumeImp.h'
--- launcher/VolumeImp.h	2013-05-17 22:53:57 +0000
+++ launcher/VolumeImp.h	2013-10-07 17:26:52 +0000
@@ -26,7 +26,6 @@
 
 #include "DeviceNotificationDisplay.h"
 #include "Volume.h"
-#include "unity-shared/FileManager.h"
 
 namespace unity
 {
@@ -38,9 +37,7 @@
 public:
   typedef std::shared_ptr<VolumeImp> Ptr;
 
-  VolumeImp(glib::Object<GVolume> const& volume,
-            FileManager::Ptr const& file_manager,
-            DeviceNotificationDisplay::Ptr const& device_notification_display);
+  VolumeImp(glib::Object<GVolume> const&);
   virtual ~VolumeImp();
 
   virtual bool CanBeEjected() const;
@@ -49,12 +46,12 @@
   virtual std::string GetName() const;
   virtual std::string GetIconName() const;
   virtual std::string GetIdentifier() const;
+  virtual std::string GetUri() const;
   virtual bool HasSiblings() const;
   virtual bool IsMounted() const;
-  virtual bool IsOpened() const;
 
-  virtual void EjectAndShowNotification();
-  virtual void MountAndOpenInFileManager(uint64_t timestamp);
+  virtual void Eject();
+  virtual void Mount();
   virtual void StopDrive();
   virtual void Unmount();
 

=== modified file 'launcher/VolumeLauncherIcon.cpp'
--- launcher/VolumeLauncherIcon.cpp	2013-08-05 13:59:08 +0000
+++ launcher/VolumeLauncherIcon.cpp	2013-10-07 17:26:52 +0000
@@ -25,8 +25,6 @@
 #include <UnityCore/ConnectionManager.h>
 #include <UnityCore/GLibSignal.h>
 
-#include "DevicesSettings.h"
-#include "Volume.h"
 #include "VolumeLauncherIcon.h"
 #include "FavoriteStore.h"
 
@@ -34,12 +32,7 @@
 {
 namespace launcher
 {
-DECLARE_LOGGER(logger, "unity.launcher.icon");
-namespace
-{
-const unsigned int volume_changed_timeout = 500;
-
-}
+DECLARE_LOGGER(logger, "unity.launcher.icon.volume");
 
 //
 // Start private implementation
@@ -51,10 +44,14 @@
 
   Impl(Volume::Ptr const& volume,
        DevicesSettings::Ptr const& devices_settings,
+       DeviceNotificationDisplay::Ptr const& notification,
+       FileManager::Ptr const& fm,
        VolumeLauncherIcon* parent)
     : parent_(parent)
     , volume_(volume)
     , devices_settings_(devices_settings)
+    , notification_(notification)
+    , file_manager_(fm)
   {
     UpdateIcon();
     UpdateVisibility();
@@ -65,7 +62,7 @@
   {
     parent_->tooltip_text = volume_->GetName();
     parent_->icon_name = volume_->GetIconName();
-    parent_->SetQuirk(Quirk::RUNNING, volume_->IsOpened());
+    parent_->SetQuirk(Quirk::RUNNING, file_manager_->IsPrefixOpened(volume_->GetUri()));
   }
 
   void UpdateVisibility()
@@ -85,7 +82,7 @@
     connections_.Add(volume_->changed.connect(sigc::mem_fun(this, &Impl::OnVolumeChanged)));
     connections_.Add(volume_->removed.connect(sigc::mem_fun(this, &Impl::OnVolumeRemoved)));
     connections_.Add(devices_settings_->changed.connect(sigc::mem_fun(this, &Impl::OnSettingsChanged)));
-    connections_.Add(volume_->opened.connect(sigc::hide(sigc::mem_fun(this, &Impl::UpdateIcon))));
+    connections_.Add(file_manager_->locations_changed.connect(sigc::mem_fun(this, &Impl::UpdateIcon)));
   }
 
   void OnVolumeChanged()
@@ -114,7 +111,16 @@
 
   void EjectAndShowNotification()
   {
-    return volume_->EjectAndShowNotification();
+    if (!CanEject())
+      return;
+
+    auto conn = std::make_shared<sigc::connection>();
+    *conn = volume_->ejected.connect([this, conn] {
+      notification_->Display(volume_->GetIconName(), volume_->GetName());
+      conn->disconnect();
+    });
+    connections_.Add(*conn);
+    volume_->Eject();
   }
 
   bool CanStop() const
@@ -127,10 +133,22 @@
     volume_->StopDrive();
   }
 
-  void ActivateLauncherIcon(ActionArg arg)
+  void OpenInFileManager(uint64_t timestamp)
   {
-    parent_->SimpleLauncherIcon::ActivateLauncherIcon(arg);
-    volume_->MountAndOpenInFileManager(arg.timestamp);
+    if (!volume_->IsMounted())
+    {
+      auto conn = std::make_shared<sigc::connection>();
+      *conn = volume_->mounted.connect([this, conn, timestamp] {
+        file_manager_->OpenActiveChild(volume_->GetUri(), timestamp);
+        conn->disconnect();
+      });
+      connections_.Add(*conn);
+      volume_->Mount();
+    }
+    else
+    {
+      file_manager_->OpenActiveChild(volume_->GetUri(), timestamp);
+    }
   }
 
   MenuItemsVector GetMenus()
@@ -161,9 +179,9 @@
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
     gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
-        auto const& identifier = volume_->GetIdentifier();
-        parent_->UnStick();
-        devices_settings_->TryToBlacklist(identifier);
+      auto const& identifier = volume_->GetIdentifier();
+      parent_->UnStick();
+      devices_settings_->TryToBlacklist(identifier);
     }));
 
     menu.push_back(menu_item);
@@ -189,7 +207,7 @@
     dbusmenu_menuitem_property_set_bool(menu_item, QuicklistMenuItem::MARKUP_ENABLED_PROPERTY, true);
 
     gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) {
-        volume_->MountAndOpenInFileManager(timestamp);
+      OpenInFileManager(timestamp);
     }));
 
     menu.push_back(menu_item);
@@ -204,7 +222,7 @@
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
     gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) {
-        volume_->MountAndOpenInFileManager(timestamp);
+      OpenInFileManager(timestamp);
     }));
 
     menu.push_back(menu_item);
@@ -222,7 +240,7 @@
     dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
     gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
-        volume_->EjectAndShowNotification();
+      EjectAndShowNotification();
     }));
 
     menu.push_back(menu_item);
@@ -278,6 +296,8 @@
   bool keep_in_launcher_;
   Volume::Ptr volume_;
   DevicesSettings::Ptr devices_settings_;
+  DeviceNotificationDisplay::Ptr notification_;
+  FileManager::Ptr file_manager_;
 
   glib::SignalManager gsignals_;
   connection::Manager connections_;
@@ -288,9 +308,11 @@
 //
 
 VolumeLauncherIcon::VolumeLauncherIcon(Volume::Ptr const& volume,
-                                       DevicesSettings::Ptr const& devices_settings)
+                                       DevicesSettings::Ptr const& devices_settings,
+                                       DeviceNotificationDisplay::Ptr const& notification,
+                                       FileManager::Ptr const& fm)
   : SimpleLauncherIcon(IconType::DEVICE)
-  , pimpl_(new Impl(volume, devices_settings, this))
+  , pimpl_(new Impl(volume, devices_settings, notification, fm, this))
 {}
 
 VolumeLauncherIcon::~VolumeLauncherIcon()
@@ -326,7 +348,8 @@
 
 void VolumeLauncherIcon::ActivateLauncherIcon(ActionArg arg)
 {
-  pimpl_->ActivateLauncherIcon(arg);
+  SimpleLauncherIcon::ActivateLauncherIcon(arg);
+  pimpl_->OpenInFileManager(arg.timestamp);
 }
 
 AbstractLauncherIcon::MenuItemsVector VolumeLauncherIcon::GetMenus()

=== modified file 'launcher/VolumeLauncherIcon.h'
--- launcher/VolumeLauncherIcon.h	2013-08-05 13:59:08 +0000
+++ launcher/VolumeLauncherIcon.h	2013-10-07 17:26:52 +0000
@@ -23,7 +23,9 @@
 
 #include "Volume.h"
 #include "DevicesSettings.h"
+#include "DeviceNotificationDisplay.h"
 #include "SimpleLauncherIcon.h"
+#include "unity-shared/FileManager.h"
 
 namespace unity
 {
@@ -35,8 +37,8 @@
 public:
   typedef nux::ObjectPtr<VolumeLauncherIcon> Ptr;
 
-  VolumeLauncherIcon(Volume::Ptr const& volume,
-                     DevicesSettings::Ptr const& devices_settings);
+  VolumeLauncherIcon(Volume::Ptr const&, DevicesSettings::Ptr const&,
+                     DeviceNotificationDisplay::Ptr const&, FileManager::Ptr const&);
   virtual ~VolumeLauncherIcon();
 
   virtual void AboutToRemove();
@@ -58,7 +60,7 @@
 
 private:
   class Impl;
-  std::shared_ptr<Impl> pimpl_;
+  std::unique_ptr<Impl> pimpl_;
 };
 
 }

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2013-09-26 21:20:47 +0000
+++ tests/CMakeLists.txt	2013-10-07 17:26:52 +0000
@@ -129,6 +129,7 @@
   set (GTEST_XLESS_SOURCES
        test_main_xless.cpp
        mock-application.cpp
+       test_action_handle.cpp
        test_abstract_interface_generator.cpp
        test_animation_utils.cpp
        test_connection_manager.cpp
@@ -164,6 +165,7 @@
        test_time_util.cpp
        test_ubus.cpp
        test_unityshell_private.cpp
+       test_volume_imp.cpp
        ${UNITY_SRC}/UnityshellPrivate.cpp
        ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle.cpp
        ${CMAKE_SOURCE_DIR}/plugins/unity-mt-grab-handles/src/unity-mt-grab-handle-group.cpp
@@ -174,6 +176,7 @@
 
   set (GTEST_XLESS_LIBS
       gtest
+      test-libs-c
       unity-shared
       unity-shared-standalone
       launcher-lib
@@ -309,7 +312,6 @@
                  test_unity_settings.cpp
                  test_unity_window_style.cpp
                  test_unity_window_view.cpp
-                 test_volume_imp.cpp
                  test_volume_launcher_icon.cpp
                  test_window_buttons.cpp
                  test_xdnd_manager_imp.cpp
@@ -321,14 +323,14 @@
 
   # Build plain C files separately so they don't try to include the
   # C++ pch.
-  add_library(test-gtest-plainc STATIC
+  add_library(test-libs-c STATIC
               bamf-mock-application.c
               bamf-mock-window.c
               gmockmount.c
               gmockvolume.c
               )
   target_link_libraries(test-gtest
-                        test-gtest-plainc
+                        test-libs-c
                         gtest
                         gmock
                         unity-shared

=== modified file 'tests/gmockvolume.c'
--- tests/gmockvolume.c	2012-11-06 18:19:09 +0000
+++ tests/gmockvolume.c	2013-10-07 17:26:52 +0000
@@ -233,8 +233,8 @@
   mock_volume->last_mount_had_mount_op = (mount_operation != NULL);
   g_mock_volume_set_mount(mock_volume, G_MOUNT(g_mock_mount_new()));
 
-  callback(NULL,
-           G_ASYNC_RESULT (g_simple_async_result_new (NULL, NULL, NULL, NULL)),
+  callback(G_OBJECT (volume),
+           G_ASYNC_RESULT (g_simple_async_result_new (G_OBJECT (volume), callback, user_data, NULL)),
            user_data);
 }
 
@@ -253,10 +253,10 @@
                      GAsyncReadyCallback  callback,
                      gpointer             user_data)
 {
-  
-  callback(NULL,
-           G_ASYNC_RESULT (g_simple_async_result_new (NULL, NULL, NULL, NULL)),
-           user_data);}
+  callback(G_OBJECT (volume),
+           G_ASYNC_RESULT (g_simple_async_result_new (G_OBJECT (volume), callback, user_data, NULL)),
+           user_data);
+}
 
 static gboolean
 g_mock_volume_eject_finish (GVolume       *volume,

=== added file 'tests/test_action_handle.cpp'
--- tests/test_action_handle.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_action_handle.cpp	2013-10-07 17:26:52 +0000
@@ -0,0 +1,109 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 warranty of
+ * MERCHANTABILITY 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
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include <gmock/gmock.h>
+#include <UnityCore/ConnectionManager.h>
+#include <glib.h>
+
+using namespace unity;
+
+namespace
+{
+
+TEST(TestActionHandle, Initialization)
+{
+  action::handle handle;
+  EXPECT_EQ(handle, 0);
+
+  uint64_t val = g_random_int();
+  action::handle random = val;
+  EXPECT_EQ(random, val);
+}
+
+TEST(TestActionHandle, Assignment)
+{
+  action::handle handle;
+  ASSERT_EQ(handle, 0);
+
+  uint64_t val = g_random_int();
+  handle = val;
+  EXPECT_EQ(handle, val);
+}
+
+TEST(TestActionHandle, CastToScalarType)
+{
+  action::handle handle = 5;
+  ASSERT_EQ(handle, 5);
+
+  int int_handle = handle;
+  EXPECT_EQ(int_handle, 5);
+
+  unsigned uint_handle = handle;
+  EXPECT_EQ(uint_handle, 5);
+}
+
+TEST(TestActionHandle, PrefixIncrementOperator)
+{
+  action::handle handle;
+  ASSERT_EQ(handle, 0);
+
+  for (auto i = 1; i <= 10; ++i)
+  {
+    ASSERT_EQ(++handle, i);
+    ASSERT_EQ(handle, i);
+  }
+}
+
+TEST(TestActionHandle, PostfixIncrementOperator)
+{
+  action::handle handle;
+  ASSERT_EQ(handle, 0);
+
+  for (auto i = 1; i <= 10; ++i)
+  {
+    ASSERT_EQ(handle++, i-1);
+    ASSERT_EQ(handle, i);
+  }
+}
+
+TEST(TestActionHandle, PrefixDecrementOperator)
+{
+  action::handle handle(10);
+  ASSERT_EQ(handle, 10);
+
+  for (auto i = 10; i > 0; --i)
+  {
+    ASSERT_EQ(--handle, i-1);
+    ASSERT_EQ(handle, i-1);
+  }
+}
+
+TEST(TestActionHandle, PostfixDecrementOperator)
+{
+  action::handle handle(10);
+  ASSERT_EQ(handle, 10);
+
+  for (auto i = 10; i > 0; --i)
+  {
+    ASSERT_EQ(handle--, i);
+    ASSERT_EQ(handle, i-1);
+  }
+}
+
+} // Namespace

=== modified file 'tests/test_connection_manager.cpp'
--- tests/test_connection_manager.cpp	2013-07-01 19:36:01 +0000
+++ tests/test_connection_manager.cpp	2013-10-07 17:26:52 +0000
@@ -25,87 +25,6 @@
 
 namespace
 {
-
-TEST(TestConnectionHandle, Initialization)
-{
-  connection::handle handle;
-  EXPECT_EQ(handle, 0);
-
-  uint64_t val = g_random_int();
-  connection::handle random = val;
-  EXPECT_EQ(random, val);
-}
-
-TEST(TestConnectionHandle, Assignment)
-{
-  connection::handle handle;
-  ASSERT_EQ(handle, 0);
-
-  uint64_t val = g_random_int();
-  handle = val;
-  EXPECT_EQ(handle, val);
-}
-
-TEST(TestConnectionHandle, CastToScalarType)
-{
-  connection::handle handle = 5;
-  ASSERT_EQ(handle, 5);
-
-  int int_handle = handle;
-  EXPECT_EQ(int_handle, 5);
-
-  unsigned uint_handle = handle;
-  EXPECT_EQ(uint_handle, 5);
-}
-
-TEST(TestConnectionHandle, PrefixIncrementOperator)
-{
-  connection::handle handle;
-  ASSERT_EQ(handle, 0);
-
-  for (auto i = 1; i <= 10; ++i)
-  {
-    ASSERT_EQ(++handle, i);
-    ASSERT_EQ(handle, i);
-  }
-}
-
-TEST(TestConnectionHandle, PostfixIncrementOperator)
-{
-  connection::handle handle;
-  ASSERT_EQ(handle, 0);
-
-  for (auto i = 1; i <= 10; ++i)
-  {
-    ASSERT_EQ(handle++, i-1);
-    ASSERT_EQ(handle, i);
-  }
-}
-
-TEST(TestConnectionHandle, PrefixDecrementOperator)
-{
-  connection::handle handle(10);
-  ASSERT_EQ(handle, 10);
-
-  for (auto i = 10; i > 0; --i)
-  {
-    ASSERT_EQ(--handle, i-1);
-    ASSERT_EQ(handle, i-1);
-  }
-}
-
-TEST(TestConnectionHandle, PostfixDecrementOperator)
-{
-  connection::handle handle(10);
-  ASSERT_EQ(handle, 10);
-
-  for (auto i = 10; i > 0; --i)
-  {
-    ASSERT_EQ(handle--, i);
-    ASSERT_EQ(handle, i-1);
-  }
-}
-
 connection::handle global_handle = 0;
 
 struct SignalerObject

=== modified file 'tests/test_device_launcher_section.cpp'
--- tests/test_device_launcher_section.cpp	2013-07-10 01:01:02 +0000
+++ tests/test_device_launcher_section.cpp	2013-10-07 17:26:52 +0000
@@ -52,13 +52,15 @@
 struct TestDeviceLauncherSection : Test
 {
   TestDeviceLauncherSection()
-    : monitor_(new MockVolumeMonitorWrapper)
-    , devices_settings_(new NiceMock<MockDevicesSettings>())
-    , section_(monitor_, devices_settings_)
+    : monitor_(std::make_shared<MockVolumeMonitorWrapper>())
+    , devices_settings_(std::make_shared<NiceMock<MockDevicesSettings>>())
+    , notifications_(std::make_shared<MockDeviceNotificationDisplay::Nice>())
+    , section_(monitor_, devices_settings_, notifications_)
   {}
 
   MockVolumeMonitorWrapper::Ptr monitor_;
   DevicesSettings::Ptr devices_settings_;
+  DeviceNotificationDisplay::Ptr notifications_;
   DeviceLauncherSection section_;
 };
 

=== modified file 'tests/test_icon_loader.cpp'
--- tests/test_icon_loader.cpp	2013-09-18 20:11:56 +0000
+++ tests/test_icon_loader.cpp	2013-10-07 17:26:52 +0000
@@ -97,12 +97,12 @@
 
   void TearDown() override
   {
-    for (int handle : handles_)
+    for (auto handle : handles_)
       icon_loader.DisconnectHandle(handle);
   }
 
   IconLoader& icon_loader;
-  std::vector<int> handles_;
+  std::vector<IconLoader::Handle> handles_;
 };
 
 TEST_F(TestIconLoader, TestGetDefault)
@@ -115,7 +115,7 @@
 {
   LoadResult load_result;
 
-  int handle = icon_loader.LoadFromIconName("python", -1, 48, sigc::mem_fun(load_result,
+  auto handle = icon_loader.LoadFromIconName("python", -1, 48, sigc::mem_fun(load_result,
         &LoadResult::IconLoaded));
   handles_.push_back(handle);
 
@@ -129,7 +129,7 @@
 {
   LoadResult load_result;
 
-  int handle = icon_loader.LoadFromGIconString(". UnityProtocolAnnotatedIcon %7B'base-icon':%20%3C'cmake'%3E,%20'ribbon':%20%3C'foo'%3E%7D", -1, 48, sigc::mem_fun(load_result,
+  auto handle = icon_loader.LoadFromGIconString(". UnityProtocolAnnotatedIcon %7B'base-icon':%20%3C'cmake'%3E,%20'ribbon':%20%3C'foo'%3E%7D", -1, 48, sigc::mem_fun(load_result,
         &LoadResult::IconLoaded));
   handles_.push_back(handle);
 
@@ -143,7 +143,7 @@
 {
   LoadResult load_result;
 
-  int handle = icon_loader.LoadFromGIconString(". UnityProtocolAnnotatedIcon %7B'base-icon':%20%3C'cmake'%3E,%20'colorize-value':%20%3Cuint32%204278190335%3E%7D", -1, 48, sigc::mem_fun(load_result,
+  auto handle = icon_loader.LoadFromGIconString(". UnityProtocolAnnotatedIcon %7B'base-icon':%20%3C'cmake'%3E,%20'colorize-value':%20%3Cuint32%204278190335%3E%7D", -1, 48, sigc::mem_fun(load_result,
         &LoadResult::IconLoaded));
   handles_.push_back(handle);
 
@@ -155,7 +155,7 @@
 TEST_F(TestIconLoader, TestGetOneIconManyTimes)
 {
   std::vector<LoadResult> results;
-  std::vector<int> handles;
+  std::vector<IconLoader::Handle> handles;
   int i, load_count;
 
   // 100 times should be good
@@ -208,7 +208,7 @@
 TEST_F(TestIconLoader, TestCancelSome)
 {
   std::vector<LoadResult> results;
-  std::vector<int> handles;
+  std::vector<IconLoader::Handle> handles;
   int i = 0;
   int icon_count;
 

=== modified file 'tests/test_launcher_controller.cpp'
--- tests/test_launcher_controller.cpp	2013-09-25 00:48:03 +0000
+++ tests/test_launcher_controller.cpp	2013-10-07 17:26:52 +0000
@@ -39,6 +39,7 @@
 #include "test_utils.h"
 #include "test_uscreen_mock.h"
 #include "test_mock_devices.h"
+#include "test_mock_filemanager.h"
 #include "mock-application.h"
 
 
@@ -178,7 +179,9 @@
 
   MockVolumeLauncherIcon()
     : VolumeLauncherIcon(Volume::Ptr(volume_ = new NiceMock<MockVolume>()),
-                         std::make_shared<NiceMock<MockDevicesSettings>>())
+                         std::make_shared<MockDevicesSettings::Nice>(),
+                         std::make_shared<MockDeviceNotificationDisplay::Nice>(),
+                         std::make_shared<MockFileManager::Nice>())
     , uuid_(std::to_string(g_random_int()))
   {
     ON_CALL(*volume_, GetIdentifier()).WillByDefault(Return(uuid_));
@@ -1266,7 +1269,7 @@
   EXPECT_CALL(*(device_icon->volume_), CanBeStopped())
       .WillRepeatedly(Return(true));
 
-  EXPECT_CALL(*(device_icon->volume_), EjectAndShowNotification());
+  EXPECT_CALL(*(device_icon->volume_), Eject());
   EXPECT_CALL(*(device_icon->volume_), StopDrive()).Times(0);
 
   lc.launcher().remove_request.emit(device_icon);
@@ -1282,7 +1285,7 @@
       .WillRepeatedly(Return(true));
 
   EXPECT_CALL(*(device_icon->volume_), StopDrive());
-  EXPECT_CALL(*(device_icon->volume_), EjectAndShowNotification()).Times(0);
+  EXPECT_CALL(*(device_icon->volume_), Eject()).Times(0);
 
   lc.launcher().remove_request.emit(device_icon);
 }

=== modified file 'tests/test_mock_devices.h'
--- tests/test_mock_devices.h	2013-05-17 22:53:57 +0000
+++ tests/test_mock_devices.h	2013-10-07 17:26:52 +0000
@@ -34,6 +34,8 @@
 
 namespace unity
 {
+namespace
+{
 
 struct MockVolumeMonitorWrapper : public AbstractVolumeMonitorWrapper
 {
@@ -56,6 +58,7 @@
 struct MockDevicesSettings : DevicesSettings
 {
   typedef std::shared_ptr<MockDevicesSettings> Ptr;
+  typedef testing::NiceMock<MockDevicesSettings> Nice;
 
   MOCK_CONST_METHOD1(IsABlacklistedDevice, bool(std::string const& uuid));
   MOCK_METHOD1(TryToBlacklist, void(std::string const& uuid));
@@ -70,27 +73,36 @@
   {}
 };
 
-class MockVolume : public Volume
+struct MockVolume : Volume
 {
-public:
   typedef std::shared_ptr<MockVolume> Ptr;
+  typedef testing::NiceMock<MockVolume> Nice;
 
   MOCK_CONST_METHOD0(CanBeRemoved, bool(void));
   MOCK_CONST_METHOD0(CanBeStopped, bool(void));
   MOCK_CONST_METHOD0(GetName, std::string(void));
   MOCK_CONST_METHOD0(GetIconName, std::string(void));
   MOCK_CONST_METHOD0(GetIdentifier, std::string(void));
+  MOCK_CONST_METHOD0(GetUri, std::string(void));
   MOCK_CONST_METHOD0(HasSiblings, bool(void));
   MOCK_CONST_METHOD0(CanBeEjected, bool(void));
   MOCK_CONST_METHOD0(IsMounted, bool(void));
-  MOCK_CONST_METHOD0(IsOpened, bool(void));
 
-  MOCK_METHOD0(EjectAndShowNotification, void(void));
-  MOCK_METHOD1(MountAndOpenInFileManager, void(uint64_t));
+  MOCK_METHOD0(Eject, void());
+  MOCK_METHOD0(Mount, void());
   MOCK_METHOD0(StopDrive, void(void));
   MOCK_METHOD0(Unmount, void(void));
 };
 
-}
+struct MockDeviceNotificationDisplay : DeviceNotificationDisplay
+{
+  typedef std::shared_ptr<MockDeviceNotificationDisplay> Ptr;
+  typedef testing::NiceMock<MockDeviceNotificationDisplay> Nice;
+
+  MOCK_METHOD2(Display, void(std::string const& icon_name, std::string const& volume_name));
+};
+
+} // anonymous namespace
+} // unity namespace
 
 #endif

=== modified file 'tests/test_mock_filemanager.h'
--- tests/test_mock_filemanager.h	2013-09-05 16:22:56 +0000
+++ tests/test_mock_filemanager.h	2013-10-07 17:26:52 +0000
@@ -20,6 +20,7 @@
 #ifndef TEST_MOCK_FILEMANAGER_H
 #define TEST_MOCK_FILEMANAGER_H
 
+#include <gmock/gmock.h>
 #include "FileManager.h"
 
 namespace unity
@@ -28,6 +29,7 @@
 struct MockFileManager : FileManager
 {
   typedef std::shared_ptr<MockFileManager> Ptr;
+  typedef testing::NiceMock<MockFileManager> Nice;
 
   MOCK_METHOD2(Open, void(std::string const& uri, uint64_t time));
   MOCK_METHOD2(OpenActiveChild, void(std::string const& uri, uint64_t time));

=== modified file 'tests/test_volume_imp.cpp'
--- tests/test_volume_imp.cpp	2013-05-17 22:53:57 +0000
+++ tests/test_volume_imp.cpp	2013-10-07 17:26:52 +0000
@@ -25,46 +25,27 @@
 #include "gmockmount.h"
 #include "gmockvolume.h"
 #include "launcher/VolumeImp.h"
-#include "test_utils.h"
-#include "test_mock_filemanager.h"
 using namespace unity;
 
 namespace
 {
-
-class MockDeviceNotificationDisplay : public launcher::DeviceNotificationDisplay
-{
-public:
-  typedef std::shared_ptr<MockDeviceNotificationDisplay> Ptr;
-
-  MOCK_METHOD2(Display, void(std::string const& icon_name, std::string const& device_name));
-};
-
-class TestVolumeImp : public Test
-{
-public:
-  void SetUp()
-  {
-    gvolume_ = g_mock_volume_new();
-    file_manager_.reset(new NiceMock<MockFileManager>);
-    device_notification_display_.reset(new MockDeviceNotificationDisplay);
-    volume_.reset(new launcher::VolumeImp(glib::Object<GVolume>(G_VOLUME(gvolume_.RawPtr()), glib::AddRef()),
-                                          file_manager_, device_notification_display_));
-  }
+struct TestVolumeImp : Test
+{
+  TestVolumeImp()
+    : gvolume_(g_mock_volume_new())
+    , volume_(std::make_shared<launcher::VolumeImp>(glib::object_cast<GVolume>(gvolume_)))
+  {}
 
   glib::Object<GMockVolume> gvolume_;
-  MockFileManager::Ptr file_manager_;
-  MockDeviceNotificationDisplay::Ptr device_notification_display_;
   launcher::VolumeImp::Ptr volume_;
 };
 
-TEST_F(TestVolumeImp, TestCtor)
+TEST_F(TestVolumeImp, Ctor)
 {
   EXPECT_FALSE(volume_->IsMounted());
-  EXPECT_FALSE(volume_->IsOpened());
 }
 
-TEST_F(TestVolumeImp, TestCanBeEjected)
+TEST_F(TestVolumeImp, CanBeEjected)
 {
   EXPECT_FALSE(volume_->CanBeEjected());
 
@@ -72,7 +53,7 @@
   EXPECT_TRUE(volume_->CanBeEjected());
 }
 
-TEST_F(TestVolumeImp, TestGetName)
+TEST_F(TestVolumeImp, GetName)
 {
   std::string const volume_name("Test Device");
 
@@ -82,7 +63,7 @@
   EXPECT_EQ(volume_->GetName(), volume_name);
 }
 
-TEST_F(TestVolumeImp, TestGetIconName)
+TEST_F(TestVolumeImp, GetIconName)
 {
   std::string const icon_name("gnome-dev-cdrom");
 
@@ -90,7 +71,7 @@
   EXPECT_EQ(volume_->GetIconName(), icon_name);
 }
 
-TEST_F(TestVolumeImp, TestGetIdentifier)
+TEST_F(TestVolumeImp, GetIdentifier)
 {
   std::string const uuid = "uuid";
   std::string const label = "label";
@@ -101,7 +82,12 @@
   EXPECT_EQ(volume_->GetIdentifier(), uuid + "-" + label);
 }
 
-TEST_F(TestVolumeImp, TestIsMounted)
+TEST_F(TestVolumeImp, GetUriUnMounted)
+{
+  EXPECT_TRUE(volume_->GetUri().empty());
+}
+
+TEST_F(TestVolumeImp, IsMounted)
 {
   g_mock_volume_set_mount(gvolume_, nullptr);
   ASSERT_FALSE(volume_->IsMounted());
@@ -110,65 +96,26 @@
   EXPECT_TRUE(volume_->IsMounted());
 }
 
-TEST_F(TestVolumeImp, TestIsOpened)
-{
-  volume_->MountAndOpenInFileManager(0);
-
-  EXPECT_CALL(*file_manager_, IsPrefixOpened(ROOT_FILE_URI));
-  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(true));
-  file_manager_->locations_changed.emit();
-  EXPECT_TRUE(volume_->IsOpened());
-
-  EXPECT_CALL(*file_manager_, IsPrefixOpened(ROOT_FILE_URI));
-  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(false));
-  file_manager_->locations_changed.emit();
-  EXPECT_FALSE(volume_->IsOpened());
-}
-
-TEST_F(TestVolumeImp, TestIsOpenedSignal)
-{
-  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(false));
-
-  bool opened = false;
-  volume_->opened.connect([&opened] (bool value) { opened = value; });
-  file_manager_->locations_changed.emit();
-
-  ASSERT_FALSE(opened);
-
-  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(true));
-  file_manager_->locations_changed.emit();
-  EXPECT_TRUE(opened);
-}
-
-TEST_F(TestVolumeImp, TestFilemanagerSignalDisconnection)
-{
-  ASSERT_FALSE(file_manager_->locations_changed.empty());
-  volume_.reset();
-
-  EXPECT_TRUE(file_manager_->locations_changed.empty());
-}
-
-TEST_F(TestVolumeImp, TestEjectAndShowNotification)
-{
+TEST_F(TestVolumeImp, Eject)
+{
+  bool ejected = false;
   g_mock_volume_set_can_eject(gvolume_, TRUE);
-
-  EXPECT_CALL(*device_notification_display_, Display(volume_->GetIconName(), volume_->GetName()))
-    .Times(1);
-
-  volume_->EjectAndShowNotification();
+  volume_->ejected.connect([&ejected] { ejected = true; });
+  volume_->Eject();
+  EXPECT_TRUE(ejected);
 }
 
-TEST_F(TestVolumeImp, TestMountAndOpenInFileManager)
+TEST_F(TestVolumeImp, Mount)
 {
-  uint64_t time = g_random_int();
-  EXPECT_CALL(*file_manager_, OpenActiveChild(ROOT_FILE_URI, time));
-
-  volume_->MountAndOpenInFileManager(time);
+  bool mounted = false;
+  volume_->mounted.connect([&mounted] { mounted = true; });
+  volume_->Mount();
   EXPECT_EQ(g_mock_volume_last_mount_had_mount_operation(gvolume_), TRUE);
   EXPECT_TRUE(volume_->IsMounted());
+  EXPECT_TRUE(mounted);
 }
 
-TEST_F(TestVolumeImp, TestChangedSignal)
+TEST_F(TestVolumeImp, ChangedSignal)
 {
   bool callback_called = false;
   volume_->changed.connect([&]() {
@@ -176,10 +123,10 @@
   });
 
   g_signal_emit_by_name(gvolume_, "changed", nullptr);
-  Utils::WaitUntil(callback_called);
+  EXPECT_TRUE(callback_called);
 }
 
-TEST_F(TestVolumeImp, TestRemovedSignal)
+TEST_F(TestVolumeImp, RemovedSignal)
 {
   bool callback_called = false;
   volume_->removed.connect([&]() {
@@ -187,7 +134,7 @@
   });
 
   g_signal_emit_by_name(gvolume_, "removed", nullptr);
-  Utils::WaitUntil(callback_called);
+  EXPECT_TRUE(callback_called);
 }
 
 }

=== modified file 'tests/test_volume_launcher_icon.cpp'
--- tests/test_volume_launcher_icon.cpp	2013-05-17 22:53:57 +0000
+++ tests/test_volume_launcher_icon.cpp	2013-10-07 17:26:52 +0000
@@ -25,6 +25,7 @@
 #include "FavoriteStore.h"
 #include "test_utils.h"
 #include "test_mock_devices.h"
+#include "test_mock_filemanager.h"
 using namespace unity;
 using namespace unity::launcher;
 
@@ -33,18 +34,19 @@
 
 struct TestVolumeLauncherIcon : public Test
 {
-  virtual void SetUp()
+  TestVolumeLauncherIcon()
+    : volume_(std::make_shared<MockVolume::Nice>())
+    , settings_(std::make_shared<MockDevicesSettings::Nice>())
+    , notifications_(std::make_shared<MockDeviceNotificationDisplay::Nice>())
+    , file_manager_(std::make_shared<MockFileManager::Nice>())
   {
-    volume_.reset(new NiceMock<MockVolume>);
-    settings_.reset(new NiceMock<MockDevicesSettings>);
-
     SetupVolumeDefaultBehavior();
     SetupSettingsDefaultBehavior();
   }
 
   void CreateIcon()
   {
-    icon_ = new NiceMock<VolumeLauncherIcon>(volume_, settings_);
+    icon_ = new NiceMock<VolumeLauncherIcon>(volume_, settings_, notifications_, file_manager_);
   }
 
   void SetupSettingsDefaultBehavior()
@@ -59,10 +61,14 @@
     ON_CALL(*volume_, GetName()).WillByDefault(Return("Test Name"));
     ON_CALL(*volume_, GetIconName()).WillByDefault(Return("Test Icon Name"));
     ON_CALL(*volume_, GetIdentifier()).WillByDefault(Return("Test Identifier"));
+    ON_CALL(*volume_, GetUri()).WillByDefault(Return("file:///media/user/device_uri"));
     ON_CALL(*volume_, HasSiblings()).WillByDefault(Return(false));
     ON_CALL(*volume_, CanBeEjected()).WillByDefault(Return(false));
     ON_CALL(*volume_, IsMounted()).WillByDefault(Return(true));
-    ON_CALL(*volume_, IsOpened()) .WillByDefault(Return(true));
+    ON_CALL(*volume_, Mount()).WillByDefault(Invoke([this] { volume_->mounted.emit(); }));
+    ON_CALL(*volume_, Unmount()).WillByDefault(Invoke([this] { volume_->unmounted.emit(); }));
+    ON_CALL(*volume_, Eject()).WillByDefault(Invoke([this] { volume_->ejected.emit(); }));
+    ON_CALL(*volume_, StopDrive()).WillByDefault(Invoke([this] { volume_->stopped.emit(); }));
   }
 
   glib::Object<DbusmenuMenuitem> GetMenuItemAtIndex(int index)
@@ -76,6 +82,8 @@
 
   MockVolume::Ptr volume_;
   MockDevicesSettings::Ptr settings_;
+  MockDeviceNotificationDisplay::Ptr notifications_;
+  MockFileManager::Ptr file_manager_;
   VolumeLauncherIcon::Ptr icon_;
   std::string old_lang_;
 };
@@ -86,26 +94,47 @@
   EXPECT_EQ(icon_->GetIconType(), AbstractLauncherIcon::IconType::DEVICE);
 }
 
-TEST_F(TestVolumeLauncherIcon, TestQuirks)
-{
-  CreateIcon();
-
-  EXPECT_EQ(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING), volume_->IsOpened());
-}
-
-TEST_F(TestVolumeLauncherIcon, TestRunningStateUpdatesOnOpenedState)
-{
-  CreateIcon();
-
-  ON_CALL(*volume_, IsOpened()).WillByDefault(Return(false));
-  volume_->opened.emit(volume_->IsOpened());
-  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
-
-  ON_CALL(*volume_, IsOpened()).WillByDefault(Return(true));
-  volume_->opened.emit(volume_->IsOpened());
-  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
-}
-
+TEST_F(TestVolumeLauncherIcon, TestRunningOnClosed)
+{
+  ON_CALL(*file_manager_, IsPrefixOpened(volume_->GetUri())).WillByDefault(Return(false));
+  CreateIcon();
+
+  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestRunningOnOpened)
+{
+  ON_CALL(*file_manager_, IsPrefixOpened(volume_->GetUri())).WillByDefault(Return(true));
+  CreateIcon();
+
+  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
+
+TEST_F(TestVolumeLauncherIcon, FilemanagerSignalDisconnection)
+{
+  CreateIcon();
+  ASSERT_FALSE(file_manager_->locations_changed.empty());
+  icon_ = nullptr;
+  EXPECT_TRUE(file_manager_->locations_changed.empty());
+}
+
+TEST_F(TestVolumeLauncherIcon, TestRunningStateOnLocationChangedClosed)
+{
+  CreateIcon();
+
+  ON_CALL(*file_manager_, IsPrefixOpened(volume_->GetUri())).WillByDefault(Return(false));
+  file_manager_->locations_changed.emit();
+  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestRunningStateOnLocationChangedOpened)
+{
+  CreateIcon();
+
+  ON_CALL(*file_manager_, IsPrefixOpened(volume_->GetUri())).WillByDefault(Return(true));
+  file_manager_->locations_changed.emit();
+  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
 
 TEST_F(TestVolumeLauncherIcon, TestPosition)
 {
@@ -281,8 +310,10 @@
   EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
   EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
 
+  ON_CALL(*volume_, IsMounted()).WillByDefault(Return(false));
   uint64_t time = g_random_int();
-  EXPECT_CALL(*volume_, MountAndOpenInFileManager(time));
+  EXPECT_CALL(*volume_, Mount());
+  EXPECT_CALL(*file_manager_, OpenActiveChild(volume_->GetUri(), time));
 
   dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, time);
 }
@@ -299,7 +330,9 @@
   EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, QuicklistMenuItem::MARKUP_ENABLED_PROPERTY));
 
   uint64_t time = g_random_int();
-  EXPECT_CALL(*volume_, MountAndOpenInFileManager(time));
+  ON_CALL(*volume_, IsMounted()).WillByDefault(Return(false));
+  EXPECT_CALL(*volume_, Mount());
+  EXPECT_CALL(*file_manager_, OpenActiveChild(volume_->GetUri(), time));
 
   dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, time);
 }
@@ -321,8 +354,8 @@
 
   auto menuitem = GetMenuItemAtIndex(5);
 
-  EXPECT_CALL(*volume_, EjectAndShowNotification())
-    .Times(1);
+  EXPECT_CALL(*volume_, Eject());
+  EXPECT_CALL(*notifications_, Display(volume_->GetIconName(), volume_->GetName()));
 
   ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Eject");
   EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
@@ -438,9 +471,8 @@
 
   CreateIcon();
 
-  EXPECT_CALL(*volume_, EjectAndShowNotification())
-    .Times(1);
-
+  EXPECT_CALL(*volume_, Eject());
+  EXPECT_CALL(*notifications_, Display(volume_->GetIconName(), volume_->GetName()));
   icon_->EjectAndShowNotification();
 }
 
@@ -532,12 +564,24 @@
   EXPECT_TRUE(forgot);
 }
 
-TEST_F(TestVolumeLauncherIcon, Activate)
-{
-  CreateIcon();
-
-  uint64_t time = g_random_int();
-  EXPECT_CALL(*volume_, MountAndOpenInFileManager(time));
+TEST_F(TestVolumeLauncherIcon, ActivateMounted)
+{
+  CreateIcon();
+
+  uint64_t time = g_random_int();
+  EXPECT_CALL(*volume_, Mount()).Times(0);
+  EXPECT_CALL(*file_manager_, OpenActiveChild(volume_->GetUri(), time));
+  icon_->Activate(ActionArg(ActionArg::Source::LAUNCHER, 0, time));
+}
+
+TEST_F(TestVolumeLauncherIcon, ActivateUnmounted)
+{
+  CreateIcon();
+
+  uint64_t time = g_random_int();
+  ON_CALL(*volume_, IsMounted()).WillByDefault(Return(false));
+  EXPECT_CALL(*volume_, Mount());
+  EXPECT_CALL(*file_manager_, OpenActiveChild(volume_->GetUri(), time));
   icon_->Activate(ActionArg(ActionArg::Source::LAUNCHER, 0, time));
 }
 

=== modified file 'unity-shared/GnomeFileManager.cpp'
--- unity-shared/GnomeFileManager.cpp	2013-09-05 16:22:56 +0000
+++ unity-shared/GnomeFileManager.cpp	2013-10-07 17:26:52 +0000
@@ -34,8 +34,12 @@
 DECLARE_LOGGER(logger, "unity.filemanager.gnome");
 
 const std::string TRASH_URI = "trash:";
-const std::string TRASH_PATH = "file://" + DesktopUtilities::GetUserDataDirectory() + "/Trash/files";
-const std::string DEVICES_PREFIX = "file:///media/" + std::string(g_get_user_name());
+const std::string FILE_SCHEMA = "file://";
+const std::string TRASH_PATH = FILE_SCHEMA + DesktopUtilities::GetUserDataDirectory() + "/Trash/files";
+const std::string DEVICES_PREFIX = FILE_SCHEMA + "/media/" + std::string(g_get_user_name());
+
+const std::string NAUTILUS_NAME = "org.gnome.Nautilus";
+const std::string NAUTILUS_PATH = "/org/gnome/Nautilus";
 }
 
 struct GnomeFileManager::Impl
@@ -93,6 +97,12 @@
     return "";
   }
 
+  glib::DBusProxy::Ptr NautilusOperationsProxy() const
+  {
+    return std::make_shared<glib::DBusProxy>(NAUTILUS_NAME, NAUTILUS_PATH,
+                                             "org.gnome.Nautilus.FileOperations");
+  }
+
   GnomeFileManager* parent_;
   glib::DBusProxy filemanager_proxy_;
   std::vector<std::string> opened_locations_;
@@ -170,9 +180,8 @@
       gdk_app_launch_context_set_timestamp(context, timestamp);
 
     auto const& gcontext = glib::object_cast<GAppLaunchContext>(context);
-    auto proxy = std::make_shared<glib::DBusProxy>("org.gnome.NautilusApplication",
-                                                   "/org/gnome/NautilusApplication",
-                                                   "org.gtk.Application");
+    auto proxy = std::make_shared<glib::DBusProxy>(NAUTILUS_NAME, NAUTILUS_PATH,
+                                                   "org.freedesktop.Application");
 
     glib::String context_string(g_app_launch_context_get_startup_notify_id(gcontext, app_info, nullptr));
 
@@ -205,9 +214,7 @@
 void GnomeFileManager::EmptyTrash(uint64_t timestamp)
 {
   Activate(timestamp);
-
-  auto proxy = std::make_shared<glib::DBusProxy>("org.gnome.Nautilus", "/org/gnome/Nautilus",
-                                                 "org.gnome.Nautilus.FileOperations");
+  auto const& proxy = impl_->NautilusOperationsProxy();
 
   // Passing the proxy to the lambda we ensure that it will be destroyed when needed
   proxy->CallBegin("EmptyTrash", nullptr, [proxy] (GVariant*, glib::Error const&) {});

=== modified file 'unity-shared/IconLoader.cpp'
--- unity-shared/IconLoader.cpp	2013-08-27 16:22:40 +0000
+++ unity-shared/IconLoader.cpp	2013-10-07 17:26:52 +0000
@@ -48,35 +48,17 @@
 class IconLoader::Impl
 {
 public:
-  // The Handle typedef is used to explicitly indicate which integers are
-  // infact our opaque handles.
-  typedef int Handle;
   static const int FONT_SIZE = 8;
   static const int MIN_FONT_SIZE = 5;
 
   Impl();
 
-  Handle LoadFromIconName(std::string const& icon_name,
-                          int max_width,
-                          int max_height,
-                          IconLoaderCallback slot);
-
-  Handle LoadFromGIconString(std::string const& gicon_string,
-                             int max_width,
-                             int max_height,
-                             IconLoaderCallback slot);
-
-  Handle LoadFromFilename(std::string const& filename,
-                          int max_width,
-                          int max_height,
-                          IconLoaderCallback slot);
-
-  Handle LoadFromURI(std::string const& uri,
-                     int max_width,
-                     int max_height,
-                     IconLoaderCallback slot);
-
-  void DisconnectHandle(Handle handle);
+  Handle LoadFromIconName(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+  Handle LoadFromGIconString(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+  Handle LoadFromFilename(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+  Handle LoadFromURI(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+
+  void DisconnectHandle(Handle);
 
   static void CalculateTextHeight(int* width, int* height);
 
@@ -103,7 +85,7 @@
     Impl* impl;
     gtk::IconInfo icon_info;
     bool no_cache;
-    int helper_handle;
+    Handle helper_handle;
     std::list<IconLoaderTask::Ptr> shadow_tasks;
     glib::Object<GdkPixbuf> result;
     glib::Error error;
@@ -114,7 +96,7 @@
                    int max_width_,
                    int max_height_,
                    std::string const& key_,
-                   IconLoaderCallback slot_,
+                   IconLoaderCallback const& slot_,
                    Handle handle_,
                    Impl* self_)
       : type(type_), data(data_), max_width(max_width_)
@@ -797,14 +779,14 @@
   Handle ReturnCachedOrQueue(std::string const& data,
                              int max_width,
                              int max_height,
-                             IconLoaderCallback slot,
+                             IconLoaderCallback const& slot,
                              IconLoaderRequestType type);
 
   Handle QueueTask(std::string const& key,
                    std::string const& data,
                    int max_width,
                    int max_height,
-                   IconLoaderCallback slot,
+                   IconLoaderCallback const& slot,
                    IconLoaderRequestType type);
 
   std::string Hash(std::string const& data, int max_width, int max_height);
@@ -813,7 +795,7 @@
                    std::string const& data,
                    int max_width,
                    int max_height,
-                   IconLoaderCallback slot);
+                   IconLoaderCallback const& slot);
 
   // Looping idle callback function
   bool Iteration();
@@ -830,7 +812,7 @@
    * in the future... You've been warned! */
   std::map<std::string, IconLoaderTask::Ptr> queued_tasks_;
   std::queue<IconLoaderTask::Ptr> tasks_;
-  std::map<Handle, IconLoaderTask::Ptr> task_map_;
+  std::unordered_map<Handle, IconLoaderTask::Ptr> task_map_;
   std::vector<IconLoaderTask*> finished_tasks_;
 
   bool no_load_;
@@ -869,15 +851,12 @@
 #endif
 }
 
-int IconLoader::Impl::LoadFromIconName(std::string const& icon_name,
-                                       int max_width,
-                                       int max_height,
-                                       IconLoaderCallback slot)
+IconLoader::Handle IconLoader::Impl::LoadFromIconName(std::string const& icon_name, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   if (no_load_ || icon_name.empty() || !slot ||
       ((max_width >= 0 && max_width < MIN_ICON_SIZE) ||
        (max_height >= 0 && max_height < MIN_ICON_SIZE)))
-    return 0;
+    return Handle();
 
   // We need to check this because of legacy desktop files
   if (icon_name[0] == '/')
@@ -889,29 +868,23 @@
                              REQUEST_TYPE_ICON_NAME);
 }
 
-int IconLoader::Impl::LoadFromGIconString(std::string const& gicon_string,
-                                          int max_width,
-                                          int max_height,
-                                          IconLoaderCallback slot)
+IconLoader::Handle IconLoader::Impl::LoadFromGIconString(std::string const& gicon_string, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   if (no_load_ || gicon_string.empty() || !slot ||
       ((max_width >= 0 && max_width < MIN_ICON_SIZE) ||
        (max_height >= 0 && max_height < MIN_ICON_SIZE)))
-    return 0;
+    return Handle();
 
   return ReturnCachedOrQueue(gicon_string, max_width, max_height, slot,
                              REQUEST_TYPE_GICON_STRING);
 }
 
-int IconLoader::Impl::LoadFromFilename(std::string const& filename,
-                                       int max_width,
-                                       int max_height,
-                                       IconLoaderCallback slot)
+IconLoader::Handle IconLoader::Impl::LoadFromFilename(std::string const& filename, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   if (no_load_ || filename.empty() || !slot ||
       ((max_width >= 0 && max_width < MIN_ICON_SIZE) ||
        (max_height >= 0 && max_height < MIN_ICON_SIZE)))
-    return 0;
+    return Handle();
 
   glib::Object<GFile> file(::g_file_new_for_path(filename.c_str()));
   glib::String uri(::g_file_get_uri(file));
@@ -919,15 +892,12 @@
   return LoadFromURI(uri.Str(), max_width, max_height, slot);
 }
 
-int IconLoader::Impl::LoadFromURI(std::string const& uri,
-                                  int max_width,
-                                  int max_height,
-                                  IconLoaderCallback slot)
+IconLoader::Handle IconLoader::Impl::LoadFromURI(std::string const& uri, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   if (no_load_ || uri.empty() || !slot ||
       ((max_width >= 0 && max_width < MIN_ICON_SIZE) ||
        (max_height >= 0 && max_height < MIN_ICON_SIZE)))
-    return 0;
+    return Handle();
 
   return ReturnCachedOrQueue(uri, max_width, max_height, slot,
                              REQUEST_TYPE_URI);
@@ -983,29 +953,19 @@
 // Private Methods
 //
 
-int IconLoader::Impl::ReturnCachedOrQueue(std::string const& data,
-                                          int max_width,
-                                          int max_height,
-                                          IconLoaderCallback slot,
-                                          IconLoaderRequestType type)
+IconLoader::Handle IconLoader::Impl::ReturnCachedOrQueue(std::string const& data, int max_width, int max_height, IconLoaderCallback const& slot, IconLoaderRequestType type)
 {
-  Handle result = 0;
   std::string key(Hash(data, max_width, max_height));
 
   if (!CacheLookup(key, data, max_width, max_height, slot))
   {
-    result = QueueTask(key, data, max_width, max_height, slot, type);
+    return QueueTask(key, data, max_width, max_height, slot, type);
   }
-  return result;
+  return Handle();
 }
 
 
-int IconLoader::Impl::QueueTask(std::string const& key,
-                                std::string const& data,
-                                int max_width,
-                                int max_height,
-                                IconLoaderCallback slot,
-                                IconLoaderRequestType type)
+IconLoader::Handle IconLoader::Impl::QueueTask(std::string const& key, std::string const& data, int max_width, int max_height, IconLoaderCallback const& slot, IconLoaderRequestType type)
 {
   auto task = std::make_shared<IconLoaderTask>(type, data,
                                                max_width, max_height,
@@ -1056,7 +1016,7 @@
                                    std::string const& data,
                                    int max_width,
                                    int max_height,
-                                   IconLoaderCallback slot)
+                                   IconLoaderCallback const& slot)
 {
   auto iter = cache_.find(key);
   bool found = iter != cache_.end();
@@ -1139,39 +1099,27 @@
   return default_loader;
 }
 
-int IconLoader::LoadFromIconName(std::string const& icon_name,
-                                 int max_width,
-                                 int max_height,
-                                 IconLoaderCallback slot)
+IconLoader::Handle IconLoader::LoadFromIconName(std::string const& icon_name, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   return pimpl->LoadFromIconName(icon_name, max_width, max_height, slot);
 }
 
-int IconLoader::LoadFromGIconString(std::string const& gicon_string,
-                                    int max_width,
-                                    int max_height,
-                                    IconLoaderCallback slot)
+IconLoader::Handle IconLoader::LoadFromGIconString(std::string const& gicon_string, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   return pimpl->LoadFromGIconString(gicon_string, max_width, max_height, slot);
 }
 
-int IconLoader::LoadFromFilename(std::string const& filename,
-                                 int max_width,
-                                 int max_height,
-                                 IconLoaderCallback slot)
+IconLoader::Handle IconLoader::LoadFromFilename(std::string const& filename, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   return pimpl->LoadFromFilename(filename, max_width, max_height, slot);
 }
 
-int IconLoader::LoadFromURI(std::string const& uri,
-                            int max_width,
-                            int max_height,
-                            IconLoaderCallback slot)
+IconLoader::Handle IconLoader::LoadFromURI(std::string const& uri, int max_width, int max_height, IconLoaderCallback const& slot)
 {
   return pimpl->LoadFromURI(uri, max_width, max_height, slot);
 }
 
-void IconLoader::DisconnectHandle(int handle)
+void IconLoader::DisconnectHandle(Handle handle)
 {
   pimpl->DisconnectHandle(handle);
 }

=== modified file 'unity-shared/IconLoader.h'
--- unity-shared/IconLoader.h	2012-09-12 15:07:07 +0000
+++ unity-shared/IconLoader.h	2013-10-07 17:26:52 +0000
@@ -24,6 +24,7 @@
 
 #include <memory>
 #include <gtk/gtk.h>
+#include <UnityCore/ActionHandle.h>
 #include <UnityCore/GLibWrapper.h>
 
 namespace unity
@@ -32,6 +33,7 @@
 class IconLoader : public boost::noncopyable
 {
 public:
+  typedef action::handle Handle;
   typedef std::function<void(std::string const&, int, int, glib::Object<GdkPixbuf> const&)> IconLoaderCallback;
 
   IconLoader();
@@ -44,27 +46,12 @@
    * this is to disconnect the callback slot.
    */
 
-  int LoadFromIconName(std::string const& icon_name,
-                       int max_width,
-                       int max_height,
-                       IconLoaderCallback slot);
-
-  int LoadFromGIconString(std::string const& gicon_string,
-                          int max_width,
-                          int max_height,
-                          IconLoaderCallback slot);
-
-  int LoadFromFilename(std::string const& filename,
-                       int max_width,
-                       int max_height,
-                       IconLoaderCallback slot);
-
-  int LoadFromURI(std::string const& uri,
-                  int max_width,
-                  int max_height,
-                  IconLoaderCallback slot);
-
-  void DisconnectHandle(int handle);
+  Handle LoadFromIconName(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+  Handle LoadFromGIconString(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+  Handle LoadFromFilename(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+  Handle LoadFromURI(std::string const&, int max_width, int max_height, IconLoaderCallback const& slot);
+
+  void DisconnectHandle(Handle handle);
 
 private:
   class Impl;