[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 "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 118 matching lines @@
   virtual void OnFilePathChanged(const FilePath& path, bool error) OVERRIDE {
     RemovableDeviceNotificationsLinux::OnFilePathChanged(path, error);
     message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   MessageLoop* message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(RemovableDeviceNotificationsLinuxTestWrapper);
 };
 
+class MockStorageObserver
+    : public RemovableStorageNotifications::RemovableStorageObserver {
+ public:
+  MockStorageObserver() {}
+  ~MockStorageObserver() {}
+
+  MOCK_METHOD3(OnRemovableStorageAttached,
+               void(const std::string& id,
+                    const string16& name,
+                    const FilePath::StringType& location));
+  MOCK_METHOD1(OnRemovableStorageDetached, void(const std::string& id));
+};
+
 class RemovableDeviceNotificationLinuxTest : public testing::Test {
  public:
   struct MtabTestData {
     MtabTestData(const std::string& mount_device,
                  const std::string& mount_point,
                  const std::string& mount_type)
         : mount_device(mount_device),
           mount_point(mount_point),
           mount_type(mount_type) {
     }
 
     const std::string mount_device;
     const std::string mount_point;
     const std::string mount_type;
   };
 
   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();
+

[vandebo (ex-Chrome), 2013/01/04 21:06:03]

Why move this below the implementation set up?  The observer won't get
notifications about the already connected devices here.

[Greg Billock, 2013/01/07 21:55:18]

I don't recall doing this deliberately. Perhaps a merge-introduced problem?

+    mock_storage_observer_.reset(new MockStorageObserver);
+    notifications_->AddRemovableStorageObserver(
+        mock_storage_observer_.get());
   }
 
   virtual void TearDown() OVERRIDE {
     message_loop_.RunUntilIdle();
+    notifications_->RemoveRemovableStorageObserver(
+        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_;
+  MockStorageObserver& 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<MockStorageObserver> 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);
 };
@@ skipping 72 matching lines @@
   WriteEmptyMtabAndRunLoop();
 }
 
 // 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));
 
@@ skipping 15 matching lines @@
   WriteEmptyMtabAndRunLoop();
 }
 
 // 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));
 
@@ skipping 46 matching lines @@
   WriteEmptyMtabAndRunLoop();
 }
 
 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));
 
   // Attach |kDeviceDCIM1| to |kMountPointB|.
   // kDeviceDCIM1 -> kMountPointA *
@@ skipping 66 matching lines @@
 }
 
 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));
 
-  base::SystemMonitor::RemovableStorageInfo device_info;
+  RemovableStorageNotifications::RemovableStorageInfo 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 54 matching lines @@
             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