app_shell: Extract extension runtime data from ExtensionService

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2013 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/extension_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
@@ skipping 65 matching lines @@
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pending_extension_manager.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
+#include "extensions/browser/runtime_data.h"
 #include "extensions/browser/update_observer.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
@@ skipping 86 matching lines @@
     return IsCWSSharedModule(extension);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SharedModuleProvider);
 };
 
 
 }  // namespace
 
-ExtensionService::ExtensionRuntimeData::ExtensionRuntimeData()
-    : background_page_ready(false),
-      being_upgraded(false),
-      has_used_webrequest(false) {
-}
-
-ExtensionService::ExtensionRuntimeData::~ExtensionRuntimeData() {
-}
-
 // ExtensionService.
 
 void ExtensionService::CheckExternalUninstall(const std::string& id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the providers know about this extension.
   extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     DCHECK(i->get()->IsReady());
@@ skipping 522 matching lines @@
     if (host && DevToolsAgentHost::HasFor(host->render_view_host())) {
       // Look for an open inspector for the background page.
       scoped_refptr<DevToolsAgentHost> agent_host =
           DevToolsAgentHost::GetOrCreateFor(host->render_view_host());
       agent_host->DisconnectRenderViewHost();
       orphaned_dev_tools_[extension_id] = agent_host;
     }
 
     path = current_extension->path();
     // BeingUpgraded is set back to false when the extension is added.
-    SetBeingUpgraded(current_extension, true);
+    system_->runtime_data()->SetBeingUpgraded(current_extension, true);
     DisableExtension(extension_id, Extension::DISABLE_RELOAD);
     reloading_extensions_.insert(extension_id);
   } else {
     path = unloaded_extension_paths_[extension_id];
   }
 
   if (delayed_installs_.Contains(extension_id)) {
     FinishDelayedInstallation(extension_id);
     return;
   }
@@ skipping 218 matching lines @@
 
   extension_prefs_->SetExtensionState(extension_id, Extension::DISABLED);
   extension_prefs_->AddDisableReason(extension_id, disable_reason);
 
   int include_mask =
       ExtensionRegistry::EVERYTHING & ~ExtensionRegistry::DISABLED;
   extension = registry_->GetExtensionById(extension_id, include_mask);
   if (!extension)
     return;
 
-  // Reset the background_page_ready flag
-  if (extensions::BackgroundInfo::HasBackgroundPage(extension))
-    extension_runtime_data_[extension->id()].background_page_ready = false;
+  bool was_enabled = registry_->enabled_extensions().Contains(extension->id());
 
-  // Move it over to the disabled list. Don't send a second unload notification
-  // for terminated extensions being disabled.
+  // Move it over to the disabled list.
   registry_->AddDisabled(make_scoped_refptr(extension));
-  if (registry_->enabled_extensions().Contains(extension->id())) {
+  if (was_enabled)
     registry_->RemoveEnabled(extension->id());
+  else
+    registry_->RemoveTerminated(extension->id());
+  registry_->TriggerOnDisabled(extension);
+
+  // Only send the unload notification for enabled extensions to avoid sending
+  // a second notification for terminated extensions.
+  if (was_enabled)
     NotifyExtensionUnloaded(extension, UnloadedExtensionInfo::REASON_DISABLE);
-  } else {
-    registry_->RemoveTerminated(extension->id());
-  }
 
   if (extension_sync_service_)
     extension_sync_service_->SyncDisableExtension(*extension);
 }
 
 void ExtensionService::DisableUserExtensions(
     const std::vector<std::string>& except_ids) {
   extensions::ManagementPolicy* management_policy =
       system_->management_policy();
   extensions::ExtensionList to_disable;
@@ skipping 578 matching lines @@
     return;
   }
 
   // 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.
   reloading_extensions_.erase(extension->id());
 
-  // Clean up runtime data.
-  extension_runtime_data_.erase(extension_id);
+  bool was_disabled =
+      registry_->disabled_extensions().Contains(extension->id());
 
