Merge lp:~azzar1/unity/devices-cleanup-and-test into lp:unity

[Andrea Azzarone]

Refactor device launcher icons.

== Problems ==
#. Unity launcher gets cluttered when having multiple partitions and/or external volumes attached.
#. Devices launcher icons needs test.

== Fix ==
#. DeviceNotificationShower and FileManagerOpener are written rely on SRP and DI.
#. Volume/VolumeImp is a wrapper for GVolume. It makes the VolumeLauncherIcon testable and readable.

== Test ==
#. Unit tests added for VolumeLauncherIcon and VolumeImpl. DeviceLauncherSection already has unit test.
#. I've not added tests for DevicesSettingsImp because Trevinho will remove DevicesSettingsImp in his next branch.

---

Forgive me for the long diff. Refactoring code to make it testable is hard without breaking legacy code.

[Sam Spilsbury (smspillaz)]

> Forgive me for the long diff. Refactoring code to make it testable is hard without breaking legacy code.

There is no need to apologize for this - a large diff that gets code under test and makes it cleaner is better than a short diff that does not include test cases.

235 +class DeviceNotificationShower : private boost::noncopyable
236 +{
237 +public:
238 + typedef std::shared_ptr<DeviceNotificationShower> Ptr;
239 +

This class can probably be renamed to DeviceNotificationDisplay - the word "Shower" has two meanings in the english langauge and although it was silly of me to confuse one for the other, I did so anyways.

235 +class DeviceNotificationShower : private boost::noncopyable
236 +{
237 +public:
238 + typedef std::shared_ptr<DeviceNotificationShower> Ptr;
239 +

I'm also not entirely certain about making the interface noncopyable. Generally speaking the object should be noncopyable.

> IconLoader::GetDefault().

Can we remove that singleton?

3019 + g_mock_volume_set_can_eject(gvolume_, TRUE);
3020 + EXPECT_TRUE(volume_->CanBeEjected());

Generally speaking I prefer to operate mocked objects through their interfaces, eg

g_volume_set_can_eject (...); (I assume that you're testing the effect of external GIO code calling set_can_eject through the interface ...).

Also it might be useful for you to hook up your mock implementation of GDrive to a Google Mock directly. That way you can expect that your VolumeLauncherImp is calling the correct function and also determine what the return value is directly within the test code without having to add new api to GMockDrive to set them.

3068 + EXPECT_CALL(*file_manager_opener_, Open("file:///some/directory/testfile"))
3069 + .Times(1);
3070 +
3071 + volume_->MountAndOpenInFileManager();
3072 + EXPECT_TRUE(volume_->IsMounted());

It was a bit confusing as to where: "file:///some/directory/testfile" came from - better make it a constant.

[Andrea Azzarone (azzar1)]

> > Forgive me for the long diff. Refactoring code to make it testable is hard
> without breaking legacy code.
>
> There is no need to apologize for this - a large diff that gets code under
> test and makes it cleaner is better than a short diff that does not include
> test cases.
>
> 235 +class DeviceNotificationShower : private boost::noncopyable
> 236 +{
> 237 +public:
> 238 + typedef std::shared_ptr<DeviceNotificationShower> Ptr;
> 239 +
>
> This class can probably be renamed to DeviceNotificationDisplay - the word
> "Shower" has two meanings in the english langauge and although it was silly of
> me to confuse one for the other, I did so anyways.

Will do!

>
> 235 +class DeviceNotificationShower : private boost::noncopyable
> 236 +{
> 237 +public:
> 238 + typedef std::shared_ptr<DeviceNotificationShower> Ptr;
> 239 +
>
> I'm also not entirely certain about making the interface noncopyable.
> Generally speaking the object should be noncopyable.
>

We really don't need to make that object copyable. Also making in un-copyable force us to use it through a pointer.

> > IconLoader::GetDefault().
>

IconLoader is used in dash/hud/launcher/switcher code. I think it's not a good idea to do it in this branch.

> Can we remove that singleton?
>
> 3019 + g_mock_volume_set_can_eject(gvolume_, TRUE);
> 3020 + EXPECT_TRUE(volume_->CanBeEjected());
>
> Generally speaking I prefer to operate mocked objects through their
> interfaces, eg
>
> g_volume_set_can_eject (...); (I assume that you're testing the effect of
> external GIO code calling set_can_eject through the interface ...).

Here I'm testing the VolumeImp mocking GVolumeIface.

>
> Also it might be useful for you to hook up your mock implementation of GDrive
> to a Google Mock directly. That way you can expect that your VolumeLauncherImp
> is calling the correct function and also determine what the return value is
> directly within the test code without having to add new api to GMockDrive to
> set them.
>

Can we mock a GObject using Google Mock?

> 3068 + EXPECT_CALL(*file_manager_opener_,
> Open("file:///some/directory/testfile"))
> 3069 + .Times(1);
> 3070 +
> 3071 + volume_->MountAndOpenInFileManager();
> 3072 + EXPECT_TRUE(volume_->IsMounted());
>
> It was a bit confusing as to where: "file:///some/directory/testfile" came
> from - better make it a constant.

Will fix it.

[Sam Spilsbury (smspillaz)]

> > > Forgive me for the long diff. Refactoring code to make it testable is hard
> > without breaking legacy code.
> >
> > There is no need to apologize for this - a large diff that gets code under
> > test and makes it cleaner is better than a short diff that does not include
> > test cases.
> >
> > 235 +class DeviceNotificationShower : private boost::noncopyable
> > 236 +{
> > 237 +public:
> > 238 + typedef std::shared_ptr<DeviceNotificationShower> Ptr;
> > 239 +
> >
> > This class can probably be renamed to DeviceNotificationDisplay - the word
> > "Shower" has two meanings in the english langauge and although it was silly
> of
> > me to confuse one for the other, I did so anyways.
>
> Will do!
>
> >
> > 235 +class DeviceNotificationShower : private boost::noncopyable
> > 236 +{
> > 237 +public:
> > 238 + typedef std::shared_ptr<DeviceNotificationShower> Ptr;
> > 239 +
> >
> > I'm also not entirely certain about making the interface noncopyable.
> > Generally speaking the object should be noncopyable.
> >
>
> We really don't need to make that object copyable. Also making in un-copyable
> force us to use it through a pointer.

Right, my point was that you've made the interface itself noncopyable. However there probably isn't much
of a way to prevent copyablility except if we were to do it like that, so that seems okay.

>
> > > IconLoader::GetDefault().
> >
>
> IconLoader is used in dash/hud/launcher/switcher code. I think it's not a good
> idea to do it in this branch.

Sure, just food for thought.

>
> > Can we remove that singleton?
> >
> > 3019 + g_mock_volume_set_can_eject(gvolume_, TRUE);
> > 3020 + EXPECT_TRUE(volume_->CanBeEjected());
> >
> > Generally speaking I prefer to operate mocked objects through their
> > interfaces, eg
> >
> > g_volume_set_can_eject (...); (I assume that you're testing the effect of
> > external GIO code calling set_can_eject through the interface ...).
>
> Here I'm testing the VolumeImp mocking GVolumeIface.

Is VolumeImp providing a C++ wrapper around GVolumeIface ?

I feel like its a bit strange then, if the contents of the underlying GVolume can never be altered except by VolumeImp, that they are being altered in the tests to check the behaviour of VolumeImp.

Wouldn't it be better to alter GVolume through VolumeImp ?

Unless it is that it wraps an /existing/ GVolume, which has can_eject () already set. In this case, it probably makes more ense to implement GMockVolume in terms of google mock.

>
> >
> > Also it might be useful for you to hook up your mock implementation of
> GDrive
> > to a Google Mock directly. That way you can expect that your
> VolumeLauncherImp
> > is calling the correct function and also determine what the return value is
> > directly within the test code without having to add new api to GMockDrive to
> > set them.
> >
>
> Can we mock a GObject using Google Mock?

Yes you can, by making the interface delegate to a google mock.

Have a look at this:

http://bazaar.launchpad.net/~compiz-team/compiz/compiz.gtk-window-decorator-gsettings/view/head:/gtk/window-decorator/tests/compiz_gwd_mock_settings_writable.cpp
>
> > 3068 + EX...

[Andrea Azzarone (azzar1)]

> Is VolumeImp providing a C++ wrapper around GVolumeIface ?

Volume is the interface, VolumeImp is the implementation. Volume doesn't know nothing about GVolume, VolumeImp is a kind of a wrapper. I added unit-test for VolumeImp because it's not a simple wrapper.

> I feel like its a bit strange then, if the contents of the underlying GVolume can never be altered except by VolumeImp, that they are being altered in the tests to check the behaviour of VolumeImp.

> Wouldn't it be better to alter GVolume through VolumeImp ?

We do it in VolumeLauncherIcon, mocking Volume. VolumeLauncherIcon doesn't use VolumeImp...

> Unless it is that it wraps an /existing/ GVolume, which has can_eject () already set. In this case, it probably makes more ense to implement GMockVolume in terms of google mock.

I will study this opportunity. Thank you :)

[Marco Trevisan (Treviño) (3v1n0)]

There are conflicts with trunk now...

50 - DeviceLauncherIcon.cpp
51 + VolumeLauncherIcon.cpp

Please, keep these in alphabetic order.

2252 void OnRemoved();

Please, make this protected in case you need this for testing.

[Andrea Azzarone (azzar1)]

> There are conflicts with trunk now...
>
> 50 - DeviceLauncherIcon.cpp
> 51 + VolumeLauncherIcon.cpp
>
> Please, keep these in alphabetic order.

Sure, will do?

>
> 2252 void OnRemoved();
>
> Please, make this protected in case you need this for testing.

It needs to be public. Maybe you meant "virtual"?

[Marco Trevisan (Treviño) (3v1n0)]

Nice, this work good for me... What about renaming IsABlacklistedDevice to IsBlackListedDevice?

[Andrea Azzarone (azzar1)]

> Nice, this work good for me... What about renaming IsABlacklistedDevice to
> IsBlackListedDevice?

Ok, but I think there is no need to change it if you're going to remove DevicesSettings ;)

[Marco Trevisan (Treviño) (3v1n0)]

Probably I will keep it, since we still need a blacklist for these devices, so for now I'll keep as you wrote it.
Also maybe it's better if you get rid of the "TryTo..." prefix.

Also is this idle still needed:
113 + device_populate_idle_.Run([this] () {
114 PopulateEntries();
115 return false;
116 });

I think it was added to make the launcher controller properly populate the devices, right?
If you confirm this, I'll handle it in another way into my branch.

[Andrea Azzarone (azzar1)]

> Probably I will keep it, since we still need a blacklist for these devices, so
> for now I'll keep as you wrote it.
> Also maybe it's better if you get rid of the "TryTo..." prefix.

I'd prefer too keep the prefix because adding/removing can fail. When you call TryTo... you're sure that adding/removing are completed successfully when you got the changed signal.

>
> Also is this idle still needed:
> 113 + device_populate_idle_.Run([this] () {
> 114 PopulateEntries();
> 115 return false;
> 116 });
>
> I think it was added to make the launcher controller properly populate the
> devices, right?
> If you confirm this, I'll handle it in another way into my branch.

Yeah you can remove it if it's a problem for you ;)

[Andrea Azzarone (azzar1)]

I removed the OnRemoved function ;)

[Marco Trevisan (Treviño) (3v1n0)]

I like the way you removed OnRemoved, I think this is fine for trunk now.

review: Approve

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity/1155/console reported an error when processing this lp:~andyrock/unity/devices-cleanup-and-test branch.
Not merging it.

=== modified file 'com.canonical.Unity.gschema.xml'
--- com.canonical.Unity.gschema.xml	2012-07-19 10:13:55 +0000
+++ com.canonical.Unity.gschema.xml	2012-08-29 08:24:20 +0000
@@ -42,10 +42,10 @@
     </key>
   </schema>
   <schema path="/com/canonical/unity/devices/" id="com.canonical.Unity.Devices" gettext-domain="unity">
-    <key type="as" name="favorites">
+    <key type="as" name="blacklist">
         <default>[]</default>
-        <summary>List of device uuid for favorites on the launcher.</summary>
-        <description>These devices are shown in the Launcher by default.</description>
+        <summary>List of device uuid blacklist from the launcher.</summary>
+        <description>These devices are not shown in the launcher by default.</description>
     </key>
   </schema>
   <schema path="/com/canonical/unity/dash/" id="com.canonical.Unity.Dash" gettext-domain="unity">
 
=== modified file 'launcher/AbstractVolumeMonitorWrapper.h'
--- launcher/AbstractVolumeMonitorWrapper.h	2012-07-18 22:54:22 +0000
+++ launcher/AbstractVolumeMonitorWrapper.h	2012-08-29 08:24:20 +0000
@@ -27,7 +27,6 @@
 #include <sigc++/trackable.h>
 
 #include <UnityCore/GLibWrapper.h>
-#include <UnityCore/GLibSignal.h>
 
 namespace unity
 {
@@ -54,8 +53,8 @@
   sigc::signal<void, glib::Object<GVolume> const&> volume_removed;
 };
 
-} // namespace launcher
-} // namespace unity
+}
+}
 
-#endif // UNITYSHELL_ABSTRACT_VOLUME_MONITOR_WRAPPER_H
+#endif
 
 
=== modified file 'launcher/CMakeLists.txt'
--- launcher/CMakeLists.txt	2012-07-27 20:20:29 +0000
+++ launcher/CMakeLists.txt	2012-08-29 08:24:20 +0000
@@ -37,14 +37,15 @@
      DNDCollectionWindow.cpp
      Decaymulator.cpp
      DesktopLauncherIcon.cpp
-     DeviceLauncherIcon.cpp
      DeviceLauncherSection.cpp
-     DevicesSettings.cpp
+     DeviceNotificationDisplayImp.cpp
+     DevicesSettingsImp.cpp
      DndData.cpp
      EdgeBarrierController.cpp
      FavoriteStore.cpp
      FavoriteStoreGSettings.cpp
      FavoriteStorePrivate.cpp
+     FileManagerOpenerImp.cpp
      HudLauncherIcon.cpp
      Launcher.cpp
      LauncherController.cpp
@@ -71,6 +72,8 @@
      SpacerLauncherIcon.cpp
      Tooltip.cpp
      TrashLauncherIcon.cpp
+     VolumeImp.cpp
+     VolumeLauncherIcon.cpp
      VolumeMonitorWrapper.cpp
      )
 
