[Media Galleries] Move RemovableStorageInfo notifications to chrome namespace (part 2)

chrome/browser/system_monitor/removable_device_notifications_linux_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // RemovableDeviceNotificationsLinux unit tests.
 
 #include "chrome/browser/system_monitor/removable_device_notifications_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
-#include "base/system_monitor/system_monitor.h"
-#include "base/test/mock_devices_changed_observer.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/system_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
 #include "chrome/browser/system_monitor/removable_device_constants.h"
+#include "chrome/browser/system_monitor/removable_storage_notifications.h"
+#include "chrome/browser/system_monitor/removable_storage_notifications_test_util.h"
 #include "content/public/test/test_browser_thread.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome {
 
 namespace {
 
 using testing::_;
 
 const char kValidFS[] = "vfat";
 const char kInvalidFS[] = "invalidfs";
@@ skipping 142 matching lines @@
   };
 
   RemovableDeviceNotificationLinuxTest()
       : message_loop_(MessageLoop::TYPE_IO),
         file_thread_(content::BrowserThread::FILE, &message_loop_) {
   }
   virtual ~RemovableDeviceNotificationLinuxTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
-    mock_devices_changed_observer_.reset(new base::MockDevicesChangedObserver);
-    system_monitor_.AddDevicesChangedObserver(
-        mock_devices_changed_observer_.get());
-
     // Create and set up a temp dir with files for the test.
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     FilePath test_dir = scoped_temp_dir_.path().AppendASCII("test_etc");
     ASSERT_TRUE(file_util::CreateDirectory(test_dir));
     mtab_file_ = test_dir.AppendASCII("test_mtab");
     MtabTestData initial_test_data[] = {
       MtabTestData("dummydevice", "dummydir", kInvalidFS),
     };
     WriteToMtab(initial_test_data,
                 arraysize(initial_test_data),
                 true  /* overwrite */);
 
     // Initialize the test subject.
     notifications_ = new RemovableDeviceNotificationsLinuxTestWrapper(
         mtab_file_, &message_loop_);
     notifications_->Init();
     message_loop_.RunUntilIdle();
+
+    mock_storage_observer_.reset(new MockRemovableStorageObserver);

[vandebo (ex-Chrome), 2013/01/11 22:06:50]

Move to start of method

[Greg Billock, 2013/01/17 22:10:45]

We can't add the observer until the notifications class is made, before which we
need to write the mtab. I think this is in the right place.

+    notifications_->AddObserver(mock_storage_observer_.get());
   }
 
   virtual void TearDown() OVERRIDE {
     message_loop_.RunUntilIdle();
+    notifications_->RemoveObserver(mock_storage_observer_.get());
     notifications_ = NULL;
-    system_monitor_.RemoveDevicesChangedObserver(
-        mock_devices_changed_observer_.get());
   }
 
   // Append mtab entries from the |data| array of size |data_size| to the mtab
   // file, and run the message loop.
   void AppendToMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
     WriteToMtab(data, data_size, false  /* do not overwrite */);
     message_loop_.Run();
   }
 
   // Overwrite the mtab file with mtab entries from the |data| array of size
@@ skipping 23 matching lines @@
   FilePath CreateMountPointWithoutDCIMDir(const std::string& dir) {
     return CreateMountPoint(dir, false  /* do not create DCIM dir */);
   }
 
   void RemoveDCIMDirFromMountPoint(const std::string& dir) {
     FilePath dcim =
         scoped_temp_dir_.path().AppendASCII(dir).Append(kDCIMDirectoryName);
     file_util::Delete(dcim, false);
   }
 
-  base::MockDevicesChangedObserver& observer() {
-    return *mock_devices_changed_observer_;
+  MockRemovableStorageObserver& observer() {
+    return *mock_storage_observer_;
   }
 
   RemovableDeviceNotificationsLinux* notifier() {
     return notifications_.get();
   }
 
  private:
   // Create a directory named |dir| relative to the test directory.
   // Set |with_dcim_dir| to true if the created directory will have a "DCIM"
   // subdirectory.
@@ skipping 40 matching lines @@
       entry.mnt_type = const_cast<char*>(data[i].mount_type.c_str());
       ASSERT_EQ(0, addmntent(file, &entry));
     }
     ASSERT_EQ(1, endmntent(file));
   }
 
   // The message loop and file thread to run tests on.
   MessageLoop message_loop_;
   content::TestBrowserThread file_thread_;
 