-  if (registry_->disabled_extensions().Contains(extension->id())) {
+  // Remove the extension from the registry.
+  if (was_disabled)
     registry_->RemoveDisabled(extension->id());
+  else
+    registry_->RemoveEnabled(extension->id());
+  registry_->TriggerOnUnloaded(extension);

[not at google - send to devlin, 2014/01/22 16:17:43]

Should this go in NotifyExtensionUnloaded? That would actually change the
behaviour here, since it would only trigger the unloaded event on !was_disabled,
which given the old code is probably the right thing to do.

Hm, maybe I'm missing something here because it looks like you did explicitly
make that change; reverting it would also mean going basically back to the old
code just without that runtime_data reference.

[James Cook, 2014/01/22 17:41:52]

The code I wrote has identical behavior to the old code with respect to clearing
the runtime data and calling NotifyExtensionUnloaded. Are you saying I should
change when runtime data is cleared?

[not at google - send to devlin, 2014/01/22 17:49:07]

Yeah I'm questioning whether the old code is correct.

+
+  // Notify other subsystems that the extension is gone.
+  if (was_disabled) {
     // Make sure the profile cleans up its RequestContexts when an already
     // disabled extension is unloaded (since they are also tracking the disabled
     // extensions).
     system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
   } else {
-    // Remove the extension from the enabled list.
-    registry_->RemoveEnabled(extension->id());
     NotifyExtensionUnloaded(extension.get(), reason);
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_REMOVED,
       content::Source<Profile>(profile_),
       content::Details<const Extension>(extension.get()));
 }
 
 void ExtensionService::RemoveComponentExtension(
@@ skipping 99 matching lines @@
   if (old) {
     is_extension_installed = true;
     int version_compare_result =
         extension->version()->CompareTo(*(old->version()));
     is_extension_upgrade = version_compare_result > 0;
     // Other than for unpacked extensions, CrxInstaller should have guaranteed
     // that we aren't downgrading.
     if (!Manifest::IsUnpackedLocation(extension->location()))
       CHECK_GE(version_compare_result, 0);
   }
-  SetBeingUpgraded(extension, is_extension_upgrade);
+  system_->runtime_data()->SetBeingUpgraded(extension, is_extension_upgrade);
 
   // The extension is now loaded, remove its data from unloaded extension map.
   unloaded_extension_paths_.erase(extension->id());
 
   // If a terminated extension is loaded, remove it from the terminated list.
   UntrackTerminatedExtension(extension->id());
 
   // If the extension was disabled for a reload, then enable it.
   bool reloading = reloading_extensions_.erase(extension->id()) > 0;
 
@@ skipping 42 matching lines @@
       }
       extension_prefs_->app_sorting()->EnsureValidOrdinals(
           extension->id(), syncer::StringOrdinal());
     }
 
     registry_->AddEnabled(extension);
     if (extension_sync_service_)
       extension_sync_service_->SyncExtensionChangeIfNeeded(*extension);
     NotifyExtensionLoaded(extension);
   }
-  SetBeingUpgraded(extension, false);
+  system_->runtime_data()->SetBeingUpgraded(extension, false);
 }
 
 void ExtensionService::AddComponentExtension(const Extension* extension) {
   const std::string old_version_string(
       extension_prefs_->GetVersionString(extension->id()));
   const Version old_version(old_version_string);
 
   VLOG(1) << "AddComponentExtension " << extension->name();
   if (!old_version.IsValid() || !old_version.Equals(*extension->version())) {
     VLOG(1) << "Component extension " << extension->name() << " ("
@@ skipping 814 matching lines @@
   const ExtensionSet& extensions = registry_->enabled_extensions();
   for (ExtensionSet::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     if ((*it)->is_app() && (*it)->location() != Manifest::COMPONENT)
       result.insert((*it)->id());
   }
 
   return result;
 }
 
-bool ExtensionService::IsBackgroundPageReady(const Extension* extension) const {
-  if (!extensions::BackgroundInfo::HasPersistentBackgroundPage(extension))
-    return true;
-  ExtensionRuntimeDataMap::const_iterator it =
-      extension_runtime_data_.find(extension->id());
-  return it == extension_runtime_data_.end() ? false :
-                                               it->second.background_page_ready;
-}
-
-void ExtensionService::SetBackgroundPageReady(const Extension* extension) {
-  DCHECK(extensions::BackgroundInfo::HasBackgroundPage(extension));
-  extension_runtime_data_[extension->id()].background_page_ready = true;
-}
-
-bool ExtensionService::IsBeingUpgraded(const Extension* extension) const {
-  ExtensionRuntimeDataMap::const_iterator it =
-      extension_runtime_data_.find(extension->id());
-  return it == extension_runtime_data_.end() ? false :
-                                               it->second.being_upgraded;
-}
-
-void ExtensionService::SetBeingUpgraded(const Extension* extension,
-                                        bool value) {
-  extension_runtime_data_[extension->id()].being_upgraded = value;
-}
-
 bool ExtensionService::IsBeingReloaded(
     const std::string& extension_id) const {
   return ContainsKey(extensions_being_reloaded_, extension_id);
 }
 
 void ExtensionService::SetBeingReloaded(const std::string& extension_id,
                                         bool isBeingReloaded) {
   if (isBeingReloaded)
     extensions_being_reloaded_.insert(extension_id);
   else
     extensions_being_reloaded_.erase(extension_id);
 }
 
-bool ExtensionService::HasUsedWebRequest(const Extension* extension) const {
-  ExtensionRuntimeDataMap::const_iterator it =
-      extension_runtime_data_.find(extension->id());
-  return it == extension_runtime_data_.end() ? false :
-                                               it->second.has_used_webrequest;
-}
-
-void ExtensionService::SetHasUsedWebRequest(const Extension* extension,
-                                            bool value) {
-  extension_runtime_data_[extension->id()].has_used_webrequest = value;
-}
-
 bool ExtensionService::ShouldEnableOnInstall(const Extension* extension) {
   // Extensions installed by policy can't be disabled. So even if a previous
   // installation disabled the extension, make sure it is now enabled.
   if (system_->management_policy()->MustRemainEnabled(extension, NULL))
     return true;
 
   if (extension_prefs_->IsExtensionDisabled(extension->id()))
     return false;
 
   if (FeatureSwitch::prompt_for_external_extensions()->IsEnabled()) {
@@ skipping 132 matching lines @@
 void ExtensionService::RemoveUpdateObserver(
     extensions::UpdateObserver* observer) {
   update_observers_.RemoveObserver(observer);
 }
 
 // Used only by test code.
 void ExtensionService::UnloadAllExtensionsInternal() {
   profile_->GetExtensionSpecialStoragePolicy()->RevokeRightsForAllExtensions();
 
   registry_->ClearAll();
-  extension_runtime_data_.clear();
+  system_->runtime_data()->ClearAll();
 
   // 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.
 }