@@ -87,7 +90,7 @@
 add_library (switcher-lib STATIC ${SWITCHER_SOURCES})
 add_dependencies (switcher-lib unity-core-${UNITY_API_VERSION} unity-shared)
 
-# 
+#
 # Standalone variant
 #
 add_executable (launcher StandaloneLauncher.cpp)
 
=== modified file 'launcher/DeviceLauncherSection.cpp'
--- launcher/DeviceLauncherSection.cpp	2012-07-18 17:51:56 +0000
+++ launcher/DeviceLauncherSection.cpp	2012-08-29 08:24:20 +0000
@@ -18,19 +18,27 @@
  */
 
 #include "DeviceLauncherSection.h"
+#include "DeviceNotificationDisplayImp.h"
+#include "DevicesSettings.h"
+#include "FileManagerOpenerImp.h"
+#include "VolumeImp.h"
 
 namespace unity
 {
 namespace launcher
 {
 
-DeviceLauncherSection::DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr volume_monitor)
+DeviceLauncherSection::DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr volume_monitor,
+                                             DevicesSettings::Ptr devices_settings)
   : monitor_(volume_monitor)
+  , devices_settings_(devices_settings)
+  , file_manager_opener_(new FileManagerOpenerImp)
+  , device_notification_display_(new DeviceNotificationDisplayImp)
 {
   monitor_->volume_added.connect(sigc::mem_fun(this, &DeviceLauncherSection::OnVolumeAdded));
   monitor_->volume_removed.connect(sigc::mem_fun(this, &DeviceLauncherSection::OnVolumeRemoved));
-  
-  device_populate_idle_.Run([&] () {
+
+  device_populate_idle_.Run([this] () {
     PopulateEntries();
     return false;
   });
@@ -39,29 +47,21 @@
 void DeviceLauncherSection::PopulateEntries()
 {
   for (auto volume : monitor_->GetVolumes())
-  {
-    // Sanity check. Avoid duplicates.
-    if (map_.find(volume) != map_.end())
-      continue;
-
-    DeviceLauncherIcon::Ptr icon(new DeviceLauncherIcon(volume));
-
-    map_[volume] = icon;
-    IconAdded.emit(icon);
-  }
+    TryToCreateAndAddIcon(volume);
 }
 
-/* Uses a std::map to track all the volume icons shown and not shown.
- * Keep in mind: when "volume-removed" is recevied we should erase
- * the pair (GVolume - DeviceLauncherIcon) from the std::map to avoid leaks
- */
 void DeviceLauncherSection::OnVolumeAdded(glib::Object<GVolume> const& volume)
 {
-  // Sanity check. Avoid duplicates.
+  TryToCreateAndAddIcon(volume);
+}
+
+void DeviceLauncherSection::TryToCreateAndAddIcon(glib::Object<GVolume> volume)
+{
   if (map_.find(volume) != map_.end())
     return;
 
-  DeviceLauncherIcon::Ptr icon(new DeviceLauncherIcon(volume));
+  VolumeLauncherIcon::Ptr icon(new VolumeLauncherIcon(std::make_shared<VolumeImp>(volume, file_manager_opener_, device_notification_display_),
+                                                        devices_settings_));
 
   map_[volume] = icon;
   IconAdded.emit(icon);
@@ -73,12 +73,8 @@
 
   // Sanity check
   if (volume_it != map_.end())
-  {
-    volume_it->second->OnRemoved();
     map_.erase(volume_it);
-  }
-}
-
-} // namespace launcher
-} // namespace unity
-
+}
+
+}
+}
 
=== modified file 'launcher/DeviceLauncherSection.h'
--- launcher/DeviceLauncherSection.h	2012-07-18 17:51:56 +0000
+++ launcher/DeviceLauncherSection.h	2012-08-29 08:24:20 +0000
@@ -17,15 +17,19 @@
  *              Andrea Azzarone <[e-mail]>
  */
 
-#ifndef _DEVICE_LAUNCHER_SECTION_H_
-#define _DEVICE_LAUNCHER_SECTION_H_
+#ifndef UNITYSHELL_DEVICE_LAUNCHER_SECTION_H
+#define UNITYSHELL_DEVICE_LAUNCHER_SECTION_H
 
 #include <map>
+#include <memory>
 
 #include <UnityCore/GLibSource.h>
 
-#include "DeviceLauncherIcon.h"
 #include "AbstractVolumeMonitorWrapper.h"
+#include "DevicesSettings.h"
+#include "DeviceNotificationDisplay.h"
+#include "FileManagerOpener.h"
+#include "VolumeLauncherIcon.h"
 
 namespace unity
 {
@@ -35,7 +39,8 @@
 class DeviceLauncherSection : public sigc::trackable
 {
 public:
-  DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr volume_monitor);
+  DeviceLauncherSection(AbstractVolumeMonitorWrapper::Ptr volume_monitor,
+                        DevicesSettings::Ptr devices_settings);
 
   sigc::signal<void, AbstractLauncherIcon::Ptr> IconAdded;
 
@@ -43,13 +48,18 @@
   void PopulateEntries();
   void OnVolumeAdded(glib::Object<GVolume> const& volume);
   void OnVolumeRemoved(glib::Object<GVolume> const& volume);
+  void TryToCreateAndAddIcon(glib::Object<GVolume> volume);
 
-  std::map<GVolume*, DeviceLauncherIcon::Ptr> map_;
+  std::map<GVolume*, VolumeLauncherIcon::Ptr> map_;
   AbstractVolumeMonitorWrapper::Ptr monitor_;
+  DevicesSettings::Ptr devices_settings_;
+  FileManagerOpener::Ptr file_manager_opener_;
+  DeviceNotificationDisplay::Ptr device_notification_display_;
+
   glib::Idle device_populate_idle_;
 };
 
 }
-} // namespace unity
+}
 
-#endif // _DEVICE_LAUNCHER_SECTION_H_
+#endif
 
=== added file 'launcher/DeviceNotificationDisplay.h'
--- launcher/DeviceNotificationDisplay.h	1970-01-01 00:00:00 +0000
+++ launcher/DeviceNotificationDisplay.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,45 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_DEVICE_NOTIFICATION_DISPLAY_H
+#define UNITYSHELL_DEVICE_NOTIFICATION_DISPLAY_H
+
+#include <boost/noncopyable.hpp>
+#include <memory>
+#include <string>
+
+namespace unity
+{
+namespace launcher
+{
+
+class DeviceNotificationDisplay : private boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<DeviceNotificationDisplay> Ptr;
+
+  virtual ~DeviceNotificationDisplay() {}
+
+  virtual void Display(std::string const& icon_name, std::string const& volume_name) = 0;
+};
+
+}
+}
+
+#endif
 
=== added file 'launcher/DeviceNotificationDisplayImp.cpp'
--- launcher/DeviceNotificationDisplayImp.cpp	1970-01-01 00:00:00 +0000
+++ launcher/DeviceNotificationDisplayImp.cpp	2012-08-29 08:24:20 +0000
@@ -0,0 +1,82 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gdk/gdk.h>
+#include <glib/gi18n-lib.h>
+#include <libnotify/notify.h>
+#include <sigc++/sigc++.h>
+#include <UnityCore/GLibWrapper.h>
+
+#include "DeviceNotificationDisplayImp.h"
+#include "unity-shared/IconLoader.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+//
+// Start private implementation
+//
+class DeviceNotificationDisplayImp::Impl
+{
+public:
+  void Show(std::string const& icon_name, std::string const& volume_name)
+  {
+    int icon_size = 48;
+    IconLoader::GetDefault().LoadFromGIconString(icon_name, icon_size,
+                                                 sigc::bind(sigc::mem_fun(this, &Impl::ShowNotificationWhenIconIsReady), volume_name));
+  }
+
+  void ShowNotificationWhenIconIsReady(std::string const& icon_name,
+                                       unsigned size,
+                                       glib::Object<GdkPixbuf> const& pixbuf,
+                                       std::string const& volume_name)
+  {
+    glib::Object<NotifyNotification> notification(notify_notification_new(volume_name.c_str(),
+                                                                         _("The drive has been successfully ejected"),
+                                                                          nullptr));
+
+    notify_notification_set_hint(notification, "x-canonical-private-synchronous", g_variant_new_boolean(TRUE));
+
+    if (GDK_IS_PIXBUF(pixbuf.RawPtr()))
+      notify_notification_set_image_from_pixbuf(notification, pixbuf);
+
+    notify_notification_show(notification, nullptr);
+  }
+};
+
+//
+// End private implementation
+//
+
+DeviceNotificationDisplayImp::DeviceNotificationDisplayImp()
+  : pimpl(new Impl)
+{}
+
+DeviceNotificationDisplayImp::~DeviceNotificationDisplayImp()
+{}
+
+void DeviceNotificationDisplayImp::Display(std::string const& icon_name, std::string const& volume_name)
+{
+  pimpl->Show(icon_name, volume_name);
+}
+
+}
+}
 
=== added file 'launcher/DeviceNotificationDisplayImp.h'
--- launcher/DeviceNotificationDisplayImp.h	1970-01-01 00:00:00 +0000
+++ launcher/DeviceNotificationDisplayImp.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,46 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_DEVICE_NOTIFICATION_DISPLAY_IMP_H
+#define UNITYSHELL_DEVICE_NOTIFICATION_DISPLAY_IMP_H
+
+#include "DeviceNotificationDisplay.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+class DeviceNotificationDisplayImp : public DeviceNotificationDisplay
+{
+public:
+  DeviceNotificationDisplayImp();
+  virtual ~DeviceNotificationDisplayImp();
+
+  virtual void Display(std::string const& icon_name, std::string const& volume_name);
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+}
+}
+
+#endif
 
=== modified file 'launcher/DevicesSettings.h'
--- launcher/DevicesSettings.h	2012-05-07 19:52:54 +0000
+++ launcher/DevicesSettings.h	2012-08-29 08:24:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-12 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
@@ -14,61 +14,39 @@
  * 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: Andrea Azzarone <[e-mail]>
+ * Authored by: Andrea Azzarone <[e-mail]>
  */
 
-#ifndef DEVICES_SETTINGS_H
-#define DEVICES_SETTINGS_H
+#ifndef UNITYSHELL_DEVICES_SETTINGS_H
+#define UNITYSHELL_DEVICES_SETTINGS_H
 
-#include <list>
+#include <boost/noncopyable.hpp>
+#include <memory>
 #include <string>
 
-#include <gio/gio.h>
-#include <boost/utility.hpp>
-#include <sigc++/sigc++.h>
-#include <UnityCore/GLibWrapper.h>
-
-namespace unity {
-
-typedef std::list<std::string> DeviceList;
-
-class DevicesSettings : boost::noncopyable
+#include <sigc++/signal.h>
+#include <sigc++/trackable.h>
+
+namespace unity
+{
+namespace launcher
+{
+
+class DevicesSettings : boost::noncopyable, public sigc::trackable
 {
 public:
-  typedef enum
-  {
-    NEVER = 0,
-    ONLY_MOUNTED,
-    ALWAYS
-
-  } DevicesOption;
-
-  DevicesSettings();
-  
-  static DevicesSettings& GetDefault();
-
-  void SetDevicesOption(DevicesOption devices_option);
-  DevicesOption GetDevicesOption() { return devices_option_; };
-
-  DeviceList const& GetFavorites() { return favorites_; };
-  void AddFavorite(std::string const& uuid);
-  void RemoveFavorite(std::string const& uuid);
-
-  void Changed(std::string const& key);
-  
-  // Signals
+  typedef std::shared_ptr<DevicesSettings> Ptr;
+
+  virtual ~DevicesSettings() {};
+
+  virtual bool IsABlacklistedDevice(std::string const& uuid) const = 0;
+  virtual void TryToBlacklist(std::string const& uuid) = 0;
+  virtual void TryToUnblacklist(std::string const& uuid) = 0;
+
   sigc::signal<void> changed;
-  
-private:
-  void Refresh();
-  void SaveFavorites(DeviceList const& favorites);
-
-  glib::Object<GSettings> settings_;
-  DeviceList favorites_;
-  bool ignore_signals_;
-  DevicesOption devices_option_;
 };
 
-} // namespace unity
+}
+}
 
-#endif // DEVICES_SETTINGS_H
+#endif
 
=== renamed file 'launcher/DevicesSettings.cpp' => 'launcher/DevicesSettingsImp.cpp'
--- launcher/DevicesSettings.cpp	2012-05-07 19:52:54 +0000
+++ launcher/DevicesSettingsImp.cpp	2012-08-29 08:24:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-12 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
@@ -14,130 +14,138 @@
  * 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: Andrea Azzarone <[e-mail]>
+ * Authored by: Andrea Azzarone <[e-mail]>
  */
 
