[Media Galleries] Lazily initialize the storage monitor.

chrome/browser/media_galleries/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"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #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_galleries/media_file_system_context.h"
 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 #include "chrome/browser/media_galleries/media_galleries_preferences_factory.h"
 #include "chrome/browser/media_galleries/media_galleries_test_util.h"
@@ skipping 258 matching lines @@
 
 class MediaFileSystemRegistryTest : public ChromeRenderViewHostTestHarness {
  public:
   MediaFileSystemRegistryTest();
   virtual ~MediaFileSystemRegistryTest() {}
 
   void CreateProfileState(size_t profile_count);
 
   ProfileState* GetProfileState(size_t i);
 
+  MediaGalleriesPreferences* GetPreferences(Profile* profile);
+
   base::FilePath empty_dir() {
     return empty_dir_;
   }
 
   base::FilePath dcim_dir() {
     return dcim_dir_;
   }
 
   TestMediaFileSystemContext* test_file_system_context() {
     return test_file_system_context_;
@@ skipping 71 matching lines @@
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 
 // TODO(gbillock): Eliminate windows-specific code from this test.
 #if defined(OS_WIN)
   scoped_ptr<test::TestStorageMonitorWin> monitor_;
 #else
-  chrome::test::TestStorageMonitor monitor_;
+  scoped_ptr<chrome::test::TestStorageMonitor> monitor_;
 #endif
 
   MockProfileSharedRenderProcessHostFactory rph_factory_;
 
   ScopedVector<ProfileState> profile_states_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaFileSystemRegistryTest);
 };
 
 namespace {
@@ skipping 190 matching lines @@
   for (size_t i = 0; i < profile_count; ++i) {
     ProfileState* state = new ProfileState(&rph_factory_);
     profile_states_.push_back(state);
   }
 }
 
 ProfileState* MediaFileSystemRegistryTest::GetProfileState(size_t i) {
   return profile_states_[i];
 }
 