-  // SystemMonitor and DevicesChangedObserver to hook together to test.
-  base::SystemMonitor system_monitor_;
-  scoped_ptr<base::MockDevicesChangedObserver> mock_devices_changed_observer_;
+  scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
 
   // Temporary directory for created test data.
   base::ScopedTempDir scoped_temp_dir_;
   // Path to the test mtab file.
   FilePath mtab_file_;
 
   scoped_refptr<RemovableDeviceNotificationsLinuxTestWrapper> notifications_;
 
   DISALLOW_COPY_AND_ASSIGN(RemovableDeviceNotificationLinuxTest);
 };
 
 // Simple test case where we attach and detach a media device.
 TEST_F(RemovableDeviceNotificationLinuxTest, BasicAttachDetach) {
   testing::Sequence mock_sequence;
   FilePath test_path = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path.empty());
   MtabTestData test_data[] = {
     MtabTestData(kDeviceDCIM2, test_path.value(), kValidFS),
     MtabTestData(kDeviceFixed, kInvalidPath, kValidFS),
   };
   // Only |kDeviceDCIM2| should be attached, since |kDeviceFixed| has a bad
   // path.
-  EXPECT_CALL(observer(),
-              OnRemovableStorageAttached(
-                  GetDeviceId(kDeviceDCIM2),
-                  GetDeviceNameWithSizeDetails(kDeviceDCIM2),
-                  test_path.value()))
-      .InSequence(mock_sequence);
   AppendToMtabAndRunLoop(test_data, arraysize(test_data));
 
+  EXPECT_EQ(1, observer().attach_calls());
+  EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_attached().device_id);
+  EXPECT_EQ(GetDeviceNameWithSizeDetails(kDeviceDCIM2),
+            observer().last_attached().name);
+  EXPECT_EQ(test_path.value(),
+            observer().last_attached().location);
+
   // |kDeviceDCIM2| should be detached here.
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(GetDeviceId(kDeviceDCIM2)))
-      .InSequence(mock_sequence);
   WriteEmptyMtabAndRunLoop();
+  EXPECT_EQ(1, observer().detach_calls());
+  EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_detached().device_id);
 }
 
 // Only removable devices are recognized.
 TEST_F(RemovableDeviceNotificationLinuxTest, Removable) {
-  testing::Sequence mock_sequence;
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path_a.empty());
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
   };
   // |kDeviceDCIM1| should be attached as expected.
-  EXPECT_CALL(observer(),
-              OnRemovableStorageAttached(
-                  GetDeviceId(kDeviceDCIM1),
-                  GetDeviceNameWithSizeDetails(kDeviceDCIM1),
-                  test_path_a.value()))
-      .InSequence(mock_sequence);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
 
+  EXPECT_EQ(1, observer().attach_calls());
+  EXPECT_EQ(GetDeviceId(kDeviceDCIM1), observer().last_attached().device_id);
+  EXPECT_EQ(GetDeviceNameWithSizeDetails(kDeviceDCIM1),
+            observer().last_attached().name);
+  EXPECT_EQ(test_path_a.value(),
+            observer().last_attached().location);
+
   // This should do nothing, since |kDeviceFixed| is not removable.
   FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_b.empty());
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
+  EXPECT_EQ(1, observer().attach_calls());
 
   // |kDeviceDCIM1| should be detached as expected.
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(GetDeviceId(kDeviceDCIM1)))
-      .InSequence(mock_sequence);
   WriteEmptyMtabAndRunLoop();
+  EXPECT_EQ(1, observer().detach_calls());
+  EXPECT_EQ(GetDeviceId(kDeviceDCIM1), observer().last_detached().device_id);
 
   // |kDeviceNoDCIM| should be attached as expected.
-  EXPECT_CALL(observer(),
-              OnRemovableStorageAttached(
-                  GetDeviceId(kDeviceNoDCIM),
-                  GetDeviceNameWithSizeDetails(kDeviceNoDCIM),
-                  test_path_b.value()))
-      .InSequence(mock_sequence);
   MtabTestData test_data3[] = {
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_attached().device_id);
+  EXPECT_EQ(GetDeviceNameWithSizeDetails(kDeviceNoDCIM),
+            observer().last_attached().name);
+  EXPECT_EQ(test_path_b.value(),
+            observer().last_attached().location);
 
   // |kDeviceNoDCIM| should be detached as expected.