-#include "DevicesSettings.h"
-
-#include <algorithm>
-
-namespace unity {
-
-namespace {
-
-const char* SETTINGS_NAME = "com.canonical.Unity.Devices";
-
-void on_settings_updated(GSettings* settings,
-                         const gchar* key,
-                         DevicesSettings* self);
-
-} // anonymous namespace
-
-DevicesSettings& DevicesSettings::GetDefault()
-{
-  static DevicesSettings instance;
-  return instance;
-}
-
-DevicesSettings::DevicesSettings()
-  : settings_(g_settings_new(SETTINGS_NAME))
-  , ignore_signals_(false)
-  , devices_option_(ONLY_MOUNTED)
-{
-
-  g_signal_connect(settings_, "changed", G_CALLBACK(on_settings_updated), this);
-
-  Refresh();
-}
-
-void DevicesSettings::Refresh()
-{
-  gchar** favs = g_settings_get_strv(settings_, "favorites");
-
-  favorites_.clear();
-
-  for (int i = 0; favs[i] != NULL; i++)
-    favorites_.push_back(favs[i]);
-
-  g_strfreev(favs);
-}
-
-void DevicesSettings::AddFavorite(std::string const& uuid)
-{
-  if (uuid.empty())
-    return;
-  
-  favorites_.push_back(uuid);
-
-  SaveFavorites(favorites_);
-  Refresh();
-}
-
-void DevicesSettings::RemoveFavorite(std::string const& uuid)
-{
-  if (uuid.empty())
-    return;
-
-  DeviceList::iterator pos = std::find(favorites_.begin(), favorites_.end(), uuid);
-  if (pos == favorites_.end())
-    return;
-
-  favorites_.erase(pos);
-  SaveFavorites(favorites_);
-  Refresh();
-}
-
-void DevicesSettings::SaveFavorites(DeviceList const& favorites)
-{
-  const int size = favorites.size();
-  const char* favs[size + 1];
-  favs[size] = NULL;
-
-  int index = 0;
-  for (DeviceList::const_iterator i = favorites.begin(), end = favorites.end();
-       i != end; ++i, ++index)
-  {
-    favs[index] = i->c_str();
-  }
-
-  ignore_signals_ = true;
-  if (!g_settings_set_strv(settings_, "favorites", favs))
-    g_warning("Saving favorites failed.");
-  ignore_signals_ = false;
-}
-
-
-void DevicesSettings::Changed(std::string const& key)
-{
-  if (ignore_signals_)
-    return;
-  
-  Refresh();
-  
-  changed.emit();
-}
-
-void DevicesSettings::SetDevicesOption(DevicesOption devices_option)
-{
-  if (devices_option == devices_option_)
-    return;
-
-  devices_option_ = devices_option;
-
-  changed.emit();
-}
-
-namespace {
-
-void on_settings_updated(GSettings* settings,
-                         const gchar* key,
-                         DevicesSettings* self)
-{
-  if (settings and key) {
-    self->Changed(key);
-  }
-}
-
-} // anonymous namespace
-
+#include <list>
+
+#include <gio/gio.h>
+#include <NuxCore/Logger.h>
+
+#include "DevicesSettingsImp.h"
+#include <UnityCore/GLibSignal.h>
+#include <UnityCore/GLibWrapper.h>
+
+namespace unity
+{
+namespace launcher
+{
+namespace
+{
+
+nux::logging::Logger logger("unity.device.settings");
+
+const std::string SETTINGS_NAME = "com.canonical.Unity.Devices";
+const std::string KEY_NAME = "blacklist";
+
+}
+
+//
+// Start private implementation
+//
+class DevicesSettingsImp::Impl
+{
+public:
+  Impl(DevicesSettingsImp* parent)
+    : parent_(parent)
+    , settings_(g_settings_new(SETTINGS_NAME.c_str()))
+  {
+    DownloadBlacklist();
+    ConnectSignals();
+  }
+
+  void ConnectSignals()
+  {
+    settings_changed_signal_.Connect(settings_, "changed::" + KEY_NAME, [this] (GSettings*, gchar*) {
+      DownloadBlacklist();
+      parent_->changed.emit();
+    });
+  }
+
+  void DownloadBlacklist()
+  {
+    std::shared_ptr<gchar*> downloaded_blacklist(g_settings_get_strv(settings_, KEY_NAME.c_str()), g_strfreev);
+
+    blacklist_.clear();
+
+    auto downloaded_blacklist_raw = downloaded_blacklist.get();
+    for (int i = 0; downloaded_blacklist_raw[i]; ++i)
+      blacklist_.push_back(downloaded_blacklist_raw[i]);
+  }
+
+  void UploadBlacklist()
+  {
+    const int size = blacklist_.size();
+    const char* blacklist_to_be_uploaded[size+1];
+
+    int index = 0;
+    for (auto item : blacklist_)
+      blacklist_to_be_uploaded[index++] = item.c_str();
+    blacklist_to_be_uploaded[index] = nullptr;
+
+    if (!g_settings_set_strv(settings_, KEY_NAME.c_str(), blacklist_to_be_uploaded))
+    {
+      LOG_WARNING(logger) << "Saving blacklist failed.";
+    }
+  }
+
+  bool IsABlacklistedDevice(std::string const& uuid) const
+  {
+    auto begin = std::begin(blacklist_);
+    auto end = std::end(blacklist_);
+    return std::find(begin, end, uuid) != end;
+  }
+
+  void TryToBlacklist(std::string const& uuid)
+  {
+    if (uuid.empty() || IsABlacklistedDevice(uuid))
+      return;
+
+    blacklist_.push_back(uuid);
+    UploadBlacklist();
+  }
+
+  void TryToUnblacklist(std::string const& uuid)
+  {
+    if (uuid.empty() || !IsABlacklistedDevice(uuid))
+      return;
+
+    blacklist_.remove(uuid);
+    UploadBlacklist();
+  }
+
+  DevicesSettingsImp* parent_;
+  glib::Object<GSettings> settings_;
+  std::list<std::string> blacklist_;
+  glib::Signal<void, GSettings*, gchar*> settings_changed_signal_;
+
+};
+
+//
+// End private implementation
+//
+
+DevicesSettingsImp::DevicesSettingsImp()
+  : pimpl(new Impl(this))
+{}
+
+DevicesSettingsImp::~DevicesSettingsImp()
+{}
+
+bool DevicesSettingsImp::IsABlacklistedDevice(std::string const& uuid) const
+{
+  return pimpl->IsABlacklistedDevice(uuid);
+}
+
+void DevicesSettingsImp::TryToBlacklist(std::string const& uuid)
+{
+  pimpl->TryToBlacklist(uuid);
+}
+
+void DevicesSettingsImp::TryToUnblacklist(std::string const& uuid)
+{
+  pimpl->TryToUnblacklist(uuid);
+}
+
+} // namespace launcher
 } // namespace unity
 
=== added file 'launcher/DevicesSettingsImp.h'
--- launcher/DevicesSettingsImp.h	1970-01-01 00:00:00 +0000
+++ launcher/DevicesSettingsImp.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,50 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_DEVICES_SETTINGS_IMP_H
+#define UNITYSHELL_DEVICES_SETTINGS_IMP_H
+
+#include "DevicesSettings.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+class DevicesSettingsImp : public DevicesSettings
+{
+public:
+  typedef std::shared_ptr<DevicesSettingsImp> Ptr; 
+
+  DevicesSettingsImp();
+  virtual ~DevicesSettingsImp();
+
+  virtual bool IsABlacklistedDevice(std::string const& uuid) const;
+  virtual void TryToBlacklist(std::string const& uuid);
+  virtual void TryToUnblacklist(std::string const& uuid);
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+}
+}
+
+#endif
 
=== added file 'launcher/FileManagerOpener.h'
--- launcher/FileManagerOpener.h	1970-01-01 00:00:00 +0000
+++ launcher/FileManagerOpener.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,45 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_FILEMANAGER_OPENER_H
+#define UNITYSHELL_FILEMANAGER_OPENER_H
+
+#include <boost/noncopyable.hpp>
+#include <memory>
+#include <string>
+
+namespace unity
+{
+namespace launcher
+{
+
+class FileManagerOpener : private boost::noncopyable
+{
+public:
+  typedef std::shared_ptr<FileManagerOpener> Ptr;
+
+  virtual ~FileManagerOpener() {}
+
+  virtual void Open(std::string const& uri) = 0;
+};
+
+}
+}
+
+#endif
 
=== added file 'launcher/FileManagerOpenerImp.cpp'
--- launcher/FileManagerOpenerImp.cpp	1970-01-01 00:00:00 +0000
+++ launcher/FileManagerOpenerImp.cpp	2012-08-29 08:24:20 +0000
@@ -0,0 +1,35 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gio/gio.h>
+
+#include "FileManagerOpenerImp.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+void FileManagerOpenerImp::Open(std::string const& uri)
+{
+  g_app_info_launch_default_for_uri(uri. c_str(), nullptr, nullptr);
+}
+
+}
+}
 
=== added file 'launcher/FileManagerOpenerImp.h'
--- launcher/FileManagerOpenerImp.h	1970-01-01 00:00:00 +0000
+++ launcher/FileManagerOpenerImp.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,39 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_FILEMANAGER_OPENER_IMP_H
+#define UNITYSHELL_FILEMANAGER_OPENER_IMP_H
+
+#include "FileManagerOpener.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+class FileManagerOpenerImp : public FileManagerOpener
+{
+public:
+  virtual void Open(std::string const& uri);
+};
+
+}
+}
+
+#endif
 
=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2012-08-21 17:45:42 +0000
+++ launcher/Launcher.cpp	2012-08-29 08:24:20 +0000
@@ -1719,6 +1719,11 @@
   return _model;
 }
 
