Get rid of MessageLoop* caching in extensions code.

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 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 "chrome/browser/extensions/extensions_service.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "base/values.h"
@@ skipping 64 matching lines @@
     return true;
   } else {
     return false;
   }
 }
 
 ExtensionsService::ExtensionsService(Profile* profile,
                                      const CommandLine* command_line,
                                      PrefService* prefs,
                                      const FilePath& install_directory,
-                                     MessageLoop* frontend_loop,
-                                     MessageLoop* backend_loop,
                                      bool autoupdate_enabled)
     : profile_(profile),
       extension_prefs_(new ExtensionPrefs(prefs, install_directory)),
-      backend_loop_(backend_loop),
       install_directory_(install_directory),
       extensions_enabled_(true),
       show_extensions_prompts_(true),
       ready_(false) {
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
   // Set up the ExtensionUpdater
   if (autoupdate_enabled) {
     int update_frequency = kDefaultUpdateFrequencySeconds;
     if (command_line->HasSwitch(switches::kExtensionsUpdateFrequency)) {
       update_frequency = StringToInt(WideToASCII(command_line->GetSwitchValue(
           switches::kExtensionsUpdateFrequency)));
     }
-    updater_ = new ExtensionUpdater(this, prefs, update_frequency,
-        backend_loop_, g_browser_process->io_thread()->message_loop());
+    updater_ = new ExtensionUpdater(this, prefs, update_frequency);
   }
 
-  backend_ = new ExtensionsServiceBackend(install_directory_, frontend_loop);
+  backend_ = new ExtensionsServiceBackend(install_directory_);
 }
 
 ExtensionsService::~ExtensionsService() {
   UnloadAllExtensions();
   if (updater_.get()) {
     updater_->Stop();
   }
 }
 
 void ExtensionsService::Init() {
@@ skipping 12 matching lines @@
 
   // TODO(erikkay) this should probably be deferred as well.
   GarbageCollectExtensions();
 }
 
 void ExtensionsService::InstallExtension(const FilePath& extension_path) {
   CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
                       "",   // no expected id
                       false,  // don't delete crx when complete
                       true,  // allow privilege increase
-                      backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::UpdateExtension(const std::string& id,
                                         const FilePath& extension_path) {
   if (!GetExtensionByIdInternal(id, true, true)) {
     LOG(WARNING) << "Will not update extension " << id << " because it is not "
                  << "installed";
     return;
   }
 
   CrxInstaller::Start(extension_path, install_directory_, Extension::INTERNAL,
                       id,
                       true,  // delete crx when complete
                       false,  // do not allow upgrade of privileges
-                      backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::ReloadExtension(const std::string& extension_id) {
   FilePath path;
   Extension* current_extension = GetExtensionById(extension_id);
 
   // Unload the extension if it's loaded. It might not be loaded if it crashed.
   if (current_extension) {
@@ skipping 15 matching lines @@
                                            bool external_uninstall) {
   Extension* extension = GetExtensionByIdInternal(extension_id, true, true);
 
   // Callers should not send us nonexistant extensions.
   DCHECK(extension);
 
   extension_prefs_->OnExtensionUninstalled(extension, external_uninstall);
 
   // Tell the backend to start deleting installed extensions on the file thread.
   if (Extension::LOAD != extension->location()) {
-    backend_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      &extension_file_util::UninstallExtension, extension_id,
-      install_directory_));
+    ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableFunction(
+          &extension_file_util::UninstallExtension, extension_id,
+          install_directory_));
   }
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   UnloadExtension(extension_id);
 }
 
 void ExtensionsService::EnableExtension(const std::string& extension_id) {
   Extension* extension = GetExtensionByIdInternal(extension_id, false, true);
@@ skipping 37 matching lines @@
                                            extension);
   extensions_.erase(iter);
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionUnloaded(extension);
 }
 
 void ExtensionsService::LoadExtension(const FilePath& extension_path) {
-  backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
-      &ExtensionsServiceBackend::LoadSingleExtension,
-      extension_path, scoped_refptr<ExtensionsService>(this)));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          backend_.get(),
+          &ExtensionsServiceBackend::LoadSingleExtension,
+          extension_path, scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::LoadAllExtensions() {
   // Load the previously installed extensions.
   scoped_ptr<InstalledExtensions> installed(
       new InstalledExtensions(extension_prefs_.get()));
   installed->VisitInstalledExtensions(
       NewCallback(this, &ExtensionsService::LoadInstalledExtension));
   OnLoadedInstalledExtensions();
 }
