Clean up a few startup and shutdown dependencies which should fix some of the...

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 "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/crypto/signature_verifier.h"
 #include "base/file_util.h"
@@ skipping 197 matching lines @@
   // True if we got a response from the utility process and have cleaned up
   // already.
   bool got_response_;
 };
 
 ExtensionsService::ExtensionsService(Profile* profile,
                                      const CommandLine* command_line,
                                      MessageLoop* frontend_loop,
                                      MessageLoop* backend_loop)
     : extension_prefs_(new ExtensionPrefs(profile->GetPrefs())),
+      extension_process_manager_(new ExtensionProcessManager(profile)),
       backend_loop_(backend_loop),
       install_directory_(profile->GetPath().AppendASCII(kInstallDirectoryName)),
       extensions_enabled_(false),
       show_extensions_prompts_(true),
       ready_(false) {
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kEnableExtensions))
     extensions_enabled_ = true;
   else if (profile->GetPrefs()->GetBoolean(prefs::kEnableExtensions))
     extensions_enabled_ = true;
 
   // We pass ownership of this object to the Backend.
   DictionaryValue* extensions = extension_prefs_->CopyCurrentExtensions();
   backend_ = new ExtensionsServiceBackend(
           install_directory_, g_browser_process->resource_dispatcher_host(),
           frontend_loop, extensions, extensions_enabled());
 }
 
 ExtensionsService::~ExtensionsService() {
   UnloadAllExtensions();
 }
 
 void ExtensionsService::SetExtensionsEnabled(bool enabled) {
   extensions_enabled_ = true;
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
     &ExtensionsServiceBackend::set_extensions_enabled, enabled));
 }
 
 void ExtensionsService::Init() {
+  DCHECK(!ready_);
   DCHECK(extensions_.size() == 0);
 
   // Start up the extension event routers.
   ExtensionBrowserEventRouter::GetInstance()->Init();
 
   LoadAllExtensions();
 
   // TODO(erikkay) this should probably be deferred to a future point
   // rather than running immediately at startup.
   CheckForUpdates();
@@ skipping 61 matching lines @@
   }
 
   // Callers should not send us nonexistant extensions.
   CHECK(extension);
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
   // Tell other services the extension is gone.
   NotificationService::current()->Notify(NotificationType::EXTENSION_UNLOADED,
-                                         NotificationService::AllSources(),
+                                         Source<ExtensionsService>(this),
                                          Details<Extension>(extension));
 
   delete extension;
 }
 
 void ExtensionsService::UnloadAllExtensions() {
   ExtensionList::iterator iter;
-  for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
-    // Tell other services the extension is gone.
-    NotificationService::current()->Notify(NotificationType::EXTENSION_UNLOADED,
-                                           NotificationService::AllSources(),
-                                           Details<Extension>(*iter));
+  for (iter = extensions_.begin(); iter != extensions_.end(); ++iter)
     delete *iter;
-  }
   extensions_.clear();
+
+  // TODO(erikkay) should there be a notification for this?  We can't use
+  // EXTENSION_UNLOADED since that implies that the extension has been disabled
+  // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
 void ExtensionsService::ReloadExtensions() {
   UnloadAllExtensions();
   LoadAllExtensions();
 }
 
 void ExtensionsService::GarbageCollectExtensions() {
   backend_loop_->PostTask(FROM_HERE, NewRunnableMethod(backend_.get(),
       &ExtensionsServiceBackend::GarbageCollectExtensions,
@@ skipping 38 matching lines @@
     } else {
       // Extensions that get enabled get added to extensions_ and deleted later.
       // Anything skipped must be deleted now so we don't leak.
       delete *iter;
     }
   }
 
   if (enabled_extensions.size()) {
     NotificationService::current()->Notify(
         NotificationType::EXTENSIONS_LOADED,
-        NotificationService::AllSources(),
+        Source<ExtensionsService>(this),
         Details<ExtensionList>(&enabled_extensions));
   }
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension,
     Extension::InstallType install_type) {
   extension_prefs_->OnExtensionInstalled(extension);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
-        NotificationService::AllSources(),
+        Source<ExtensionsService>(this),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_INSTALLED,
-        NotificationService::AllSources(),
+        Source<ExtensionsService>(this),
         Details<Extension>(extension));
   }
 }
 
 void ExtensionsService::OnExtensionOverinstallAttempted(const std::string& id) {
   Extension* extension = GetExtensionById(id);
   if (extension && extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
-        NotificationService::AllSources(),
+        Source<ExtensionsService>(this),
         Details<Extension>(extension));
   }
 }
 
 Extension* ExtensionsService::GetExtensionById(const std::string& id) {
   for (ExtensionList::const_iterator iter = extensions_.begin();
       iter != extensions_.end(); ++iter) {
     if ((*iter)->id() == id)
       return *iter;
   }
@@ skipping 843 matching lines @@
   Extension::InstallType install_type =
       CompareToInstalledVersion(id, version->GetString(), &current_version);
 
   if (install_type == Extension::DOWNGRADE)
     return false;
 
   return (install_type == Extension::UPGRADE ||
           install_type == Extension::NEW_INSTALL ||
           NeedsReinstall(id, current_version));
 }