+void Launcher::SetDevicesSettings(DevicesSettings::Ptr devices_settings)
+{
+  devices_settings_ = devices_settings;
+}
+
 void Launcher::EnsureIconOnScreen(AbstractLauncherIcon::Ptr selection)
 {
   nux::Geometry const& geo = GetGeometry();
@@ -2581,7 +2586,7 @@
 
   for (auto it : _dnd_data.Uris())
   {
-    if (g_str_has_suffix(it.c_str(), ".desktop"))
+    if (g_str_has_suffix(it.c_str(), ".desktop") || g_str_has_prefix(it.c_str(), "device://"))
     {
       _steal_drag = true;
       break;
@@ -2686,7 +2691,7 @@
     // see if the launcher wants this one
     for (auto it : _dnd_data.Uris())
     {
-      if (g_str_has_suffix(it.c_str(), ".desktop"))
+      if (g_str_has_suffix(it.c_str(), ".desktop") || g_str_has_prefix(it.c_str(), "device://"))
       {
         _steal_drag = true;
         break;
@@ -2824,6 +2829,11 @@
           g_free(path);
         }
       }
+      else if (devices_settings_ && g_str_has_prefix(it.c_str(), "device://"))
+      {
+        const gchar* uuid = it.c_str() + 9;
+        devices_settings_->TryToUnblacklist(uuid);
+      }
     }
   }
   else if (_dnd_hovered_icon && _drag_action != nux::DNDACTION_NONE)
 
=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2012-08-21 17:45:42 +0000
+++ launcher/Launcher.h	2012-08-29 08:24:20 +0000
@@ -30,6 +30,7 @@
 #include "PointerBarrier.h"
 #include "unity-shared/AbstractIconRenderer.h"
 #include "unity-shared/BackgroundEffectHelper.h"
+#include "DevicesSettings.h"
 #include "DNDCollectionWindow.h"
 #include "DndData.h"
 #include "EdgeBarrierController.h"
@@ -82,6 +83,8 @@
   void SetModel(LauncherModel::Ptr model);
   LauncherModel::Ptr GetModel() const;
 
+  void SetDevicesSettings(DevicesSettings::Ptr devices_settings);
+
   void StartKeyShowLauncher();
   void EndKeyShowLauncher();
 
@@ -393,6 +396,8 @@
   ui::AbstractIconRenderer::Ptr icon_renderer;
   BackgroundEffectHelper bg_effect_helper_;
 
+  DevicesSettings::Ptr devices_settings_;
+
   UBusManager ubus_;
   glib::SourceManager sources_;
 
 
=== modified file 'launcher/LauncherController.cpp'
--- launcher/LauncherController.cpp	2012-08-27 03:00:42 +0000
+++ launcher/LauncherController.cpp	2012-08-29 08:24:20 +0000
@@ -29,7 +29,7 @@
 #include "LauncherOptions.h"
 #include "BamfLauncherIcon.h"
 #include "DesktopLauncherIcon.h"
-#include "DeviceLauncherIcon.h"
+#include "VolumeLauncherIcon.h"
 #include "FavoriteStore.h"
 #include "HudLauncherIcon.h"
 #include "LauncherController.h"
@@ -95,7 +95,8 @@
   , model_(new LauncherModel())
   , sort_priority_(0)
   , volume_monitor_(new VolumeMonitorWrapper)
-  , device_section_(volume_monitor_)
+  , devices_settings_(new DevicesSettingsImp)
+  , device_section_(volume_monitor_, devices_settings_)
   , show_desktop_icon_(false)
   , display_(display)
   , matcher_(bamf_matcher_get_default())
@@ -267,6 +268,7 @@
   launcher->monitor = monitor;
   launcher->options = parent_->options();
   launcher->SetModel(model_);
+  launcher->SetDevicesSettings(devices_settings_);
 
   nux::HLayout* layout = new nux::HLayout(NUX_TRACKER_LOCATION);
   layout->AddView(launcher, 1);
@@ -424,10 +426,10 @@
     }
     case AbstractLauncherIcon::IconType::DEVICE:
     {
-      DeviceLauncherIcon* device_icon = dynamic_cast<DeviceLauncherIcon*>(icon.GetPointer());
+      auto device_icon = dynamic_cast<VolumeLauncherIcon*>(icon.GetPointer());
 
       if (device_icon && device_icon->CanEject())
-        device_icon->Eject();
+        device_icon->EjectAndShowNotification();
       else if (device_icon && device_icon->CanStop())
         device_icon->StopDrive();
 
 
=== modified file 'launcher/LauncherController.h'
--- launcher/LauncherController.h	2012-07-27 19:32:41 +0000
+++ launcher/LauncherController.h	2012-08-29 08:24:20 +0000
@@ -32,6 +32,7 @@
 {
 namespace launcher
 {
+
 class AbstractLauncherIcon;
 class Launcher;
 class LauncherModel;
 
=== modified file 'launcher/LauncherControllerPrivate.h'
--- launcher/LauncherControllerPrivate.h	2012-07-25 13:42:41 +0000
+++ launcher/LauncherControllerPrivate.h	2012-08-29 08:24:20 +0000
@@ -27,6 +27,7 @@
 
 #include "AbstractLauncherIcon.h"
 #include "DeviceLauncherSection.h"
+#include "DevicesSettingsImp.h"
 #include "EdgeBarrierController.h"
 #include "LauncherController.h"
 #include "Launcher.h"
@@ -126,6 +127,7 @@
   nux::ObjectPtr<Launcher> keyboard_launcher_;
   int                    sort_priority_;
   AbstractVolumeMonitorWrapper::Ptr volume_monitor_;
+  DevicesSettingsImp::Ptr devices_settings_;
   DeviceLauncherSection  device_section_;
   LauncherEntryRemoteModel remote_model_;
   AbstractLauncherIcon::Ptr expo_icon_;
 
=== added file 'launcher/Volume.h'
--- launcher/Volume.h	1970-01-01 00:00:00 +0000
+++ launcher/Volume.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,62 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_VOLUME_H
+#define UNITYSHELL_VOLUME_H
+
+#include <boost/noncopyable.hpp>
+#include <memory>
+#include <sigc++/signal.h>
+#include <sigc++/trackable.h>
+#include <string>
+
+namespace unity
+{
+namespace launcher
+{
+
+class Volume : private boost::noncopyable, public sigc::trackable
+{
+public:
+  typedef std::shared_ptr<Volume> Ptr;
+
+  virtual ~Volume() {}
+
+  virtual bool CanBeEjected() const = 0;
+  virtual bool CanBeRemoved() const = 0;
+  virtual bool CanBeStopped() const = 0;
+  virtual std::string GetName() const = 0;
+  virtual std::string GetIconName() const = 0;
+  virtual std::string GetIdentifier() const = 0;
+  virtual bool HasSiblings() const = 0;
+  virtual bool IsMounted() const = 0;
+
+  virtual void EjectAndShowNotification() = 0;
+  virtual void MountAndOpenInFileManager() = 0;
+  virtual void StopDrive() = 0;
+  virtual void Unmount() = 0;
+
+  sigc::signal<void> changed;
+  sigc::signal<void> removed;
+};
+
+}
+}
+
+#endif
 
=== added file 'launcher/VolumeImp.cpp'
--- launcher/VolumeImp.cpp	1970-01-01 00:00:00 +0000
+++ launcher/VolumeImp.cpp	2012-08-29 08:24:20 +0000
@@ -0,0 +1,294 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#include <gio/gio.h>
+#include <gtk/gtk.h>
+#include <UnityCore/GLibSignal.h>
+
+#include "VolumeImp.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+//
+// Start private implementation
+//
+
+class VolumeImp::Impl
+{
+public:
+  Impl(glib::Object<GVolume> const& volume,
+       FileManagerOpener::Ptr const& file_manager_opener,
+       DeviceNotificationDisplay::Ptr const& device_notification_display,
+       VolumeImp* parent)
+    : parent_(parent)
+    , cancellable_(g_cancellable_new())
+    , volume_(volume)
+    , file_manager_opener_(file_manager_opener)
+    , device_notification_display_(device_notification_display)
+  {
+    signal_volume_changed_.Connect(volume_, "changed", [this] (GVolume*) {
+      parent_->changed.emit();
+    });
+
+    signal_volume_removed_.Connect(volume_, "removed", [this] (GVolume*) {
+          parent_->removed.emit();
+    });
+  }
+
+  ~Impl()
+  {
+    g_cancellable_cancel(cancellable_);
+  }
+
+  bool CanBeEjected() const
+  {
+    return g_volume_can_eject(volume_) != FALSE;
+  }
+
+  bool CanBeRemoved() const
+  {
+    glib::Object<GDrive> drive(g_volume_get_drive(volume_));
+    return drive && g_drive_is_media_removable(drive) != FALSE;
+  }
+
+  bool CanBeStopped() const
+  {
+    glib::Object<GDrive> drive(g_volume_get_drive(volume_));
+    return drive && g_drive_can_stop(drive) != FALSE;
+  }
+
+  std::string GetName() const
+  {
+    return glib::String(g_volume_get_name(volume_)).Str();
+  }
+
+  std::string GetIconName() const
+  {
+    glib::Object<GIcon> icon(g_volume_get_icon(volume_));
+    return glib::String(g_icon_to_string(icon)).Str();
+  }
+
+  std::string GetIdentifier() const
+  {
+    return glib::String(g_volume_get_identifier(volume_, G_VOLUME_IDENTIFIER_KIND_UUID)).Str();
+  }
+
+  bool HasSiblings() const
+  {
+    glib::Object<GDrive> drive(g_volume_get_drive(volume_));
+
+    if (!drive)
+      return false;
+
+    GList* volumes = g_drive_get_volumes(drive);
+    bool has_sibilings = volumes && volumes->next;
+
+    if (volumes)
+      g_list_free_full(volumes, g_object_unref);
+
+    return has_sibilings;
+  }
+
+  bool IsMounted() const
+  {
+    glib::Object<GMount> mount(g_volume_get_mount(volume_));
+    return static_cast<bool>(mount);
+  }
+
+  void EjectAndShowNotification()
+  {
+    if (!CanBeEjected())
+      return;
+
+    glib::Object<GMountOperation> mount_op(gtk_mount_operation_new(nullptr));
+
+    g_volume_eject_with_operation(volume_,
+                                  (GMountUnmountFlags)0,
+                                  mount_op,
+                                  nullptr,
+                                  (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()
+  {
+    if (!IsMounted())
+      MountAndOnFinishOpenInFileManager();
+    else
+      OpenInFileManager();
+  }
+
+  void MountAndOnFinishOpenInFileManager()
+  {
+    g_volume_mount(volume_,
+                   (GMountMountFlags) 0,
+                   nullptr,
+                   nullptr,
+                   (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_opener_->Open(GetUri());
+  }
+
+  std::string GetUri()
+  {
+    glib::Object<GMount> mount(g_volume_get_mount(volume_));
+    glib::Object<GFile> root(g_mount_get_root(mount));
+
+    if (root.IsType(G_TYPE_FILE))
+      return glib::String(g_file_get_uri(root)).Str();
+    else
+     return std::string();
+  }
+
+  void StopDrive()
+  {
+    if (!CanBeStopped())
+      return;
+
+    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,
+                 nullptr, nullptr, nullptr);
+  }
+
+  void Unmount()
+  {
+    if (!IsMounted())
+      return;
+
+    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,
+                                   nullptr, nullptr, nullptr);
+  }
+
+  VolumeImp* parent_;
+  glib::Object<GCancellable> cancellable_;
+  glib::Object<GVolume> volume_;
+  FileManagerOpener::Ptr file_manager_opener_;
+  DeviceNotificationDisplay::Ptr device_notification_display_;
+
+  glib::Signal<void, GVolume*> signal_volume_changed_;
+  glib::Signal<void, GVolume*> signal_volume_removed_;
+};
+
+//
+// End private implementation
+//
+
+VolumeImp::VolumeImp(glib::Object<GVolume> const& volume,
+                     FileManagerOpener::Ptr const& file_manager_opener,
+                     DeviceNotificationDisplay::Ptr const& device_notification_display)
+  : pimpl(new Impl(volume, file_manager_opener, device_notification_display, this))
+{}
+
+VolumeImp::~VolumeImp()
+{}
+
+bool VolumeImp::CanBeEjected() const
+{
+  return pimpl->CanBeEjected();
+}
+
+bool VolumeImp::CanBeRemoved() const
+{
+  return pimpl->CanBeRemoved();
+}
+
+bool VolumeImp::CanBeStopped() const
+{
+  return pimpl->CanBeStopped();
+}
+
+std::string VolumeImp::GetName() const
+{
+  return pimpl->GetName();
+}
+
+std::string VolumeImp::GetIconName() const
+{
+  return pimpl->GetIconName();
+}
+
+std::string VolumeImp::GetIdentifier() const
+{
+  return pimpl->GetIdentifier();
+}
+
+bool VolumeImp::HasSiblings() const
+{
+  return pimpl->HasSiblings();
+}
+
+bool VolumeImp::IsMounted() const
+{
+  return pimpl->IsMounted();
+}
+
+void VolumeImp::MountAndOpenInFileManager()
+{
+  pimpl->MountAndOpenInFileManager();
+}
+
+void VolumeImp::EjectAndShowNotification()
+{
+  pimpl->EjectAndShowNotification();
+}
+
+void VolumeImp::StopDrive()
+{
+  pimpl->StopDrive();
+}
+
+void VolumeImp::Unmount()
+{
+  pimpl->Unmount();
+}
+
+} // namespace launcher
+} // namespace unity
 
=== added file 'launcher/VolumeImp.h'
--- launcher/VolumeImp.h	1970-01-01 00:00:00 +0000
+++ launcher/VolumeImp.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,68 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2012 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: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITYSHELL_VOLUME_IMP_H
+#define UNITYSHELL_VOLUME_IMP_H
+
+#include <memory>
+
+#include <UnityCore/GLibWrapper.h>
+
+#include "DeviceNotificationDisplay.h"
+#include "FileManagerOpener.h"
+#include "Volume.h"
+
+namespace unity
+{
+namespace launcher
+{
+
+class VolumeImp : public Volume
+{
+public:
+  typedef std::shared_ptr<VolumeImp> Ptr;
+
+  VolumeImp(glib::Object<GVolume> const& volume,
+            FileManagerOpener::Ptr const& file_manager_opener,
+            DeviceNotificationDisplay::Ptr const& device_notification_display);
+  virtual ~VolumeImp();
+
+  virtual bool CanBeEjected() const;
+  virtual bool CanBeRemoved() const;
+  virtual bool CanBeStopped() const;
+  virtual std::string GetName() const;
+  virtual std::string GetIconName() const;
+  virtual std::string GetIdentifier() const;
+  virtual bool HasSiblings() const;
+  virtual bool IsMounted() const;
+
+  virtual void EjectAndShowNotification();
+  virtual void MountAndOpenInFileManager();
+  virtual void StopDrive();
+  virtual void Unmount();
+
+private:
+  class Impl;
+  std::unique_ptr<Impl> pimpl;
+};
+
+}
+}
+
+#endif
 
=== renamed file 'launcher/DeviceLauncherIcon.cpp' => 'launcher/VolumeLauncherIcon.cpp'
--- launcher/DeviceLauncherIcon.cpp	2012-08-21 17:50:55 +0000
+++ launcher/VolumeLauncherIcon.cpp	2012-08-29 08:24:20 +0000
@@ -15,21 +15,17 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Andrea Azzarone <[e-mail]>
  */
 
-#include "DeviceLauncherIcon.h"
-
-#include <algorithm>
-#include <list>
 
 #include <glib/gi18n-lib.h>
-#include <libnotify/notify.h>
 #include <NuxCore/Logger.h>
+#include <UnityCore/GLibSignal.h>
 
 #include "DevicesSettings.h"
-#include "unity-shared/IconLoader.h"
-#include "unity-shared/ubus-server.h"
-#include "unity-shared/UBusMessages.h"
+#include "Volume.h"
+#include "VolumeLauncherIcon.h"
 
 namespace unity
 {
@@ -44,381 +40,265 @@
 
 }
 
-DeviceLauncherIcon::DeviceLauncherIcon(glib::Object<GVolume> const& volume)
+//
+// Start private implementation
+//
+class VolumeLauncherIcon::Impl
+{
+public:
+  typedef glib::Signal<void, DbusmenuMenuitem*, int> ItemSignal;
+
+  Impl(Volume::Ptr const& volume,
+       DevicesSettings::Ptr const& devices_settings,
+       VolumeLauncherIcon* parent)
+    : parent_(parent)
+    , volume_(volume)
+    , devices_settings_(devices_settings)
+  {
+    UpdateIcon();
+    UpdateVisibility();
+    ConnectSignals();
+  }
+
+  ~Impl()
+  { 
+    volume_changed_conn_.disconnect();
+    volume_removed_conn_.disconnect();
+    settings_changed_conn_.disconnect();
+  }
+
+  void UpdateIcon()
+  {
+    parent_->tooltip_text = volume_->GetName();
+    parent_->icon_name = volume_->GetIconName();
+
+    parent_->SetQuirk(Quirk::RUNNING, false);
+  }
+
+  void UpdateVisibility()
+  {
+    UpdateKeepInLauncher();
+    parent_->SetQuirk(Quirk::VISIBLE, keep_in_launcher_);
+  }
+
+  void UpdateKeepInLauncher()
+  {
+    auto identifier = volume_->GetIdentifier();
+    keep_in_launcher_ = !devices_settings_->IsABlacklistedDevice(identifier);
+  }
+
+  void ConnectSignals()
+  {
+    volume_changed_conn_ = volume_->changed.connect(sigc::mem_fun(this, &Impl::OnVolumeChanged));
+    volume_removed_conn_ = volume_->removed.connect(sigc::mem_fun(this, &Impl::OnVolumeRemoved));
+    settings_changed_conn_ = devices_settings_->changed.connect(sigc::mem_fun(this, &Impl::OnSettingsChanged));
+  }
+
+  void OnVolumeChanged()
+  {
+    UpdateIcon();
+  }
+
+  void OnVolumeRemoved()
+  {
+    if (devices_settings_->IsABlacklistedDevice(volume_->GetIdentifier()))
+      devices_settings_->TryToUnblacklist(volume_->GetIdentifier());
+
+    parent_->Remove();
+  }
+
+  void OnSettingsChanged()
+  {
+    UpdateVisibility();
+  }
+
+  bool CanEject() const
+  {
+    return volume_->CanBeEjected();
+  }
+
+  void EjectAndShowNotification()
+  {
+    return volume_->EjectAndShowNotification();
+  }
+
+  bool CanStop() const
+  {
+    return volume_->CanBeStopped();
+  }
+
+  void StopDrive()
+  {
+    volume_->StopDrive();
+  }
+
+  void ActivateLauncherIcon(ActionArg arg)
+  {
+    parent_->SimpleLauncherIcon::ActivateLauncherIcon(arg);
+    volume_->MountAndOpenInFileManager();
+  }
+
+  MenuItemsVector GetMenus()
+  {
+    MenuItemsVector result;
+
+    AppendUnlockFromLauncherItem(result);
+    AppendOpenItem(result);
+    AppendEjectItem(result);
+    AppendSafelyRemoveItem(result);
+    AppendUnmountItem(result);
+
+    return result;
+  }
+
+  void AppendUnlockFromLauncherItem(MenuItemsVector& menu)
+  {
+    if (volume_->GetIdentifier().empty())
+      return;
+
+    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
+
+    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Unlock from Launcher"));
+    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+    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 identifier = volume_->GetIdentifier();
+        devices_settings_->TryToBlacklist(identifier);
+    }));
+
+    menu.push_back(menu_item);
+  }
+
+  void AppendOpenItem(MenuItemsVector& menu)
+  {
+    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
+
+    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Open"));
+    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+    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_->MountAndOpenInFileManager();
+    }));
+
+    menu.push_back(menu_item);
+  }
+
+  void AppendEjectItem(MenuItemsVector& menu)
+  {
+    if (!volume_->CanBeEjected())
+      return;
+
+    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
+
+    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, volume_->HasSiblings() ? _("Eject parent drive") : _("Eject"));
+    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+    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();
+    }));
+
+    menu.push_back(menu_item);
+  }
+
+  void AppendSafelyRemoveItem(MenuItemsVector& menu)
+  {
+    if (!volume_->CanBeStopped())
+      return;
+
+    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
+
+    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, volume_->HasSiblings() ? _("Safely remove parent drive") : _("Safely remove"));
+    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+    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_->StopDrive();
+    }));
+
+    menu.push_back(menu_item);
+  }
+
+  void AppendUnmountItem(MenuItemsVector& menu)
+  {
+    if (!volume_->IsMounted() || volume_->CanBeEjected() || volume_->CanBeStopped())
+      return;
+
+    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
+
+    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Unmount"));
+    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
+    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_->Unmount();
+    }));
+
+    menu.push_back(menu_item);
+  }
+
+  VolumeLauncherIcon* parent_;
+  bool keep_in_launcher_;
+  Volume::Ptr volume_;
+  DevicesSettings::Ptr devices_settings_;
+
+  glib::SignalManager gsignals_;
+  sigc::connection settings_changed_conn_;
+  sigc::connection volume_changed_conn_;
+  sigc::connection volume_removed_conn_;
+};
+
+//
+// End private implementation
+//
+
+VolumeLauncherIcon::VolumeLauncherIcon(Volume::Ptr const& volume,
+                                       DevicesSettings::Ptr const& devices_settings)
   : SimpleLauncherIcon(IconType::DEVICE)
