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

chrome/browser/media_gallery/media_file_system_registry_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.
 
 // MediaFileSystemRegistry unit tests.
 
 #include <algorithm>
 #include <set>
 
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/media_gallery/media_file_system_context.h"
 #include "chrome/browser/media_gallery/media_file_system_registry.h"
 #include "chrome/browser/media_gallery/media_galleries_preferences_factory.h"
 #include "chrome/browser/media_gallery/media_galleries_test_util.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/test_removable_storage_notifications.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/render_process_host_factory.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 251 matching lines @@
   scoped_ptr<content::WebContents> shared_web_contents2_;
 
   // The RenderProcessHosts are freed when their respective WebContents /
   // RenderViewHosts go away.
   content::MockRenderProcessHost* single_rph_;
   content::MockRenderProcessHost* shared_rph_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileState);
 };
 
+}  // namespace
+
 class MediaFileSystemRegistryTest : public ChromeRenderViewHostTestHarness {
  public:
   MediaFileSystemRegistryTest();
   virtual ~MediaFileSystemRegistryTest() {}
 
   void CreateProfileState(size_t profile_count);
 
   ProfileState* GetProfileState(size_t i);
 
   FilePath empty_dir() {
@@ skipping 28 matching lines @@
 
   void CheckNewGalleryInfo(ProfileState* profile_state,
                            const FSInfoMap& galleries_info,
                            const FilePath& location,
                            bool removable,
                            bool media_device);
 
   std::vector<MediaFileSystemInfo> GetAutoAddedGalleries(
       ProfileState* profile_state);
 
+  void ProcessAttach(const std::string& id,
+                     const string16& name,
+                     const FilePath::StringType& location) {
+    chrome::RemovableStorageNotifications::GetInstance()->ProcessAttach(

[Lei Zhang, 2013/01/26 01:27:49]

nit: no need for chrome:: Since we're already inside namespace chrome. Ditto
below.

[Greg Billock, 2013/01/26 01:42:07]

Done.

+        id, name, location);
+  }
+
+  void ProcessDetach(const std::string& id) {
+    chrome::RemovableStorageNotifications::GetInstance()->ProcessDetach(id);
+  }
+
  protected:
   void SetUp();
   void TearDown();
 
  private:
   // This makes sure that at least one default gallery exists on the file
   // system.
   EnsureMediaDirectoriesExists media_directories_;
 
   // Some test gallery directories.
   base::ScopedTempDir galleries_dir_;
   // An empty directory in |galleries_dir_|
   FilePath empty_dir_;
   // A directory in |galleries_dir_| with a DCIM directory in it.
   FilePath dcim_dir_;
 
   // MediaFileSystemRegistry owns this.
   TestMediaFileSystemContext* test_file_system_context_;
 
   // Needed for extension service & friends to work.
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
-  // For AttachDevice() and DetachDevice().
-  scoped_ptr<base::SystemMonitor> system_monitor_;
-
   MockProfileSharedRenderProcessHostFactory rph_factory_;
 
   ScopedVector<ProfileState> profile_states_;
 
+  chrome::test::TestRemovableStorageNotifications notifications_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaFileSystemRegistryTest);
 };
 
+namespace {
+
 bool MediaFileSystemInfoComparator(const MediaFileSystemInfo& a,
                                    const MediaFileSystemInfo& b) {
   CHECK_NE(a.name, b.name); // Name must be unique.
   return a.name < b.name;
 }
 
 //////////////////////////
 // TestMediaStorageUtil //
 //////////////////////////
 
@@ skipping 176 matching lines @@
       EXPECT_EQ(expected[i].fsid, actual[i].fsid) << test;
   }
 }
 
 int ProfileState::GetAndClearComparisonCount() {
   int result = num_comparisons_;
   num_comparisons_ = 0;
   return result;
 }
 
+}  // namespace
+
 /////////////////////////////////
 // MediaFileSystemRegistryTest //
 /////////////////////////////////
 
 MediaFileSystemRegistryTest::MediaFileSystemRegistryTest()
     : ui_thread_(content::BrowserThread::UI, MessageLoop::current()),
       file_thread_(content::BrowserThread::FILE, MessageLoop::current()) {
 }
 
 void MediaFileSystemRegistryTest::CreateProfileState(size_t profile_count) {
@@ skipping 22 matching lines @@
   return device_id;
 }
 
 std::string MediaFileSystemRegistryTest::AttachDevice(
     MediaStorageUtil::Type type,
     const std::string& unique_id,
     const FilePath& location) {
   std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
   DCHECK(MediaStorageUtil::IsRemovableDevice(device_id));
   string16 name = location.LossyDisplayName();
-  base::SystemMonitor::Get()->ProcessRemovableStorageAttached(device_id, name,
-                                                              location.value());
+  ProcessAttach(device_id, name, location.value());
   bool user_added = (type == MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM);
   for (size_t i = 0; i < profile_states_.size(); ++i) {
     profile_states_[i]->GetMediaGalleriesPrefs()->AddGallery(
         device_id, name, FilePath(), user_added);
   }
   MessageLoop::current()->RunUntilIdle();
   return device_id;
 }
 
 void MediaFileSystemRegistryTest::DetachDevice(const std::string& device_id) {
   DCHECK(MediaStorageUtil::IsRemovableDevice(device_id));
-  base::SystemMonitor::Get()->ProcessRemovableStorageDetached(device_id);
+  ProcessDetach(device_id);
   MessageLoop::current()->RunUntilIdle();
 }
 
 void MediaFileSystemRegistryTest::SetGalleryPermission(
     ProfileState* profile_state, extensions::Extension* extension,
     const std::string& device_id, bool has_access) {
   MediaGalleriesPreferences* preferences =
       profile_state->GetMediaGalleriesPrefs();
   MediaGalleryPrefIdSet pref_id =
       preferences->LookUpGalleriesByDeviceId(device_id);
@@ skipping 78 matching lines @@
       MediaFileSystemInfo info(path.AsUTF8Unsafe(), path, std::string(),
                                0, 0, false, false);
       result.push_back(info);
     }
   }
   std::sort(result.begin(), result.end(), MediaFileSystemInfoComparator);
   return result;
 }
 
 void MediaFileSystemRegistryTest::SetUp() {
-#if defined(OS_MACOSX)
-  // This needs to happen before SystemMonitor's ctor.
-  base::SystemMonitor::AllocateSystemIOPorts();
-#endif
-  system_monitor_.reset(new base::SystemMonitor);
-
   ChromeRenderViewHostTestHarness::SetUp();
   DeleteContents();
   SetRenderProcessHostFactory(&rph_factory_);
 
   TestMediaStorageUtil::SetTestingMode();
   test_file_system_context_ = new TestMediaFileSystemContext(
       g_browser_process->media_file_system_registry());
 
   ASSERT_TRUE(galleries_dir_.CreateUniqueTempDir());
   empty_dir_ = galleries_dir_.path().AppendASCII("empty");
@@ skipping 136 matching lines @@
   // Add permission for new non-default gallery.
   ProfileState* profile_state = GetProfileState(0U);
   SetGalleryPermission(profile_state,
                        profile_state->all_permission_extension(),
                        device_id,
                        true /*has access*/);
   CheckNewGalleryInfo(profile_state, galleries_info, empty_dir(),
                       false /*removable*/, false /* media device */);
 }
 
-}  // namespace
-
 }  // namespace chrome