Get rid of MessageLoop* caching in extensions code.

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-2009 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.
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 176 matching lines @@
 
   scoped_ptr<ExternalPrefExtensionProvider> provider_;
   scoped_ptr<DictionaryValue> prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
 class ExtensionsServiceTest
   : public testing::Test, public NotificationObserver {
  public:
-  ExtensionsServiceTest() : installed_(NULL) {
+  ExtensionsServiceTest()
+      : ui_thread_(ChromeThread::UI, &loop_),
+        file_thread_(ChromeThread::FILE, &loop_),
+        installed_(NULL) {
     registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_INSTALLED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::THEME_INSTALLED,
                    NotificationService::AllSources());
   }
 
   virtual void InitializeExtensionsService(const FilePath& pref_file,
       const FilePath& extensions_install_dir) {
     prefs_.reset(new PrefService(pref_file, NULL));
     profile_.reset(new TestingProfile());
     service_ = new ExtensionsService(profile_.get(),
                                      CommandLine::ForCurrentProcess(),
                                      prefs_.get(),
                                      extensions_install_dir,
-                                     &loop_,
-                                     &loop_,
                                      false);
     service_->set_extensions_enabled(true);
     service_->set_show_extensions_prompts(false);
 
     // When we start up, we want to make sure there is no external provider,
     // since the ExtensionService on Windows will use the Registry as a default
     // provider and if there is something already registered there then it will
     // interfere with the tests. Those tests that need an external provider
     // will register one specifically.
     service_->ClearProvidersForTesting();
@@ skipping 233 matching lines @@
   }
 
  protected:
   ScopedTempDir temp_dir_;
   scoped_ptr<PrefService> prefs_;
   scoped_ptr<Profile> profile_;
   FilePath extensions_install_dir_;
   scoped_refptr<ExtensionsService> service_;
   size_t total_successes_;
   MessageLoop loop_;
+  ChromeThread ui_thread_;
+  ChromeThread file_thread_;
   ExtensionList loaded_;
   std::string unloaded_id_;
   Extension* installed_;
 
  private:
   NotificationRegistrar registrar_;
 };
 
 FilePath::StringType NormalizeSeperators(FilePath::StringType path) {
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
@@ skipping 1039 matching lines @@
 // Test that we get enabled/disabled correctly for all the pref/command-line
 // combinations. We don't want to derive from the ExtensionsServiceTest class
 // for this test, so we use ExtensionsServiceTestSimple.
 //
 // Also tests that we always fire EXTENSIONS_READY, no matter whether we are
 // enabled or not.
 TEST(ExtensionsServiceTestSimple, Enabledness) {
   ExtensionsReadyRecorder recorder;
   TestingProfile profile;
   MessageLoop loop;
+  ChromeThread ui_thread(ChromeThread::UI, &loop);
+  ChromeThread file_thread(ChromeThread::FILE, &loop);
   scoped_ptr<CommandLine> command_line;
   scoped_refptr<ExtensionsService> service;
   FilePath install_dir = profile.GetPath()
       .AppendASCII(ExtensionsService::kInstallDirectoryName);
 
   // By default, we are enabled.
   command_line.reset(new CommandLine(CommandLine::ARGUMENTS_ONLY));
   service = new ExtensionsService(&profile, command_line.get(),
-      profile.GetPrefs(), install_dir, &loop, &loop, false);
+      profile.GetPrefs(), install_dir, false);
   EXPECT_TRUE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // If either the command line or pref is set, we are disabled.
   recorder.set_ready(false);
   command_line->AppendSwitch(switches::kDisableExtensions);
   service = new ExtensionsService(&profile, command_line.get(),
-      profile.GetPrefs(), install_dir, &loop, &loop, false);
+      profile.GetPrefs(), install_dir, false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
   service = new ExtensionsService(&profile, command_line.get(),
-      profile.GetPrefs(), install_dir, &loop, &loop, false);
+      profile.GetPrefs(), install_dir, false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   command_line.reset(new CommandLine(CommandLine::ARGUMENTS_ONLY));
   service = new ExtensionsService(&profile, command_line.get(),
-      profile.GetPrefs(), install_dir, &loop, &loop, false);
+      profile.GetPrefs(), install_dir, false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 }