-  , volume_(volume)
-{
-  gsignals_.Add<void, GVolume*>(volume, "changed", sigc::mem_fun(this, &DeviceLauncherIcon::OnVolumeChanged));
-  DevicesSettings::GetDefault().changed.connect(sigc::mem_fun(this, &DeviceLauncherIcon::OnSettingsChanged));
-
-  // Checks if in favorites!
-  glib::String uuid(g_volume_get_identifier(volume_, G_VOLUME_IDENTIFIER_KIND_UUID));
-  DeviceList favorites = DevicesSettings::GetDefault().GetFavorites();
-  DeviceList::iterator pos = std::find(favorites.begin(), favorites.end(), uuid.Str());
-
-  keep_in_launcher_ = pos != favorites.end();
-
-  UpdateDeviceIcon();
-  UpdateVisibility();
-}
-
-void DeviceLauncherIcon::OnVolumeChanged(GVolume* volume)
-{
-  if (!G_IS_VOLUME(volume))
-    return;
-
-  changed_timeout_.reset(new glib::Timeout(volume_changed_timeout, [this]() {
-    UpdateDeviceIcon();
-    UpdateVisibility();
-    return false;
-  }));
-}
-
-void DeviceLauncherIcon::UpdateVisibility()
-{
-  switch (DevicesSettings::GetDefault().GetDevicesOption())
-  {
-    case DevicesSettings::NEVER:
-      SetQuirk(Quirk::VISIBLE, false);
-      break;
-    case DevicesSettings::ONLY_MOUNTED:
-      if (keep_in_launcher_)
-      {
-        SetQuirk(Quirk::VISIBLE, true);
-      }
-      else
-      {
-        glib::Object<GMount> mount(g_volume_get_mount(volume_));
-        SetQuirk(Quirk::VISIBLE, mount);
-      }
-      break;
-    case DevicesSettings::ALWAYS:
-      SetQuirk(Quirk::VISIBLE, true);
-      break;
-  }
-}
-
-void DeviceLauncherIcon::UpdateDeviceIcon()
-{
-  name_ = glib::String(g_volume_get_name(volume_)).Str();
-
-  glib::Object<GIcon> icon(g_volume_get_icon(volume_));
-  glib::String icon_string(g_icon_to_string(icon));
-
-  tooltip_text = name_;
-  icon_name = icon_string.Str();
-
-  SetQuirk(Quirk::RUNNING, false);
-}
-
-bool
-DeviceLauncherIcon::CanEject()
-{
-  return g_volume_can_eject(volume_);
-}
-
-bool
-DeviceLauncherIcon::CanStop()
-{
-  return g_drive_can_stop(g_volume_get_drive(volume_));
-}
-
-AbstractLauncherIcon::MenuItemsVector DeviceLauncherIcon::GetMenus()
-{
-  MenuItemsVector result;
-  glib::Object<DbusmenuMenuitem> menu_item;
-  glib::Object<GDrive> drive(g_volume_get_drive(volume_));
-  typedef glib::Signal<void, DbusmenuMenuitem*, int> ItemSignal;
-
-  // "Lock to Launcher"/"Unlock from Launcher" item
-  if (DevicesSettings::GetDefault().GetDevicesOption() == DevicesSettings::ONLY_MOUNTED
-      && drive && !g_drive_is_media_removable (drive))
-  {
-    menu_item = dbusmenu_menuitem_new();
-
-    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, !keep_in_launcher_ ? _("Lock to Launcher") : _("Unlock from Launcher"));
-    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
-    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
-
-    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
-                                 sigc::mem_fun(this, &DeviceLauncherIcon::OnTogglePin)));
-    result.push_back(menu_item);
-  }
-
-  // "Open" item
-  menu_item = dbusmenu_menuitem_new();
-
-  dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Open"));
-  dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
-  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) {
-    ActivateLauncherIcon(ActionArg(ActionArg::OTHER, 0));
-  }));
-
-  result.push_back(menu_item);
-
-  // "Eject" item
-  if (drive && g_drive_can_eject(drive))
-  {
-    menu_item = dbusmenu_menuitem_new();
-
-    GList *list = g_drive_get_volumes(drive);
-    if (list)
-    {
-      if (!list->next) // If the list has only one item
-        dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Eject"));
-      else
-        dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Eject parent drive"));
-
-      g_list_free_full(list, g_object_unref);
-    }
-
-    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
-    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) {
-      Eject();
-    }));
-
-    result.push_back(menu_item);
-  }
-
-  // "Safely remove" item
-  if (drive && g_drive_can_stop(drive))
-  {
-    menu_item = dbusmenu_menuitem_new();
-
-    GList *list = g_drive_get_volumes(drive);
-    if (list)
-    {
-      if (!list->next) // If the list has only one item
-        dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Safely remove"));
-      else
-        dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Safely remove parent drive"));
-
-      g_list_free_full(list, g_object_unref);
-    }
-
-    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
-    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) {
-      StopDrive();
-    }));
-
-    result.push_back(menu_item);
-  }
-
-  // "Unmount" item
-  if (!g_volume_can_eject(volume_))  // Don't need Unmount if can Eject
-  {
-    glib::Object<GMount> mount(g_volume_get_mount(volume_));
-
-    if (mount && g_mount_can_unmount(mount))
-    {
-      menu_item = dbusmenu_menuitem_new();
-
-      dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Unmount"));
-      dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
-      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) {
-        Unmount();
-      }));
-
-      result.push_back(menu_item);
-    }
-  }
-
-  return result;
-}
-
-void DeviceLauncherIcon::ShowMount(GMount* mount)
-{
-  if (G_IS_MOUNT(mount))
-  {
-    glib::Object<GFile> root(g_mount_get_root(mount));
-
-    if (G_IS_FILE(root.RawPtr()))
-    {
-      glib::String uri(g_file_get_uri(root));
-      glib::Error error;
-
-      g_app_info_launch_default_for_uri(uri.Value(), NULL, &error);
-
-      if (error)
-      {
-        LOG_WARNING(logger) << "Cannot open volume '" << name_
-                            << "': Unable to show " << uri
-                            << ": " << error;
-      }
-    }
-    else
-    {
-      LOG_WARNING(logger) << "Cannot open volume '" << name_
-                          << "': Mount has no root";
-    }
-  }
-  else
-  {
-    LOG_WARNING(logger) << "Cannot open volume '" << name_
-                        << "': Mount-point is invalid";
-  }
-}
-
-void DeviceLauncherIcon::ActivateLauncherIcon(ActionArg arg)
-{
-  SimpleLauncherIcon::ActivateLauncherIcon(arg);
-  SetQuirk(Quirk::STARTING, true);
-
-  glib::Object<GMount> mount(g_volume_get_mount(volume_));
-
-  if (G_IS_MOUNT(mount.RawPtr()))
-    ShowMount(mount);
-  else
-    g_volume_mount(volume_,
-                   (GMountMountFlags)0,
-                   NULL,
-                   NULL,
-                   (GAsyncReadyCallback)&DeviceLauncherIcon::OnMountReady,
-                   this);
-}
-
-void DeviceLauncherIcon::OnMountReady(GObject* object,
-                                      GAsyncResult* result,
-                                      DeviceLauncherIcon* self)
-{
-  glib::Error error;
-
-  if (g_volume_mount_finish(self->volume_, result, &error))
-  {
-    glib::Object<GMount> mount(g_volume_get_mount(self->volume_));
-    self->ShowMount(mount);
-  }
-  else
-  {
-    LOG_WARNING(logger) << "Cannot open volume '" << self->name_ << "' : " <<
-                            (error ? error.Message() : "Mount operation failed");
-  }
-}
-
-void DeviceLauncherIcon::OnEjectReady(GObject* object,
-                                      GAsyncResult* result,
-                                      DeviceLauncherIcon* self)
-{
-  if (g_volume_eject_with_operation_finish(self->volume_, result, NULL))
-  {
-    IconLoader::GetDefault().LoadFromGIconString(self->icon_name(), 48,
-                                                 sigc::bind(sigc::mem_fun(self, &DeviceLauncherIcon::ShowNotification), self->name_));
-  }
-}
-
-void DeviceLauncherIcon::ShowNotification(std::string const& icon_name,
-                                          unsigned size,
-                                          glib::Object<GdkPixbuf> const& pixbuf,
-                                          std::string const& name)
-{
-  glib::Object<NotifyNotification> notification(notify_notification_new(name.c_str(),
-                                                                        _("The drive has been successfully ejected"),
-                                                                        NULL));
-
-  notify_notification_set_hint(notification,
-                               "x-canonical-private-synchronous",
-                               g_variant_new_boolean(TRUE));
-
-  if (GDK_IS_PIXBUF(pixbuf.RawPtr()))
-    notify_notification_set_image_from_pixbuf(notification, pixbuf);
-
-  notify_notification_show(notification, NULL);
-}
-
-void DeviceLauncherIcon::Eject()
-{
-  glib::Object<GMountOperation> mount_op(gtk_mount_operation_new(NULL));
-
-  g_volume_eject_with_operation(volume_,
-                                (GMountUnmountFlags)0,
-                                mount_op,
-                                NULL,
-                                (GAsyncReadyCallback)OnEjectReady,
-                                this);
-}
-
-void DeviceLauncherIcon::OnTogglePin(DbusmenuMenuitem* item, int time)
-{
-  glib::String uuid(g_volume_get_identifier(volume_, G_VOLUME_IDENTIFIER_KIND_UUID));
-
-  keep_in_launcher_ = !keep_in_launcher_;
-
-  if (!keep_in_launcher_)
-  {
-    // If the volume is not mounted hide the icon
-    glib::Object<GMount> mount(g_volume_get_mount(volume_));
-
-    if (!mount)
-      SetQuirk(Quirk::VISIBLE, false);
-
-    // Remove from favorites
-    if (!uuid.Str().empty())
-      DevicesSettings::GetDefault().RemoveFavorite(uuid.Str());
-  }
-  else
-  {
-    if (!uuid.Str().empty())
-      DevicesSettings::GetDefault().AddFavorite(uuid.Str());
-  }
-}
-
-void DeviceLauncherIcon::OnUnmountReady(GObject* object,
-                                        GAsyncResult* result,
-                                        DeviceLauncherIcon* self)
-{
-  if (G_IS_MOUNT(object))
-    g_mount_unmount_with_operation_finish(G_MOUNT(object), result, NULL);
-}
-
-void DeviceLauncherIcon::Unmount()
-{
-  glib::Object<GMount> mount(g_volume_get_mount(volume_));
-
-  if (mount)
-  {
-    glib::Object<GMountOperation> op(gtk_mount_operation_new(NULL));
-
-    g_mount_unmount_with_operation(mount, (GMountUnmountFlags)0, op, NULL,
-                                   (GAsyncReadyCallback)OnUnmountReady, this);
-  }
-}
-
-void DeviceLauncherIcon::OnRemoved()
-{
-  Remove();
-}
-
-void DeviceLauncherIcon::StopDrive()
-{
-  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, NULL, NULL, NULL);
-}
-
-void DeviceLauncherIcon::OnSettingsChanged()
-{
-  // Checks if in favourites!
-  glib::String uuid(g_volume_get_identifier(volume_, G_VOLUME_IDENTIFIER_KIND_UUID));
-  DeviceList favorites = DevicesSettings::GetDefault().GetFavorites();
-  DeviceList::iterator pos = std::find(favorites.begin(), favorites.end(), uuid.Str());
-
-  keep_in_launcher_ = pos != favorites.end();
-
-  UpdateVisibility();
-}
-
-std::string DeviceLauncherIcon::GetName() const
-{
-  return "DeviceLauncherIcon";
+  , pimpl_(new Impl(volume, devices_settings, this))
+{}
+
+VolumeLauncherIcon::~VolumeLauncherIcon()
+{}
+
+bool VolumeLauncherIcon::CanEject() const
+{
+  return pimpl_->CanEject();
+}
+
+void VolumeLauncherIcon::EjectAndShowNotification()
+{
+  pimpl_->EjectAndShowNotification();
+}
+
+bool VolumeLauncherIcon::CanStop() const
+{
+  return pimpl_->CanStop();
+}
+
+void VolumeLauncherIcon::StopDrive()
+{
+  return pimpl_->StopDrive();
+}
+
+void VolumeLauncherIcon::ActivateLauncherIcon(ActionArg arg)
+{
+  pimpl_->ActivateLauncherIcon(arg);
+}
+
+AbstractLauncherIcon::MenuItemsVector VolumeLauncherIcon::GetMenus()
+{
+  return pimpl_->GetMenus();
+}
+
+//
+// Introspection
+//
+std::string VolumeLauncherIcon::GetName() const
+{
+  return "VolumeLauncherIcon";
 }
 
 } // namespace launcher
 
