Kill Extension::RuntimeData and move its guts to ExtensionsService.

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2010 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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 132 matching lines @@
 
 PendingExtensionInfo::PendingExtensionInfo()
     : update_url(),
       expected_crx_type(PendingExtensionInfo::UNKNOWN),
       is_from_sync(true),
       install_silently(false),
       enable_on_install(false),
       enable_incognito_on_install(false),
       install_source(Extension::INVALID) {}
 
+
+ExtensionsService::ExtensionRuntimeData::ExtensionRuntimeData()
+    : background_page_ready(false),
+      being_upgraded(false) {
+}
+
+ExtensionsService::ExtensionRuntimeData::~ExtensionRuntimeData() {
+}
+
 // ExtensionsService.
 
 const char* ExtensionsService::kInstallDirectoryName = "Extensions";
 const char* ExtensionsService::kCurrentVersionFileName = "Current Version";
 
 // Implements IO for the ExtensionsService.
 
 class ExtensionsServiceBackend
     : public base::RefCountedThreadSafe<ExtensionsServiceBackend>,
       public ExternalExtensionProvider::Visitor {
@@ skipping 1157 matching lines @@
   // Callers should not send us nonexistent extensions.
   CHECK(extension.get());
 
   // Keep information about the extension so that we can reload it later
   // even if it's not permanently installed.
   unloaded_extension_paths_[extension->id()] = extension->path();
 
   // Clean up if the extension is meant to be enabled after a reload.
   disabled_extension_paths_.erase(extension->id());
 
+  // Clean up runtime data.
+  extension_runtime_data_.erase(extension_id);
+
   ExtensionDOMUI::UnregisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension.get());
   if (iter != disabled_extensions_.end()) {
     disabled_extensions_.erase(iter);
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_UNLOADED_DISABLED,
         Source<Profile>(profile_),
         Details<const Extension>(extension.get()));
     return;
   }
 
   iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
 
   // Remove the extension from our list.
   extensions_.erase(iter);
 
   NotifyExtensionUnloaded(extension.get());
   UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionsService::UnloadAllExtensions() {
   extensions_.clear();
   disabled_extensions_.clear();
+  extension_runtime_data_.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();
 }
@@ skipping 52 matching lines @@
       // CrxInstaller should have guaranteed that we aren't downgrading.
       CHECK(extension->version()->CompareTo(*(old->version())) >= 0);
 
       bool allow_silent_upgrade =
           allow_privilege_increase || !Extension::IsPrivilegeIncrease(
               old, extension);
 
       // Extensions get upgraded if silent upgrades are allowed, otherwise
       // they get disabled.
       if (allow_silent_upgrade) {
-        old->set_being_upgraded(true);
-        extension->set_being_upgraded(true);
+        SetBeingUpgraded(old, true);
+        SetBeingUpgraded(extension, true);
       }
 
       // To upgrade an extension in place, unload the old one and
       // then load the new one.
       UnloadExtension(old->id());
       old = NULL;
 
       if (!allow_silent_upgrade) {
         // Extension has changed permissions significantly. Disable it. We
         // send a notification below.
@@ skipping 17 matching lines @@
             NotificationType::EXTENSION_UPDATE_DISABLED,
             Source<Profile>(profile_),
             Details<const Extension>(extension));
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
-  extension->set_being_upgraded(false);
+  SetBeingUpgraded(extension, false);
 
   UpdateActiveExtensionsInCrashReporter();
 
   if (profile_->GetTemplateURLModel())
     profile_->GetTemplateURLModel()->RegisterExtensionKeyword(extension);
 
   // Load the icon for omnibox-enabled extensions so it will be ready to display
   // in the URL bar.
   if (!extension->omnibox_keyword().empty()) {
     omnibox_popup_icon_manager_.LoadIcon(extension);
@@ skipping 355 matching lines @@
 ExtensionIdSet ExtensionsService::GetAppIds() const {
   ExtensionIdSet result;
   for (ExtensionList::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
     if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
       result.insert((*it)->id());
   }
 
   return result;
 }
+
+bool ExtensionsService::IsBackgroundPageReady(const Extension* extension) {
+  return (extension->background_url().is_empty() ||
+          extension_runtime_data_[extension->id()].background_page_ready);
+}
+
+void ExtensionsService::SetBackgroundPageReady(const Extension* extension) {
+  DCHECK(!extension->background_url().is_empty());
+  extension_runtime_data_[extension->id()].background_page_ready = true;
+  NotificationService::current()->Notify(
+      NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
+      Source<const Extension>(extension),
+      NotificationService::NoDetails());
+}
+
+bool ExtensionsService::IsBeingUpgraded(const Extension* extension) {
+  return extension_runtime_data_[extension->id()].being_upgraded;
+}
+
+void ExtensionsService::SetBeingUpgraded(const Extension* extension,
+                                         bool value) {
+  extension_runtime_data_[extension->id()].being_upgraded = value;
+}