Reland 125805 - Reland 124817 - A profile-keyed service for Extensions, ExtensionSystem.

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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 <set>
 
 #include "base/basictypes.h"
@@ skipping 35 matching lines @@
 #include "chrome/browser/extensions/extension_global_error.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_input_ime_api.h"
 #include "chrome/browser/extensions/extension_management_api.h"
 #include "chrome/browser/extensions/extension_preference_api.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_processes_api.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/extensions/extension_webnavigation_api.h"
 #include "chrome/browser/extensions/external_extension_provider_impl.h"
 #include "chrome/browser/extensions/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
@@ skipping 304 matching lines @@
   return true;
 }
 
 ExtensionService::ExtensionService(Profile* profile,
                                    const CommandLine* command_line,
                                    const FilePath& install_directory,
                                    ExtensionPrefs* extension_prefs,
                                    bool autoupdate_enabled,
                                    bool extensions_enabled)
     : profile_(profile),
+      system_(ExtensionSystemFactory::GetForProfile(profile)),
       extension_prefs_(extension_prefs),
       settings_frontend_(extensions::SettingsFrontend::Create(profile)),
       pending_extension_manager_(*ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       install_directory_(install_directory),
       extensions_enabled_(extensions_enabled),
       show_extensions_prompts_(true),
       ready_(false),
       toolbar_model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       menu_manager_(profile),
       app_notification_manager_(new AppNotificationManager(profile)),
@@ skipping 303 matching lines @@
 void ExtensionService::ReloadExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath path;
   const Extension* current_extension = GetExtensionById(extension_id, false);
 
   // Disable the extension if it's loaded. It might not be loaded if it crashed.
   if (current_extension) {
     // If the extension has an inspector open for its background page, detach
     // the inspector and hang onto a cookie for it, so that we can reattach
     // later.
-    ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
+    // TODO(yoz): this is not incognito-safe!
+    ExtensionProcessManager* manager = system_->process_manager();
     ExtensionHost* host = manager->GetBackgroundHostForExtension(extension_id);
     if (host && DevToolsAgentHostRegistry::HasDevToolsAgentHost(
             host->render_view_host())) {
       // Look for an open inspector for the background page.
       DevToolsAgentHost* agent =
           DevToolsAgentHostRegistry::GetDevToolsAgentHost(
               host->render_view_host());
       int devtools_cookie =
           content::DevToolsManager::GetInstance()->DetachClientHost(agent);
       if (devtools_cookie >= 0)
@@ skipping 269 matching lines @@
   }
 }
 
 void ExtensionService::NotifyExtensionLoaded(const Extension* extension) {
   // The ChromeURLRequestContexts need 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. The profile is responsible
   // for ensuring its URLRequestContexts appropriately discover the loaded
   // extension.
-  profile_->RegisterExtensionWithRequestContexts(extension);
+  system_->RegisterExtensionWithRequestContexts(extension);
 
   // Tell renderers about the new extension, unless it's a theme (renderers
   // don't need to know about themes).
   if (!extension->is_theme()) {
     for (content::RenderProcessHost::iterator i(
             content::RenderProcessHost::AllHostsIterator());
          !i.IsAtEnd(); i.Advance()) {
       content::RenderProcessHost* host = i.GetCurrentValue();
       Profile* host_profile =
           Profile::FromBrowserContext(host->GetBrowserContext());
@@ skipping 126 matching lines @@
   for (content::RenderProcessHost::iterator i(
           content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     content::RenderProcessHost* host = i.GetCurrentValue();
     Profile* host_profile =
         Profile::FromBrowserContext(host->GetBrowserContext());
     if (host_profile->GetOriginalProfile() == profile_->GetOriginalProfile())
       host->Send(new ExtensionMsg_Unloaded(extension->id()));
   }
 
-  profile_->UnregisterExtensionWithRequestContexts(extension->id(), reason);
+  system_->UnregisterExtensionWithRequestContexts(extension->id(), reason);
   profile_->GetExtensionSpecialStoragePolicy()->
       RevokeRightsForExtension(extension);
 
   ExtensionWebUI::UnregisterChromeURLOverrides(
       profile_, extension->GetChromeURLOverrides());
 
 #if defined(OS_CHROMEOS)
     // Revoke external file access to
   if (BrowserContext::GetFileSystemContext(profile_) &&
       BrowserContext::GetFileSystemContext(profile_)->external_provider()) {
@@ skipping 722 matching lines @@
     extension_misc::UnloadedExtensionReason reason) {
   // Make sure the extension gets deleted after we return from this function.
   scoped_refptr<const Extension> extension(
       GetExtensionByIdInternal(extension_id, true, true, false));
 
   // This method can be called via PostTask, so the extension may have been
   // unloaded by the time this runs.
   if (!extension) {
     // In case the extension may have crashed/uninstalled. Allow the profile to
     // clean up its RequestContexts.
-    profile_->UnregisterExtensionWithRequestContexts(extension_id, reason);
+    system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     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.
   disabled_extension_paths_.erase(extension->id());
 
   // Clean up runtime data.
   extension_runtime_data_.erase(extension_id);
 
 if (disabled_extensions_.Contains(extension->id())) {
     UnloadedExtensionInfo details(extension, reason);
     details.already_disabled = true;
     disabled_extensions_.Remove(extension->id());
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNLOADED,
         content::Source<Profile>(profile_),
         content::Details<UnloadedExtensionInfo>(&details));
     // Make sure the profile cleans up its RequestContexts when an already
     // disabled extension is unloaded (since they are also tracking the disabled
     // extensions).
-    profile_->UnregisterExtensionWithRequestContexts(extension_id, reason);
+    system_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
 // Remove the extension from our list.
   extensions_.Remove(extension->id());
 
   NotifyExtensionUnloaded(extension.get(), reason);
 }
 
 void ExtensionService::UnloadAllExtensions() {
@@ skipping 550 matching lines @@
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
           break;
 
       installed_app_hosts_.erase(process->GetID());
 
       process_map_.RemoveAllFromProcess(process->GetID());
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&ExtensionInfoMap::UnregisterAllExtensionsInProcess,
-                     profile_->GetExtensionInfoMap(),
+                     system_->info_map(),
                      process->GetID()));
       break;
     }
     case chrome::NOTIFICATION_PREF_CHANGED: {
       std::string* pref_name = content::Details<std::string>(details).ptr();
       if (*pref_name == prefs::kExtensionInstallAllowList ||
           *pref_name == prefs::kExtensionInstallDenyList) {
         CheckAdminBlacklist();
       } else {
         NOTREACHED() << "Unexpected preference name.";
@@ skipping 152 matching lines @@
   return api_resource_controller_;
 }
 
 extensions::RulesRegistryService* ExtensionService::GetRulesRegistryService() {
   if (!rules_registry_service_.get()) {
     rules_registry_service_.reset(
         new extensions::RulesRegistryService(profile_));
   }
   return rules_registry_service_.get();
 }