=== renamed file 'launcher/DeviceLauncherIcon.h' => 'launcher/VolumeLauncherIcon.h'
--- launcher/DeviceLauncherIcon.h	2012-08-21 17:59:29 +0000
+++ launcher/VolumeLauncherIcon.h	2012-08-29 08:24:20 +0000
@@ -15,15 +15,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Andrea Azzarone <[e-mail]>
  */
 
-#ifndef _DEVICE_LAUNCHER_ICON_H__H
-#define _DEVICE_LAUNCHER_ICON_H__H
-
-#include <gio/gio.h>
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/GLibSignal.h>
-
+#ifndef UNITYSHELL_VOLUME_LAUNCHER_ICON_H
+#define UNITYSHELL_VOLUME_LAUNCHER_ICON_H
+
+#include "Volume.h"
+#include "DevicesSettings.h"
 #include "SimpleLauncherIcon.h"
 
 namespace unity
@@ -31,48 +30,33 @@
 namespace launcher
 {
 
-class DeviceLauncherIcon : public SimpleLauncherIcon
+class VolumeLauncherIcon : public SimpleLauncherIcon
 {
 public:
-  typedef nux::ObjectPtr<DeviceLauncherIcon> Ptr;
-
-  DeviceLauncherIcon(glib::Object<GVolume> const& volume);
-
-  void OnRemoved();
-  bool CanEject();
-  bool CanStop();
-  void Eject();
+  typedef nux::ObjectPtr<VolumeLauncherIcon> Ptr;
+
+  VolumeLauncherIcon(Volume::Ptr const& volume,
+                     DevicesSettings::Ptr const& devices_settings);
+  virtual ~VolumeLauncherIcon();
+
+  bool CanEject() const; // TODO: rename to public virtual bool IsTrashable();
+  void EjectAndShowNotification(); // TODO: rename to private virtual void DoDropToTrash();
+  bool CanStop() const;
   void StopDrive();
+  MenuItemsVector GetMenus();
 
 protected:
-  MenuItemsVector GetMenus();
-  std::string GetName() const;
-
-private:
-  void UpdateVisibility();
-  void UpdateDeviceIcon();
-  void ActivateLauncherIcon(ActionArg arg);
-  void ShowMount(GMount* mount);
-  void Unmount();
-  void OnTogglePin(DbusmenuMenuitem* item, int time);
-  void OnSettingsChanged();
-  void ShowNotification(std::string const&, unsigned, glib::Object<GdkPixbuf> const&, std::string const&);
-  void OnVolumeChanged(GVolume* volume);
-  static void OnChanged(GVolume* volume, DeviceLauncherIcon* self);
-  static void OnMountReady(GObject* object, GAsyncResult* result, DeviceLauncherIcon* self);
-  static void OnEjectReady(GObject* object, GAsyncResult* result, DeviceLauncherIcon* self);
-  static void OnUnmountReady(GObject* object, GAsyncResult* result, DeviceLauncherIcon* self);
-
-private:
-  glib::Source::UniquePtr changed_timeout_;
-  glib::Object<GVolume> volume_;
-  glib::SignalManager gsignals_;
-
-  std::string name_;
-  bool keep_in_launcher_;
+  virtual void ActivateLauncherIcon(ActionArg arg);
+
+  // Introspection
+  virtual std::string GetName() const;
+
+private:
+  class Impl;
+  std::shared_ptr<Impl> pimpl_;
 };
 
 }
-} // namespace unity
+}
 
-#endif // _DEVICE_LAUNCHER_ICON_H__H
+#endif
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-08-27 19:08:38 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-08-29 08:24:20 +0000
@@ -29,7 +29,6 @@
 #include "Launcher.h"
 #include "LauncherIcon.h"
 #include "LauncherController.h"
-#include "DevicesSettings.h"
 #include "PluginAdapter.h"
 #include "QuicklistManager.h"
 #include "StartupNotifyService.h"
@@ -281,7 +280,6 @@
      optionSetIconSizeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetAutohideAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetDashBlurExperimentalNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
-     optionSetDevicesOptionNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShortcutOverlayNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowDesktopIconNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowLauncherInitiate(boost::bind(&UnityScreen::showLauncherKeyInitiate, this, _1, _2, _3));
@@ -2925,9 +2923,6 @@
     case UnityshellOptions::AutomaximizeValue:
       PluginAdapter::Default()->SetCoverageAreaBeforeAutomaximize(optionGetAutomaximizeValue() / 100.0f);
       break;
-    case UnityshellOptions::DevicesOption:
-      unity::DevicesSettings::GetDefault().SetDevicesOption((unity::DevicesSettings::DevicesOption) optionGetDevicesOption());
-      break;
     case UnityshellOptions::AltTabTimeout:
       switcher_controller_->detail_on_timeout = optionGetAltTabTimeout();
     case UnityshellOptions::AltTabBiasViewport:
 
=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2012-08-07 10:41:46 +0000
+++ plugins/unityshell/unityshell.xml.in	2012-08-29 08:24:20 +0000
@@ -394,26 +394,6 @@
                     <default>75</default>
                 </option>
 
-                <option name="devices_option" type="int">
-                    <_short>Show Devices</_short>
-                    <_long>Show devices in the launcher</_long>
-                    <min>0</min>
-                    <max>2</max>
-                    <default>1</default>
-                    <desc>
-                        <value>0</value>
-                        <_name>Never</_name>
-                    </desc>
-                    <desc>
-                        <value>1</value>
-                        <_name>Only Mounted</_name>
-                    </desc>
-                    <desc>
-                        <value>2</value>
-                        <_name>Always</_name>
-                    </desc>
-                </option>
-
                 <option name="shortcut_overlay" type="bool">
                   <_short>Enable Shortcut Hints Overlay</_short>
                   <_long>Enable Shortcut Hints Overlay</_long>
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2012-08-23 06:15:27 +0000
+++ po/POTFILES.in	2012-08-29 08:24:20 +0000
@@ -11,11 +11,12 @@
 launcher/BFBLauncherIcon.cpp
 launcher/BamfLauncherIcon.cpp
 launcher/DesktopLauncherIcon.cpp
-launcher/DeviceLauncherIcon.cpp
+launcher/DeviceNotificationShowerImp.cpp
 launcher/LauncherController.cpp
 launcher/SoftwareCenterLauncherIcon.cpp
 launcher/SpacerLauncherIcon.cpp
 launcher/TrashLauncherIcon.cpp
+launcher/VolumeLauncherIcon.cpp
 panel/PanelMenuView.cpp
 plugins/networkarearegion/networkarearegion.xml.in
 plugins/unity-mt-grab-handles/unitymtgrabhandles.xml.in
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-08-28 12:23:15 +0000
+++ tests/CMakeLists.txt	2012-08-29 08:24:20 +0000
@@ -227,6 +227,9 @@
                  test_switcher_model.cpp
                  test_texture_cache.cpp
                  test_thumbnail_generator.cpp
+                 test_volume_imp.cpp
+                 test_volume_launcher_icon.cpp
+                 gmockmount.c
                  gmockvolume.c
                  ${CMAKE_SOURCE_DIR}/dash/AbstractPlacesGroup.cpp
                  ${CMAKE_SOURCE_DIR}/dash/DashViewPrivate.cpp
@@ -258,14 +261,15 @@
                  ${CMAKE_SOURCE_DIR}/launcher/DNDCollectionWindow.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/Decaymulator.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/DesktopLauncherIcon.cpp
-                 ${CMAKE_SOURCE_DIR}/launcher/DeviceLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/DeviceLauncherSection.cpp
-                 ${CMAKE_SOURCE_DIR}/launcher/DevicesSettings.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/DeviceNotificationDisplayImp.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/DevicesSettingsImp.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/DndData.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/EdgeBarrierController.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStore.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStoreGSettings.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/FavoriteStorePrivate.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/FileManagerOpenerImp.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/HudLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/Launcher.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/LauncherController.cpp
@@ -296,6 +300,8 @@
                  ${CMAKE_SOURCE_DIR}/launcher/SwitcherView.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/Tooltip.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/TrashLauncherIcon.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/VolumeImp.cpp
+                 ${CMAKE_SOURCE_DIR}/launcher/VolumeLauncherIcon.cpp
                  ${CMAKE_SOURCE_DIR}/launcher/VolumeMonitorWrapper.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/Animator.cpp
                  ${CMAKE_SOURCE_DIR}/unity-shared/BackgroundEffectHelper.cpp
 
=== added file 'tests/gmockmount.c'
--- tests/gmockmount.c	1970-01-01 00:00:00 +0000
+++ tests/gmockmount.c	2012-08-29 08:24:20 +0000
@@ -0,0 +1,167 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ *
+ */
+
+#include <glib.h>
+
+#include "gmockmount.h"
+
+static void g_mock_mount_iface_init (GMountIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GMockMount, g_mock_mount, G_TYPE_OBJECT,
+			 G_IMPLEMENT_INTERFACE (G_TYPE_MOUNT,
+						g_mock_mount_iface_init))
+
+static void
+g_mock_mount_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (g_mock_mount_parent_class)->finalize (object);
+}
+
+static void
+g_mock_mount_dispose (GObject *object)
+{
+  G_OBJECT_CLASS (g_mock_mount_parent_class)->dispose (object);
+}
+
+
+static void
+g_mock_mount_class_init (GMockMountClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->finalize = g_mock_mount_finalize;
+  gobject_class->dispose = g_mock_mount_dispose;
+}
+
+static void
+g_mock_mount_init (GMockMount *mock_mount)
+{}
+
+GMockMount *
+g_mock_mount_new ()
+{
+  GMockMount *mount;
+
+  mount = g_object_new (G_TYPE_MOCK_MOUNT, NULL);
+
+  return mount;
+}
+
+static GFile *
+g_mock_mount_get_root (GMount *mount)
+{
+  return g_file_new_for_path (ROOT_FILE_PATH);
+}
+
+static GIcon *
+g_mock_mount_get_icon (GMount *mount)
+{
+  return NULL;
+}
+
+static char *
+g_mock_mount_get_uuid (GMount *mount)
+{
+  return g_strdup ("");
+}
+
+static char *
+g_mock_mount_get_name (GMount *mount)
+{
+  return g_strdup ("");
+}
+
+static GDrive *
+g_mock_mount_get_drive (GMount *mount)
+{
+  return NULL;
+}
+
+static GVolume *
+g_mock_mount_get_volume (GMount *mount)
+{
+  return NULL;
+}
+
+static gboolean
+g_mock_mount_can_unmount (GMount *mount)
+{
+  return TRUE;
+}
+
+static gboolean
+g_mock_mount_can_eject (GMount *mount)
+{
+  return FALSE;
+}
+
+static void
+g_mock_mount_unmount (GMount             *mount,
+                      GMountUnmountFlags flags,
+                      GCancellable        *cancellable,
+                      GAsyncReadyCallback  callback,
+                      gpointer             user_data)
+{
+}
+
+static gboolean
+g_mock_mount_unmount_finish (GMount       *mount,
+                             GAsyncResult  *result,
+                             GError       **error)
+{
+  return TRUE;
+}
+
+static void
+g_mock_mount_eject (GMount             *mount,
+                    GMountUnmountFlags flags,
+                    GCancellable        *cancellable,
+                    GAsyncReadyCallback  callback,
+                    gpointer             user_data)
+{
+}
+
+static gboolean
+g_mock_mount_eject_finish (GMount       *mount,
+                           GAsyncResult  *result,
+                           GError       **error)
+{
+  return TRUE;
+}
+
+
+static void
+g_mock_mount_iface_init (GMountIface *iface)
+{
+  iface->get_root = g_mock_mount_get_root;
+  iface->get_name = g_mock_mount_get_name;
+  iface->get_icon = g_mock_mount_get_icon;
+  iface->get_uuid = g_mock_mount_get_uuid;
+  iface->get_drive = g_mock_mount_get_drive;
+  iface->get_volume = g_mock_mount_get_volume;
+  iface->can_unmount = g_mock_mount_can_unmount;
+  iface->can_eject = g_mock_mount_can_eject;
+  iface->unmount = g_mock_mount_unmount;
+  iface->unmount_finish = g_mock_mount_unmount_finish;
+  iface->eject = g_mock_mount_eject;
+  iface->eject_finish = g_mock_mount_eject_finish;
+}
 