+void GetPreferencesForwarder(base::WaitableEvent* event,

[vandebo (ex-Chrome), 2013/05/16 18:56:27]

As far as I can tell, you don't need a waitable event in any of the cases you
have it in this file (Wait() is never used).

[Greg Billock, 2013/05/16 23:27:55]

I was thinking I'd have to run this in another thread, but this test actually
just uses the one message loop. I could take it out -- it's just getting used as
a bit storage currently.

[vandebo (ex-Chrome), 2013/05/17 22:19:58]

Yes, please remove the waitable events, it makes things more complicated to
understand.

[Greg Billock, 2013/05/18 00:02:26]

Done.

+                             MediaGalleriesPreferences** prefs_ptr,
+                             MediaGalleriesPreferences* prefs) {
+  *prefs_ptr = prefs;
+  event->Signal();
+}
+
+MediaGalleriesPreferences* MediaFileSystemRegistryTest::GetPreferences(
+    Profile* profile) {
+  base::WaitableEvent pref_event(false, false);
+  MediaGalleriesPreferences* prefs;
+  GetMediaFileSystemRegistry()->GetPreferencesAsync(
+      profile, base::Bind(&GetPreferencesForwarder, &pref_event, &prefs));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(pref_event.IsSignaled());
+  return prefs;
+}
+
 std::string MediaFileSystemRegistryTest::AddUserGallery(
     MediaStorageUtil::Type type,
     const std::string& unique_id,
     const base::FilePath& path) {
   std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
   string16 name = path.LossyDisplayName();
   DCHECK(!MediaStorageUtil::IsMediaDevice(device_id));
 
   for (size_t i = 0; i < profile_states_.size(); ++i) {
     profile_states_[i]->GetMediaGalleriesPrefs()->AddGalleryWithName(
@@ skipping 107 matching lines @@
       MediaFileSystemInfo info(path.LossyDisplayName(), path, std::string(),
                                0, std::string(), false, false);
       result.push_back(info);
     }
   }
   std::sort(result.begin(), result.end(), MediaFileSystemInfoComparator);
   return result;
 }
 
 void MediaFileSystemRegistryTest::SetUp() {
-#if defined(OS_WIN)
+#if !defined(OS_WIN)
+  monitor_.reset(new test::TestStorageMonitor());
+  base::WaitableEvent wait_for_init(false, false);
+  monitor_->Initialize(base::Bind(&base::WaitableEvent::Signal,
+                                  base::Unretained(&wait_for_init)));
+  monitor_->MarkInitialized();
+  base::RunLoop().RunUntilIdle();
+  DCHECK(wait_for_init.IsSignaled());
+#else
   test::TestPortableDeviceWatcherWin* portable_device_watcher =
       new test::TestPortableDeviceWatcherWin;
   test::TestVolumeMountWatcherWin* mount_watcher =
       new test::TestVolumeMountWatcherWin;
   portable_device_watcher->set_use_dummy_mtp_storage_info(true);
   monitor_.reset(new test::TestStorageMonitorWin(
       mount_watcher, portable_device_watcher));
-  monitor_->Init();
+  base::WaitableEvent wait_for_init(false, false);
+  wait_for_init.Reset();
+  monitor_->Initialize(base::Bind(&base::WaitableEvent::Signal,
+                                 base::Unretained(&wait_for_init)));
   // TODO(gbillock): Replace this with the correct event notification
   // on the storage monitor finishing the startup scan when that exists.
   base::RunLoop().RunUntilIdle();
   mount_watcher->FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
   mount_watcher->FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
+  DCHECK(wait_for_init.IsSignaled());
 #endif
 
   ChromeRenderViewHostTestHarness::SetUp();
   DeleteContents();
   SetRenderProcessHostFactory(&rph_factory_);
 
   test_file_system_context_ = new TestMediaFileSystemContext(
       g_browser_process->media_file_system_registry());
 
   ASSERT_TRUE(galleries_dir_.CreateUniqueTempDir());
@@ skipping 94 matching lines @@
 
   // Attach a device.
   const std::string device_id = AttachDevice(
       MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM,
       "removable_dcim_fake_id",
       dcim_dir());
   EXPECT_EQ(gallery_count + 1, GetAutoAddedGalleries(profile_state).size());
 
   // Forget the device.
   bool forget_gallery = false;
-  MediaGalleriesPreferences* prefs =
-      GetMediaFileSystemRegistry()->GetPreferences(profile_state->profile());
+  MediaGalleriesPreferences* prefs = GetPreferences(profile_state->profile());
   const MediaGalleriesPrefInfoMap& galleries = prefs->known_galleries();
   for (MediaGalleriesPrefInfoMap::const_iterator it = galleries.begin();
        it != galleries.end(); ++it) {
     if (it->second.device_id == device_id) {
       prefs->ForgetGalleryById(it->first);
       forget_gallery = true;
       break;
     }
   }
   MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(forget_gallery);
   EXPECT_EQ(gallery_count, GetAutoAddedGalleries(profile_state).size());
 
   // Call GetPreferences() and the gallery count should not change.
-  GetMediaFileSystemRegistry()->GetPreferences(profile_state->profile());
+  prefs = GetPreferences(profile_state->profile());
   EXPECT_EQ(gallery_count, GetAutoAddedGalleries(profile_state).size());
 }
 
 TEST_F(MediaFileSystemRegistryTest, GalleryNameDefault) {
   FSInfoMap galleries_info;
   InitForGalleriesInfoTest(&galleries_info);
 
   for (FSInfoMap::const_iterator it = galleries_info.begin();
        it != galleries_info.end();
        ++it) {
     CheckGalleryInfo(it->second, test_file_system_context(), &it->second.name,
                      it->second.path, false, false);
   }
 }
 
 // TODO(gbillock): Put the platform-specific parts of this test in tests
 // for those classes, not here. This test, internally, ends up creating an
-// MTP delegate.
+// MTP delegate. (Probably ./win/mtp_device_delegate_impl_win_unittest)
 #if defined(SUPPORT_MTP_DEVICE_FILESYSTEM)
 #if !defined(OS_MACOSX)
 TEST_F(MediaFileSystemRegistryTest, GalleryNameMTP) {
   FSInfoMap galleries_info;
   InitForGalleriesInfoTest(&galleries_info);
 
 #if defined(OS_WIN)
   base::FilePath location(
       PortableDeviceWatcherWin::GetStoragePathFromStorageId(
           test::TestPortableDeviceWatcherWin::kStorageUniqueIdA));
@@ skipping 74 matching lines @@
   pref_info_with_relpath.device_id = device_id;
   EXPECT_EQ(dcim_dir().Append(pref_info_with_relpath.path).value(),
             pref_info_with_relpath.AbsolutePath().value());
 
   DetachDevice(device_id);
   EXPECT_TRUE(pref_info.AbsolutePath().empty());
   EXPECT_TRUE(pref_info_with_relpath.AbsolutePath().empty());
 }
 
 }  // namespace chrome