-  EXPECT_CALL(observer(),
-              OnRemovableStorageDetached(GetDeviceId(kDeviceNoDCIM)))
-      .InSequence(mock_sequence);
   WriteEmptyMtabAndRunLoop();
+  EXPECT_EQ(2, observer().detach_calls());
+  EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_detached().device_id);
 }
 
 // More complicated test case with multiple devices on multiple mount points.
 TEST_F(RemovableDeviceNotificationLinuxTest, SwapMountPoints) {
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
-  // Attach two devices.  (*'d mounts are those SystemMonitor knows about.)
+  // Attach two devices.
+  // (*'d mounts are those RemovableStorageNotifications knows about.)
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM2 -> kMountPointB *
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(0, observer().detach_calls());
 
   // Detach two devices from old mount points and attach the devices at new
   // mount points.
   // kDeviceDCIM1 -> kMountPointB *
   // kDeviceDCIM2 -> kMountPointA *
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceDCIM2, test_path_a.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(2);
   OverwriteMtabAndRunLoop(test_data2, arraysize(test_data2));
+  EXPECT_EQ(4, observer().attach_calls());
+  EXPECT_EQ(2, observer().detach_calls());
 
   // Detach all devices.
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(2);
   WriteEmptyMtabAndRunLoop();
+  EXPECT_EQ(4, observer().attach_calls());
+  EXPECT_EQ(4, observer().detach_calls());
 }
 
 // More complicated test case with multiple devices on multiple mount points.
 TEST_F(RemovableDeviceNotificationLinuxTest, MultiDevicesMultiMountPoints) {
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
-  // Attach two devices.  (*'d mounts are those SystemMonitor knows about.)
+  // Attach two devices.
+  // (*'d mounts are those RemovableStorageNotifications knows about.)
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM2 -> kMountPointB *
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(0, observer().detach_calls());
 
   // Attach |kDeviceDCIM1| to |kMountPointB|.
   // |kDeviceDCIM2| is inaccessible, so it is detached. |kDeviceDCIM1| has been
   // attached at |kMountPointB|, but is still accessible from |kMountPointA|.
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM2 -> kMountPointB
   // kDeviceDCIM1 -> kMountPointB
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(1, observer().detach_calls());
 
   // Detach |kDeviceDCIM1| from |kMountPointA|, causing a detach and attach
   // event.
   // kDeviceDCIM2 -> kMountPointB
   // kDeviceDCIM1 -> kMountPointB *
   MtabTestData test_data3[] = {
     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(1);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   OverwriteMtabAndRunLoop(test_data3, arraysize(test_data3));
+  EXPECT_EQ(3, observer().attach_calls());
+  EXPECT_EQ(2, observer().detach_calls());
 
   // Attach |kDeviceDCIM1| to |kMountPointA|.
   // kDeviceDCIM2 -> kMountPointB
   // kDeviceDCIM1 -> kMountPointB *
   // kDeviceDCIM1 -> kMountPointA
   MtabTestData test_data4[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data4, arraysize(test_data4));
+  EXPECT_EQ(3, observer().attach_calls());
+  EXPECT_EQ(2, observer().detach_calls());
 
   // Detach |kDeviceDCIM1| from |kMountPointB|.
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM2 -> kMountPointB *
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(5, observer().attach_calls());
+  EXPECT_EQ(3, observer().detach_calls());
 
   // Detach all devices.
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(2);
   WriteEmptyMtabAndRunLoop();
+  EXPECT_EQ(5, observer().attach_calls());
+  EXPECT_EQ(5, observer().detach_calls());
 }
 
 TEST_F(RemovableDeviceNotificationLinuxTest,
        MultipleMountPointsWithNonDCIMDevices) {
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
-  // Attach to one first. (*'d mounts are those SystemMonitor knows about.)
+  // Attach to one first.
+  // (*'d mounts are those RemovableStorageNotifications knows about.)
   // kDeviceDCIM1 -> kMountPointA *
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(1);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(1, observer().attach_calls());
+  EXPECT_EQ(0, observer().detach_calls());
 
   // Attach |kDeviceDCIM1| to |kMountPointB|.
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM1 -> kMountPointB
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
+  EXPECT_EQ(1, observer().attach_calls());
+  EXPECT_EQ(0, observer().detach_calls());
 
   // Attach |kDeviceFixed| (a non-removable device) to |kMountPointA|.
   // kDeviceDCIM1 -> kMountPointA
   // kDeviceDCIM1 -> kMountPointB *
   // kDeviceFixed -> kMountPointA
   MtabTestData test_data3[] = {
     MtabTestData(kDeviceFixed, test_path_a.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(1);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   RemoveDCIMDirFromMountPoint(kMountPointA);
   AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(1, observer().detach_calls());
 
   // Detach |kDeviceFixed|.
   // kDeviceDCIM1 -> kMountPointA
   // kDeviceDCIM1 -> kMountPointB *
   MtabTestData test_data4[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   CreateMountPointWithDCIMDir(kMountPointA);
   OverwriteMtabAndRunLoop(test_data4, arraysize(test_data4));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(1, observer().detach_calls());
 
   // Attach |kDeviceNoDCIM| (a non-DCIM device) to |kMountPointB|.
   // kDeviceDCIM1  -> kMountPointA *
   // kDeviceDCIM1  -> kMountPointB
   // kDeviceNoDCIM -> kMountPointB *
   MtabTestData test_data5[] = {
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   file_util::Delete(test_path_b.Append(kDCIMDirectoryName), false);
   AppendToMtabAndRunLoop(test_data5, arraysize(test_data5));
+  EXPECT_EQ(4, observer().attach_calls());
+  EXPECT_EQ(2, observer().detach_calls());
 
   // Detach |kDeviceNoDCIM|.
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM1 -> kMountPointB
   MtabTestData test_data6[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   CreateMountPointWithDCIMDir(kMountPointB);
   OverwriteMtabAndRunLoop(test_data6, arraysize(test_data6));
+  EXPECT_EQ(4, observer().attach_calls());
+  EXPECT_EQ(3, observer().detach_calls());
 
   // Detach |kDeviceDCIM1| from |kMountPointB|.
   // kDeviceDCIM1 -> kMountPointA *
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(4, observer().attach_calls());
+  EXPECT_EQ(3, observer().detach_calls());
 
   // Detach all devices.
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   WriteEmptyMtabAndRunLoop();
+  EXPECT_EQ(4, observer().attach_calls());
+  EXPECT_EQ(4, observer().detach_calls());
 }
 
 TEST_F(RemovableDeviceNotificationLinuxTest, DeviceLookUp) {
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   FilePath test_path_c = CreateMountPointWithoutDCIMDir(kMountPointC);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
   ASSERT_FALSE(test_path_c.empty());
 
-  // Attach to one first. (*'d mounts are those SystemMonitor knows about.)
+  // Attach to one first.
+  // (*'d mounts are those RemovableStorageNotifications knows about.)
   // kDeviceDCIM1  -> kMountPointA *
   // kDeviceNoDCIM -> kMountPointB *
   // kDeviceFixed  -> kMountPointC
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(0, observer().detach_calls());
 
-  base::SystemMonitor::RemovableStorageInfo device_info;
+  RemovableStorageNotifications::StorageInfo device_info;
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_a, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id);
   EXPECT_EQ(test_path_a.value(), device_info.location);
   EXPECT_EQ(GetDeviceName(kDeviceDCIM1), device_info.name);
 
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_b, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), device_info.device_id);
   EXPECT_EQ(test_path_b.value(), device_info.location);
   EXPECT_EQ(GetDeviceName(kDeviceNoDCIM), device_info.name);
 
@@ skipping 14 matching lines @@
 
   // One device attached at multiple points.
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceFixed -> kMountPointB
   // kDeviceFixed -> kMountPointC
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(0);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(1);
   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
 
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_a, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id);
 
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_b, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
 
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_c, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
+
+  EXPECT_EQ(0, observer().attach_calls());
+  EXPECT_EQ(1, observer().detach_calls());
 }
 
 TEST_F(RemovableDeviceNotificationLinuxTest, DevicePartitionSize) {
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceFixed, kInvalidPath, kInvalidFS),
   };
-  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
-  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
+  EXPECT_EQ(2, observer().attach_calls());
+  EXPECT_EQ(0, observer().detach_calls());
 
   EXPECT_EQ(GetDevicePartitionSize(kDeviceDCIM1),
             notifier()->GetStorageSize(test_path_a.value()));
   EXPECT_EQ(GetDevicePartitionSize(kDeviceNoDCIM),
             notifier()->GetStorageSize(test_path_b.value()));
   EXPECT_EQ(GetDevicePartitionSize(kInvalidPath),
             notifier()->GetStorageSize(kInvalidPath));
 }
 
 }  // namespace
 
 }  // namespace chrome