=== added file 'tests/gmockmount.h'
--- tests/gmockmount.h	1970-01-01 00:00:00 +0000
+++ tests/gmockmount.h	2012-08-29 08:24:20 +0000
@@ -0,0 +1,55 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ *
+ */
+
+#ifndef UNITYSHELL_G_MOCK_MOUNT_H
+#define UNITYSHELL_G_MOCK_MOUNT_H
+
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define ROOT_FILE_PATH "/some/directory/testfile"
+#define ROOT_FILE_URI "file://" ROOT_FILE_PATH
+
+#define G_TYPE_MOCK_MOUNT        (g_mock_mount_get_type ())
+#define G_MOCK_MOUNT(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_MOCK_MOUNT, GMockMount))
+#define G_MOCK_MOUNT_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_MOCK_MOUNT, GMockMountClass))
+#define G_IS_MOCK_MOUNT(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_MOCK_MOUNT))
+#define G_IS_MOCK_MOUNT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_MOCK_MOUNT))
+
+typedef struct _GMockMount GMockMount;
+typedef struct _GMockMountClass GMockMountClass;
+
+struct _GMockMount {
+  GObject parent;
+};
+
+struct _GMockMountClass {
+  GObjectClass parent_class;
+};
+
+GType         g_mock_mount_get_type  (void) G_GNUC_CONST;
+GMockMount *  g_mock_mount_new       ();
+
+G_END_DECLS
+
+#endif // UNITYSHELL_G_MOCK_MOUNT_H
 
=== modified file 'tests/gmockvolume.c'
--- tests/gmockvolume.c	2012-07-18 22:47:34 +0000
+++ tests/gmockvolume.c	2012-08-29 08:24:20 +0000
@@ -22,13 +22,13 @@
 
 #include <glib.h>
 
+#include "gmockmount.h"
 #include "gmockvolume.h"
 
-static void g_mock_volume_volume_iface_init (GVolumeIface *iface);
+static void g_mock_volume_iface_init (GVolumeIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (GMockVolume, g_mock_volume, G_TYPE_OBJECT,
-			 G_IMPLEMENT_INTERFACE (G_TYPE_VOLUME,
-						g_mock_volume_volume_iface_init))
+                         G_IMPLEMENT_INTERFACE (G_TYPE_VOLUME, g_mock_volume_iface_init))
 
 static void
 g_mock_volume_finalize (GObject *object)
@@ -37,44 +37,119 @@
 }
 
 static void
+g_mock_volume_dispose (GObject *object)
+{
+  GMockVolume *self = G_MOCK_VOLUME (object);
+
+  self->can_eject = FALSE;
+
+  if (self->name)
+  {
+    g_free(self->name);
+    self->name = NULL;
+  }
+
+  if (self->icon)
+  {
+    g_object_unref(self->icon);
+    self->icon = NULL;
+  }
+
+  if (self->uuid)
+  {
+    g_free(self->uuid);
+    self->uuid = NULL;
+  }
+
+  if (self->mount)
+  {
+    g_object_unref(self->mount);
+    self->mount = NULL;
+  }
+
+  G_OBJECT_CLASS (g_mock_volume_parent_class)->dispose (object);
+}
+
+
+static void
 g_mock_volume_class_init (GMockVolumeClass *klass)
 {
   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 
   gobject_class->finalize = g_mock_volume_finalize;
+  gobject_class->dispose = g_mock_volume_dispose;
 }
 
 static void
 g_mock_volume_init (GMockVolume *mock_volume)
 {
+  mock_volume->name = g_strdup("");
+  mock_volume->icon = g_icon_new_for_string("", NULL);
+  mock_volume->uuid = g_strdup("");
+  mock_volume->mount = NULL;
 }
 
 GMockVolume *
 g_mock_volume_new ()
 {
   GMockVolume *volume;
-  
+
   volume = g_object_new (G_TYPE_MOCK_VOLUME, NULL);
 
   return volume;
 }
 
+void
+g_mock_volume_set_name (GMockVolume *volume, const char* name)
+{
+  if (volume->name)
+    g_free(volume->name);
+
+  volume->name = g_strdup (name);
+}
+
 static char *
 g_mock_volume_get_name (GVolume *volume)
 {
-  return g_strdup ("");
-}
+  GMockVolume *self = G_MOCK_VOLUME (volume);
+  return g_strdup (self->name);
+}
+
+void
+g_mock_volume_set_icon (GMockVolume *volume, GIcon *icon)
+{
+  if (volume->icon)
+    g_object_unref(volume->icon);
+
+  volume->icon = icon;
+}
+
 
 static GIcon *
 g_mock_volume_get_icon (GVolume *volume)
 {
-  return g_icon_new_for_string("", NULL);
+  GMockVolume *self = G_MOCK_VOLUME (volume);
+
+  if (self->icon)
+    return g_object_ref (self->icon);
+  else
+    return NULL;
+}
+
+void
+g_mock_volume_set_uuid (GMockVolume *volume, const char* uuid)
+{
+  if (volume->uuid)
+    g_free(volume->uuid);
+
+  volume->uuid = g_strdup (uuid);
 }
 
 static char *
 g_mock_volume_get_uuid (GVolume *volume)
 {
-  return NULL;
+  GMockVolume *self = G_MOCK_VOLUME (volume);
+  return g_strdup (self->uuid);
 }
 
 static GDrive *
@@ -83,10 +158,23 @@
   return NULL;
 }
 
+void
+g_mock_volume_set_mount (GMockVolume *volume, GMount *mount)
+{
+  if (volume->mount)
+    g_object_unref(volume->mount);
+
+  volume->mount = mount;
+}
+
 static GMount *
 g_mock_volume_get_mount (GVolume *volume)
 {
-  return NULL;
+  GMockVolume *self = G_MOCK_VOLUME (volume);
+  if (self->mount)
+    return g_object_ref (self->mount);
+  else
+    return NULL;
 }
 
 static gboolean
@@ -98,7 +186,14 @@
 static gboolean
 g_mock_volume_can_eject (GVolume *volume)
 {
-  return FALSE;
+  GMockVolume *self = G_MOCK_VOLUME (volume);
+  return self->can_eject;
+}
+
+void
+g_mock_volume_set_can_eject (GMockVolume* mock_volume, gboolean can_eject)
+{
+  mock_volume->can_eject = can_eject;
 }
 
 static gboolean
@@ -115,6 +210,11 @@
                      GAsyncReadyCallback  callback,
                      gpointer             user_data)
 {
+  g_mock_volume_set_mount(G_MOCK_VOLUME(volume), G_MOUNT(g_mock_mount_new()));
+
+  callback(NULL,
+           G_ASYNC_RESULT (g_simple_async_result_new (NULL, NULL, NULL, NULL)),
+           user_data);
 }
 
 static gboolean
@@ -132,7 +232,10 @@
                      GAsyncReadyCallback  callback,
                      gpointer             user_data)
 {
-}
+  
+  callback(NULL,
+           G_ASYNC_RESULT (g_simple_async_result_new (NULL, NULL, NULL, NULL)),
+           user_data);}
 
 static gboolean
 g_mock_volume_eject_finish (GVolume       *volume,
@@ -146,6 +249,11 @@
 g_mock_volume_get_identifier (GVolume     *volume,
                               const gchar *kind)
 {
+  GMockVolume *self = G_MOCK_VOLUME (volume);
+
+  if (!g_strcmp0 (kind, G_VOLUME_IDENTIFIER_KIND_UUID))
+    return g_strdup (self->uuid);
+
   return NULL;
 }
 
@@ -156,7 +264,7 @@
 }
 
 static void
-g_mock_volume_volume_iface_init (GVolumeIface *iface)
+g_mock_volume_iface_init (GVolumeIface *iface)
 {
   iface->get_name = g_mock_volume_get_name;
   iface->get_icon = g_mock_volume_get_icon;
@@ -173,4 +281,3 @@
   iface->get_identifier = g_mock_volume_get_identifier;
   iface->enumerate_identifiers = g_mock_volume_enumerate_identifiers;
 }
-
 
=== modified file 'tests/gmockvolume.h'
--- tests/gmockvolume.h	2012-07-18 22:47:34 +0000
+++ tests/gmockvolume.h	2012-08-29 08:24:20 +0000
@@ -38,14 +38,26 @@
 
 struct _GMockVolume {
   GObject parent;
+
+  gboolean can_eject;
+  char *name;
+  GIcon *icon;
+  char *uuid;
+  GMount *mount;
 };
 
 struct _GMockVolumeClass {
   GObjectClass parent_class;
 };
 
-GType         g_mock_volume_get_type (void) G_GNUC_CONST;
-GMockVolume * g_mock_volume_new      ();
+GType         g_mock_volume_get_type  (void) G_GNUC_CONST;
+GMockVolume * g_mock_volume_new       ();
+
+void          g_mock_volume_set_can_eject (GMockVolume* volume, gboolean can_eject);
+void          g_mock_volume_set_name  (GMockVolume *volume, const char *name);
+void          g_mock_volume_set_icon  (GMockVolume *volume, GIcon *icon);
+void          g_mock_volume_set_uuid  (GMockVolume *volume, const char *uuid);
+void          g_mock_volume_set_mount (GMockVolume *volume, GMount *mount);
 
 G_END_DECLS
 
 
=== modified file 'tests/test_device_launcher_section.cpp'
--- tests/test_device_launcher_section.cpp	2012-07-18 22:47:34 +0000
+++ tests/test_device_launcher_section.cpp	2012-08-29 08:24:20 +0000
@@ -24,6 +24,7 @@
 using namespace testing;
 
 #include "DeviceLauncherSection.h"
+#include "DevicesSettings.h"
 #include "AbstractVolumeMonitorWrapper.h"
 using namespace unity;
 using namespace unity::launcher;
@@ -74,12 +75,20 @@
   glib::Object<GVolume> volume2;
 };
 
+class MockDevicesSettings : public DevicesSettings
+{
+  MOCK_CONST_METHOD1(IsABlacklistedDevice, bool(std::string const& uuid));
+  MOCK_METHOD1(TryToBlacklist, void(std::string const& uuid));
+  MOCK_METHOD1(TryToUnblacklist, void(std::string const& uuid));
+};
+
 class TestDeviceLauncherSection : public Test
 {
 public:
   TestDeviceLauncherSection()
     : monitor_(new MockVolumeMonitorWrapper)
-    , section_(monitor_)
+    , devices_settings_(new MockDevicesSettings)
+    , section_(monitor_, devices_settings_)
   {}
 
   void SetUp()
@@ -89,6 +98,7 @@
   }
 
   MockVolumeMonitorWrapper::Ptr monitor_;
+  DevicesSettings::Ptr devices_settings_;
   DeviceLauncherSection section_;
 };
 
 
=== added file 'tests/test_volume_imp.cpp'
--- tests/test_volume_imp.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_volume_imp.cpp	2012-08-29 08:24:20 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2012 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 <memory>
+
+#include <gmock/gmock.h>
+using namespace testing;
+
+#include "gmockmount.h"
+#include "gmockvolume.h"
+#include "launcher/VolumeImp.h"
+#include "test_utils.h"
+using namespace unity;
+
+namespace
+{
+
+class MockFileManagerOpener : public launcher::FileManagerOpener
+{
+public:
+  typedef std::shared_ptr<MockFileManagerOpener> Ptr;
+
+  MOCK_METHOD1(Open, void(std::string const& uri));
+};
+
+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_opener_.reset(new MockFileManagerOpener);
+    device_notification_display_.reset(new MockDeviceNotificationDisplay);
+    volume_.reset(new launcher::VolumeImp(glib::Object<GVolume>(G_VOLUME(gvolume_.RawPtr()), glib::AddRef()),
+                                          file_manager_opener_, device_notification_display_));
+  }
+
+  glib::Object<GMockVolume> gvolume_;
+  MockFileManagerOpener::Ptr file_manager_opener_;
+  MockDeviceNotificationDisplay::Ptr device_notification_display_;
+  launcher::VolumeImp::Ptr volume_;
+};
+
+TEST_F(TestVolumeImp, TestCtor)
+{
+  EXPECT_FALSE(volume_->IsMounted());
+}
+
+TEST_F(TestVolumeImp, TestCanBeEjected)
+{
+  EXPECT_FALSE(volume_->CanBeEjected());
+
+  g_mock_volume_set_can_eject(gvolume_, TRUE);
+  EXPECT_TRUE(volume_->CanBeEjected());
+}
+
+TEST_F(TestVolumeImp, TestGetName)
+{
+  std::string const volume_name("Test Device");
+
+  // g_mock_volume_set_name is equivalent to
+  // EXPECT_CALL(gvolume_, g_volume_get_name) ...
+  g_mock_volume_set_name(gvolume_, volume_name.c_str());
+  EXPECT_EQ(volume_->GetName(), volume_name);
+}
+
+TEST_F(TestVolumeImp, TestGetIconName)
+{
+  std::string const icon_name("gnome-dev-cdrom");
+
+  g_mock_volume_set_icon(gvolume_, g_icon_new_for_string(icon_name.c_str(), NULL));
+  EXPECT_EQ(volume_->GetIconName(), icon_name);
+}
+
+TEST_F(TestVolumeImp, TestGetIdentifier)
+{
+  std::string const uuid("0123456789abc");
+
+  g_mock_volume_set_uuid(gvolume_, uuid.c_str());
+  EXPECT_EQ(volume_->GetIdentifier(), uuid);
+}
+
+TEST_F(TestVolumeImp, TestIsMounted)
+{
+  g_mock_volume_set_mount(gvolume_, nullptr);
+  ASSERT_FALSE(volume_->IsMounted());
+
+  g_mock_volume_set_mount(gvolume_, G_MOUNT(g_mock_mount_new()));
+  EXPECT_TRUE(volume_->IsMounted());
+}
+
+TEST_F(TestVolumeImp, TestEjectAndShowNotification)
+{
+  g_mock_volume_set_can_eject(gvolume_, TRUE);
+
+  EXPECT_CALL(*device_notification_display_, Display(volume_->GetIconName(), volume_->GetName()))
+    .Times(1);
+
+  volume_->EjectAndShowNotification();
+}
+
+TEST_F(TestVolumeImp, TestMountAndOpenInFileManager)
+{
+  EXPECT_CALL(*file_manager_opener_, Open(ROOT_FILE_URI))
+      .Times(1);
+
+  volume_->MountAndOpenInFileManager();
+  EXPECT_TRUE(volume_->IsMounted());
+
+  EXPECT_CALL(*file_manager_opener_, Open(ROOT_FILE_URI))
+      .Times(1);
+
+  volume_->MountAndOpenInFileManager();
+  EXPECT_TRUE(volume_->IsMounted());
+}
+
+TEST_F(TestVolumeImp, TestChangedSignal)
+{
+  bool callback_called = false;
+  volume_->changed.connect([&]() {
+    callback_called = true;
+  });
+
+  g_signal_emit_by_name(gvolume_, "changed", nullptr);
+  Utils::WaitUntil(callback_called);
+}
+
+TEST_F(TestVolumeImp, TestRemovedSignal)
+{
+  bool callback_called = false;
+  volume_->removed.connect([&]() {
+    callback_called = true;
+  });
+
+  g_signal_emit_by_name(gvolume_, "removed", nullptr);
+  Utils::WaitUntil(callback_called);
+}
+
+}
 