@@ skipping 18 matching lines @@
                              NotificationType::EXTENSION_INSTALL_ERROR,
                              false);
     return;
   }
 
   extension->set_location(location);
   OnExtensionLoaded(extension, true);
 
   if (location == Extension::EXTERNAL_PREF ||
       location == Extension::EXTERNAL_REGISTRY) {
-    backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
-        &ExtensionsServiceBackend::CheckExternalUninstall,
-        scoped_refptr<ExtensionsService>(this), id, location));
+    ChromeThread::PostTask(
+        ChromeThread::FILE, FROM_HERE,
+        NewRunnableMethod(
+            backend_.get(),
+            &ExtensionsServiceBackend::CheckExternalUninstall,
+            scoped_refptr<ExtensionsService>(this), id, location));
   }
 }
 
 void ExtensionsService::NotifyExtensionLoaded(Extension* extension) {
   LOG(INFO) << "Sending EXTENSION_LOADED";
 
   // The ChromeURLRequestContext needs to be first to know that the extension
   // was loaded, otherwise a race can arise where a renderer that is created
   // for the extension may try to load an extension URL with an extension id
   // that the request context doesn't yet know about.
   if (profile_ && !profile_->IsOffTheRecord()) {
     ChromeURLRequestContextGetter* context_getter =
         static_cast<ChromeURLRequestContextGetter*>(
             profile_->GetRequestContext());
     if (context_getter) {
-      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-          NewRunnableMethod(context_getter,
-                            &ChromeURLRequestContextGetter::OnNewExtensions,
-                            extension->id(),
-                            extension->path()));
+      ChromeThread::PostTask(
+          ChromeThread::IO, FROM_HERE,
+          NewRunnableMethod(
+              context_getter,
+              &ChromeURLRequestContextGetter::OnNewExtensions,
+              extension->id(),
+              extension->path()));
     }
   }
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_LOADED,
       Source<ExtensionsService>(this),
       Details<Extension>(extension));
 }
 
 void ExtensionsService::NotifyExtensionUnloaded(Extension* extension) {
   LOG(INFO) << "Sending EXTENSION_UNLOADED";
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_UNLOADED,
       Source<ExtensionsService>(this),
       Details<Extension>(extension));
 
   if (profile_ && !profile_->IsOffTheRecord()) {
     ChromeURLRequestContextGetter* context_getter =
         static_cast<ChromeURLRequestContextGetter*>(
             profile_->GetRequestContext());
     if (context_getter) {
-      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+      ChromeThread::PostTask(
+          ChromeThread::IO, FROM_HERE,
           NewRunnableMethod(
               context_getter,
               &ChromeURLRequestContextGetter::OnUnloadedExtension,
               extension->id()));
     }
   }
 }
 
 void ExtensionsService::UpdateExtensionBlacklist(
   const std::vector<std::string>& blacklist) {
@@ skipping 21 matching lines @@
     UnloadExtension(to_be_removed[i]);
   }
 }
 
 void ExtensionsService::CheckForExternalUpdates() {
   // This installs or updates externally provided extensions.
   // TODO(aa): Why pass this list into the provider, why not just filter it
   // later?
   std::set<std::string> killed_extensions;
   extension_prefs_->GetKilledExtensionIds(&killed_extensions);
-  backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
-      &ExtensionsServiceBackend::CheckForExternalUpdates,
-      killed_extensions,
-      scoped_refptr<ExtensionsService>(this)));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          backend_.get(), &ExtensionsServiceBackend::CheckForExternalUpdates,
+          killed_extensions, scoped_refptr<ExtensionsService>(this)));
 }
 
 void ExtensionsService::UnloadExtension(const std::string& extension_id) {
   scoped_ptr<Extension> extension(
       GetExtensionByIdInternal(extension_id, true, true));
 
   // Callers should not send us nonexistant extensions.
   CHECK(extension.get());
 
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
@@ skipping 31 matching lines @@
 }
 
 void ExtensionsService::ReloadExtensions() {
   UnloadAllExtensions();
   LoadAllExtensions();
 }
 
 void ExtensionsService::GarbageCollectExtensions() {
   InstalledExtensionSet installed(
       new InstalledExtensions(extension_prefs_.get()));
-  backend_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      &extension_file_util::GarbageCollectExtensions, install_directory_,
-      installed.extensions()));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableFunction(
+          &extension_file_util::GarbageCollectExtensions, install_directory_,
+          installed.extensions()));
 }
 
 void ExtensionsService::OnLoadedInstalledExtensions() {
   ready_ = true;
   if (updater_.get()) {
     updater_->Start();
   }
   NotificationService::current()->Notify(
       NotificationType::EXTENSIONS_READY,
       Source<ExtensionsService>(this),
@@ skipping 139 matching lines @@
   }
   return NULL;
 }
 
 Extension* ExtensionsService::GetExtensionByURL(const GURL& url) {
   std::string host = url.host();
   return GetExtensionById(host);
 }
 
 void ExtensionsService::ClearProvidersForTesting() {
-  backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
-      &ExtensionsServiceBackend::ClearProvidersForTesting));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          backend_.get(), &ExtensionsServiceBackend::ClearProvidersForTesting));
 }
 
 void ExtensionsService::SetProviderForTesting(
     Extension::Location location, ExternalExtensionProvider* test_provider) {
-  backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
-      &ExtensionsServiceBackend::SetProviderForTesting,
-      location, test_provider));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          backend_.get(), &ExtensionsServiceBackend::SetProviderForTesting,
+          location, test_provider));
 }
 
 void ExtensionsService::OnExternalExtensionFound(const std::string& id,
                                                  const std::string& version,
                                                  const FilePath& path,
                                                  Extension::Location location) {
   // Before even bothering to unpack, check and see if we already have this
   // version. This is important because these extensions are going to get
   // installed on every startup.
   Extension* existing = GetExtensionById(id);
   scoped_ptr<Version> other(Version::GetVersionFromString(version));
   if (existing) {
     switch (existing->version()->CompareTo(*other)) {
       case -1:  // existing version is older, we should upgrade
         break;
       case 0:  // existing version is same, do nothing
         return;
       case 1:  // existing version is newer, uh-oh
         LOG(WARNING) << "Found external version of extension " << id
                      << "that is older than current version. Current version "
                      << "is: " << existing->VersionString() << ". New version "
                      << "is: " << version << ". Keeping current version.";
         return;
     }
   }
 
   CrxInstaller::Start(path, install_directory_, location, id,
                       false,  // don't delete crx when complete
                       true,  // allow privilege increase
-                      backend_loop_,
                       this,
                       NULL);  // no client (silent install)
 }
 
 void ExtensionsService::ReportExtensionLoadError(
     const FilePath& extension_path,
     const std::string &error,
     NotificationType type,
     bool be_noisy) {
   NotificationService* service = NotificationService::current();
   service->Notify(type,
                   Source<ExtensionsService>(this),
                   Details<const std::string>(&error));
 
   // TODO(port): note that this isn't guaranteed to work properly on Linux.
   std::string path_str = WideToASCII(extension_path.ToWStringHack());
   std::string message = StringPrintf("Could not load extension from '%s'. %s",
                                      path_str.c_str(), error.c_str());
   ExtensionErrorReporter::GetInstance()->ReportError(message, be_noisy);
 }
 
 // ExtensionsServicesBackend
 
 ExtensionsServiceBackend::ExtensionsServiceBackend(
-    const FilePath& install_directory, MessageLoop* frontend_loop)
+    const FilePath& install_directory)
         : frontend_(NULL),
           install_directory_(install_directory),
