Add TestBrowserThreadBundle into RenderViewHostTestHarness. Kill some unnecessary real threads.

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"
@@ skipping 266 matching lines @@
   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);
 
   base::FilePath empty_dir() {
     return empty_dir_;
   }
 
   base::FilePath dcim_dir() {
     return dcim_dir_;
@@ skipping 62 matching lines @@
   base::ScopedTempDir galleries_dir_;
   // An empty directory in |galleries_dir_|
   base::FilePath empty_dir_;
   // A directory in |galleries_dir_| with a DCIM directory in it.
   base::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_;
 
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
-  chromeos::ScopedTestUserManager test_user_manager_;
+  scoped_ptr<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_;
 #endif
 
   MockProfileSharedRenderProcessHostFactory rph_factory_;
 
   ScopedVector<ProfileState> profile_states_;
-
-  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;
 }
 
@@ skipping 167 matching lines @@
   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) {
   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];
 }
@@ skipping 118 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() {
+  ChromeRenderViewHostTestHarness::SetUp();
 #if defined(OS_WIN)
   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();
-  // 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 runloop;
+  monitor_->Initialize(runloop.QuitClosure());
+  runloop.Run();
   base::RunLoop().RunUntilIdle();
 #endif
 
-  ChromeRenderViewHostTestHarness::SetUp();
   DeleteContents();
   SetRenderProcessHostFactory(&rph_factory_);
 
   test_file_system_context_ = new TestMediaFileSystemContext(
       g_browser_process->media_file_system_registry());
 
+#if defined OS_CHROMEOS
+  test_user_manager_.reset(new chromeos::ScopedTestUserManager());
+#endif
+
   ASSERT_TRUE(galleries_dir_.CreateUniqueTempDir());
   empty_dir_ = galleries_dir_.path().AppendASCII("empty");
   ASSERT_TRUE(file_util::CreateDirectory(empty_dir_));
   dcim_dir_ = galleries_dir_.path().AppendASCII("with_dcim");
   ASSERT_TRUE(file_util::CreateDirectory(dcim_dir_));
   ASSERT_TRUE(file_util::CreateDirectory(dcim_dir_.Append(kDCIMDirectoryName)));
 }
 
 void MediaFileSystemRegistryTest::TearDown() {
   profile_states_.clear();
-  ChromeRenderViewHostTestHarness::TearDown();
   MediaFileSystemRegistry* registry =
       g_browser_process->media_file_system_registry();
   EXPECT_EQ(0U, registry->GetExtensionGalleriesHostCountForTests());
-  BrowserThread::GetBlockingPool()->FlushForTesting();
-  MessageLoop::current()->RunUntilIdle();
+#if defined OS_CHROMEOS
+  test_user_manager_.reset();
+#endif
+
+#if defined(OS_WIN)
+  monitor_.reset();
+#endif
+  ChromeRenderViewHostTestHarness::TearDown();
 }
 
 ///////////
 // Tests //
 ///////////
 
 TEST_F(MediaFileSystemRegistryTest, Basic) {
   CreateProfileState(1);
   AssertAllAutoAddedGalleries();
 
@@ skipping 196 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