=== added file 'tests/test_volume_launcher_icon.cpp'
--- tests/test_volume_launcher_icon.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_volume_launcher_icon.cpp	2012-08-29 08:24:20 +0000
@@ -0,0 +1,498 @@
+/*
+ * Copyright 2012 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 "launcher/DevicesSettings.h"
+#include "launcher/Volume.h"
+#include "launcher/VolumeLauncherIcon.h"
+#include "test_utils.h"
+using namespace unity;
+using namespace unity::launcher;
+
+namespace
+{
+
+class MockVolume : public Volume
+{
+public:
+  typedef std::shared_ptr<MockVolume> Ptr;
+
+  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(HasSiblings, bool(void));
+  MOCK_CONST_METHOD0(CanBeEjected, bool(void));
+  MOCK_CONST_METHOD0(IsMounted, bool(void));
+
+  MOCK_METHOD0(EjectAndShowNotification, void(void));
+  MOCK_METHOD0(MountAndOpenInFileManager, void(void));
+  MOCK_METHOD0(StopDrive, void(void));
+  MOCK_METHOD0(Unmount, void(void));
+};
+
+class MockDevicesSettings : public DevicesSettings
+{
+public:
+  typedef std::shared_ptr<MockDevicesSettings> Ptr;
+
+  MOCK_CONST_METHOD1(IsABlacklistedDevice, bool(std::string const& uuid));
+  MOCK_METHOD1(TryToBlacklist, void(std::string const& uuid));
+  MOCK_METHOD1(TryToUnblacklist, void(std::string const& uuid));
+};
+
+
+class TestVolumeLauncherIcon : public Test
+{
+public:
+  virtual void SetUp()
+  {
+    volume_.reset(new MockVolume);
+    settings_.reset(new MockDevicesSettings);
+
+    SetupVolumeDefaultBehavior();
+    SetupSettingsDefaultBehavior();
+  }
+
+  void CreateIcon()
+  {
+    icon_ = new VolumeLauncherIcon(volume_, settings_);
+  }
+
+  void SetupSettingsDefaultBehavior()
+  {
+    EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+      .WillRepeatedly(Return(false));
+  }
+
+  void SetupVolumeDefaultBehavior()
+  {
+    EXPECT_CALL(*volume_, CanBeRemoved())
+      .WillRepeatedly(Return(false));
+
+    EXPECT_CALL(*volume_, CanBeStopped())
+      .WillRepeatedly(Return(false));
+
+    EXPECT_CALL(*volume_, GetName())
+      .WillRepeatedly(Return("Test Name"));
+
+    EXPECT_CALL(*volume_, GetIconName())
+      .WillRepeatedly(Return("Test Icon Name"));
+
+    EXPECT_CALL(*volume_, GetIdentifier())
+      .WillRepeatedly(Return("Test Identifier"));
+
+    EXPECT_CALL(*volume_, HasSiblings())
+      .WillRepeatedly(Return(false));
+
+    EXPECT_CALL(*volume_, CanBeEjected())
+      .WillRepeatedly(Return(false));
+
+    EXPECT_CALL(*volume_, IsMounted())
+      .WillRepeatedly(Return(true));
+  }
+
+  glib::Object<DbusmenuMenuitem> GetMenuItemAtIndex(int index)
+  {
+    auto menuitems = icon_->GetMenus();
+    auto menuitem = menuitems.begin();
+    std::advance(menuitem, index);
+
+    return *menuitem;
+  } 
+
+  MockVolume::Ptr volume_;
+  MockDevicesSettings::Ptr settings_;
+  VolumeLauncherIcon::Ptr icon_;
+};
+
+TEST_F(TestVolumeLauncherIcon, TestIconType)
+{
+  CreateIcon();
+  EXPECT_EQ(icon_->GetIconType(), AbstractLauncherIcon::IconType::DEVICE);
+}
+
+TEST_F(TestVolumeLauncherIcon, TestQuirks)
+{
+  CreateIcon();
+
+  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestTooltipText)
+{
+  CreateIcon();
+
+  ASSERT_EQ(icon_->tooltip_text, "Test Name");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestIconName)
+{
+  CreateIcon();
+
+  ASSERT_EQ(icon_->icon_name, "Test Icon Name");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestVisibility_InitiallyMountedVolume)
+{
+  CreateIcon();
+
+  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestVisibility_InitiallyMountedBlacklistedVolume)
+{
+  EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  ASSERT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+
+TEST_F(TestVolumeLauncherIcon, TestVisibility_InitiallyUnmountedVolume)
+{
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(false));
+
+  CreateIcon();
+
+  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+
+TEST_F(TestVolumeLauncherIcon, TestVisibility_InitiallyUnmountedBlacklistedVolume)
+{
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(false));
+
+  EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestSettingsChangedSignal)
+{
+  CreateIcon();
+
+  EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+    .WillRepeatedly(Return(true));
+  settings_->changed.emit();
+
+  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestVisibilityAfterUnmount)
+{
+  CreateIcon();
+
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(false));
+
+  EXPECT_CALL(*settings_, TryToBlacklist(_))
+    .Times(0);
+
+  volume_->changed.emit();
+  Utils::WaitForTimeout(1);
+
+  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestVisibilityAfterUnmount_BlacklistedVolume)
+{
+  EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(false));
+
+  EXPECT_CALL(*settings_, TryToUnblacklist(_))
+    .Times(0);
+
+  volume_->changed.emit();
+  Utils::WaitForTimeout(1);
+
+  EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestUnlockFromLauncherMenuItem_VolumeWithoutIdentifier)
+{
+  EXPECT_CALL(*volume_, GetIdentifier())
+    .WillRepeatedly(Return(""));
+
+  CreateIcon();
+
+  for (auto menuitem : icon_->GetMenus())
+    ASSERT_STRNE(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unlock from Launcher");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestUnlockFromLauncherMenuItem_Success)
+{
+  CreateIcon();
+
+  auto menuitem = GetMenuItemAtIndex(0);
+
+  ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unlock from Launcher");
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
+
+  EXPECT_CALL(*settings_, TryToBlacklist(_))
+    .Times(1);
+
+  EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+    .WillRepeatedly(Return(true));
+
+  dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, 0);
+  settings_->changed.emit(); // TryToBlacklist() works if DevicesSettings emits a changed signal.
+  Utils::WaitForTimeout(1);
+
+  ASSERT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestUnlockFromLauncherMenuItem_Failure)
+{
+  CreateIcon();
+
+  auto menuitem = GetMenuItemAtIndex(0);
+
+  ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unlock from Launcher");
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
+
+  EXPECT_CALL(*settings_, TryToBlacklist(_))
+    .Times(1);
+
+  dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, 0);
+  Utils::WaitForTimeout(1);
+
+  ASSERT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::VISIBLE));
+}
+
+TEST_F(TestVolumeLauncherIcon, TestOpenMenuItem)
+{
+  CreateIcon();
+
+  auto menuitem = GetMenuItemAtIndex(1);
+
+  ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Open");
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
+
+  EXPECT_CALL(*volume_, MountAndOpenInFileManager())
+    .Times(1);
+
+  dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, 0);
+  Utils::WaitForTimeout(1);
+}
+
+TEST_F(TestVolumeLauncherIcon, TestEjectMenuItem_NotEjectableVolume)
+{
+  CreateIcon();
+
+  for (auto menuitem : icon_->GetMenus())
+    ASSERT_STRNE(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Eject");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestEjectMenuItem)
+{
+  EXPECT_CALL(*volume_, CanBeEjected())
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  auto menuitem = GetMenuItemAtIndex(2);
+
+  EXPECT_CALL(*volume_, EjectAndShowNotification())
+    .Times(1);
+
+  ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Eject");
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
+
+  dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, 0);
+  Utils::WaitForTimeout(1);
+}
+
+TEST_F(TestVolumeLauncherIcon, TestEjectMenuItem_NotStoppableVolume)
+{
+  CreateIcon();
+
+  for (auto menuitem : icon_->GetMenus())
+    ASSERT_STRNE(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Safely remove");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestSafelyRemoveMenuItem)
+{
+  EXPECT_CALL(*volume_, CanBeStopped())
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  auto menuitem = GetMenuItemAtIndex(2);
+
+  EXPECT_CALL(*volume_, StopDrive())
+    .Times(1);
+
+  ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Safely remove");
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
+
+  dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, 0);
+  Utils::WaitForTimeout(1);
+}
+
+TEST_F(TestVolumeLauncherIcon, TestUnmountMenuItem_UnmountedVolume)
+{
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(false));
+
+  CreateIcon();
+
+  for (auto menuitem : icon_->GetMenus())
+    ASSERT_STRNE(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unmount");
+}
+
+
+TEST_F(TestVolumeLauncherIcon, TestUnmountMenuItem_EjectableVolume)
+{
+  EXPECT_CALL(*volume_, CanBeEjected())
+    .WillRepeatedly(Return(true));
+
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  for (auto menuitem : icon_->GetMenus())
+    ASSERT_STRNE(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unmount");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestUnmountMenuItem_StoppableVolume)
+{
+  EXPECT_CALL(*volume_, CanBeStopped())
+    .WillRepeatedly(Return(true));
+
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  for (auto menuitem : icon_->GetMenus())
+    ASSERT_STRNE(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unmount");
+}
+
+TEST_F(TestVolumeLauncherIcon, TestUnmountMenuItem)
+{
+  EXPECT_CALL(*volume_, IsMounted())
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  auto menuitem = GetMenuItemAtIndex(2);
+
+  EXPECT_CALL(*volume_, Unmount())
+    .Times(1);
+
+  ASSERT_STREQ(dbusmenu_menuitem_property_get(menuitem, DBUSMENU_MENUITEM_PROP_LABEL), "Unmount");
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_VISIBLE));
+  EXPECT_TRUE(dbusmenu_menuitem_property_get_bool(menuitem, DBUSMENU_MENUITEM_PROP_ENABLED));
+
+  dbusmenu_menuitem_handle_event(menuitem, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, 0);
+  Utils::WaitForTimeout(1);
+}
+
+TEST_F(TestVolumeLauncherIcon, TestCanBeEject)
+{
+  CreateIcon();
+
+  EXPECT_CALL(*volume_, CanBeEjected())
+    .WillRepeatedly(Return(true));
+  ASSERT_TRUE(icon_->CanEject());
+
+  EXPECT_CALL(*volume_, CanBeEjected())
+    .WillRepeatedly(Return(false));
+  ASSERT_FALSE(icon_->CanEject());
+
+}
+
+TEST_F(TestVolumeLauncherIcon, TestEject)
+{
+  EXPECT_CALL(*volume_, CanBeEjected())
+    .WillRepeatedly(Return(true));
+
+  CreateIcon();
+
+  EXPECT_CALL(*volume_, EjectAndShowNotification())
+    .Times(1);
+
+  icon_->EjectAndShowNotification();
+}
+
+TEST_F(TestVolumeLauncherIcon, OnRemoved)
+{
+  CreateIcon();
+
+  EXPECT_CALL(*settings_, TryToBlacklist(_))
+    .Times(0);
+  EXPECT_CALL(*settings_, TryToUnblacklist(_))
+    .Times(0);
+
+  volume_->removed.emit();
+}
+
+TEST_F(TestVolumeLauncherIcon, OnRemoved_RemovabledVolume)
+{
+  EXPECT_CALL(*volume_, CanBeRemoved())
+    .WillRepeatedly(Return(true));
+  CreateIcon();
+
+  EXPECT_CALL(*settings_, TryToBlacklist(_))
+    .Times(0);
+  EXPECT_CALL(*settings_, TryToUnblacklist(_))
+    .Times(0);
+
+  volume_->removed.emit();
+}
+
+TEST_F(TestVolumeLauncherIcon, OnRemoved_RemovableAndBlacklistedVolume)
+{
+  EXPECT_CALL(*volume_, CanBeRemoved())
+    .WillRepeatedly(Return(true));
+  EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
+    .WillRepeatedly(Return(true));
+  CreateIcon();
+
+  EXPECT_CALL(*settings_, TryToBlacklist(_))
+    .Times(0);
+  EXPECT_CALL(*settings_, TryToUnblacklist(_))
+    .Times(1);
+
+  volume_->removed.emit();
+}
+
+}