-          alert_on_error_(false),
-          frontend_loop_(frontend_loop) {
+          alert_on_error_(false) {
   // TODO(aa): This ends up doing blocking IO on the UI thread because it reads
   // pref data in the ctor and that is called on the UI thread. Would be better
   // to re-read data each time we list external extensions, anyway.
   external_extension_providers_[Extension::EXTERNAL_PREF] =
       linked_ptr<ExternalExtensionProvider>(
           new ExternalPrefExtensionProvider());
 #if defined(OS_WIN)
   external_extension_providers_[Extension::EXTERNAL_REGISTRY] =
       linked_ptr<ExternalExtensionProvider>(
           new ExternalRegistryExtensionProvider());
@@ skipping 26 matching lines @@
     ReportExtensionLoadError(extension_path, error);
     return;
   }
 
   extension->set_location(Extension::LOAD);
   ReportExtensionLoaded(extension);
 }
 
 void ExtensionsServiceBackend::ReportExtensionLoadError(
     const FilePath& extension_path, const std::string &error) {
-  // In the unit tests, frontend_loop_ may be null.
-  if (frontend_loop_ == NULL) {
-    frontend_->ReportExtensionLoadError(
-        extension_path,
-        error,
-        NotificationType::EXTENSION_INSTALL_ERROR,
-        alert_on_error_);
-    return;
-  }
-
-  frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(frontend_,
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          frontend_,
           &ExtensionsService::ReportExtensionLoadError, extension_path,
           error, NotificationType::EXTENSION_INSTALL_ERROR, alert_on_error_));
 }
 
 void ExtensionsServiceBackend::ReportExtensionLoaded(Extension* extension) {
-  frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      frontend_, &ExtensionsService::OnExtensionLoaded, extension, true));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          frontend_, &ExtensionsService::OnExtensionLoaded, extension, true));
 }
 
 bool ExtensionsServiceBackend::LookupExternalExtension(
     const std::string& id, Version** version, Extension::Location* location) {
   scoped_ptr<Version> extension_version;
   for (ProviderMap::const_iterator i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     const ExternalExtensionProvider* provider = i->second.get();
     extension_version.reset(provider->RegisteredVersion(id, location));
     if (extension_version.get()) {
@@ skipping 41 matching lines @@
                  << location;
     return;
   }
 
   scoped_ptr<Version> version;
   version.reset(i->second->RegisteredVersion(id, NULL));
   if (version.get())
     return;  // Yup, known extension, don't uninstall.
 
   // This is an external extension that we don't have registered.  Uninstall.
-  frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      frontend.get(), &ExtensionsService::UninstallExtension,
-      id, true));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          frontend.get(), &ExtensionsService::UninstallExtension, id, true));
 }
 
 void ExtensionsServiceBackend::ClearProvidersForTesting() {
   external_extension_providers_.clear();
 }
 
 void ExtensionsServiceBackend::SetProviderForTesting(
     Extension::Location location,
     ExternalExtensionProvider* test_provider) {
   DCHECK(test_provider);
   external_extension_providers_[location] =
       linked_ptr<ExternalExtensionProvider>(test_provider);
 }
 
 void ExtensionsServiceBackend::OnExternalExtensionFound(
     const std::string& id, const Version* version, const FilePath& path,
     Extension::Location location) {
-  frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(frontend_,
-      &ExtensionsService::OnExternalExtensionFound, id, version->GetString(),
-      path, location));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          frontend_, &ExtensionsService::OnExternalExtensionFound, id,
+          version->GetString(), path, location));
 }