Convert ExtensionRegistry to a BrowserContextKeyedService

extensions/browser/process_manager.cc

 // Copyright 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 "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 15 matching lines @@
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "content/public/common/renderer_preferences.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 #include "extensions/common/switches.h"
 
 using content::BrowserContext;
 using content::RenderViewHost;
 using content::SiteInstance;
@@ skipping 248 matching lines @@
   }
 
   return result;
 }
 
 const Extension* ProcessManager::GetExtensionForRenderViewHost(
     RenderViewHost* render_view_host) {
   if (!render_view_host->GetSiteInstance())
     return NULL;
 
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-      GetBrowserContext())->extension_service();
-  if (!service)
+  ExtensionRegistry* registry = ExtensionRegistry::Get(GetBrowserContext());
+  if (!registry)
     return NULL;
 
-  return service->extensions()->GetByID(GetExtensionID(render_view_host));
+  return registry->enabled_extensions().GetByID(
+      GetExtensionID(render_view_host));
 }
 
 void ProcessManager::UnregisterRenderViewHost(
     RenderViewHost* render_view_host) {
   ExtensionRenderViews::iterator view =
       all_extension_views_.find(render_view_host);
   if (view == all_extension_views_.end())
     return;
 
   OnRenderViewHostUnregistered(GetBrowserContext(), render_view_host);
@@ skipping 375 matching lines @@
   }
 }
 
 void ProcessManager::CreateBackgroundHostsForProfileStartup() {
   if (startup_background_hosts_created_ ||
       !ExtensionsBrowserClient::Get()->
           IsBackgroundPageAllowed(GetBrowserContext())) {
     return;
   }
 
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-      GetBrowserContext())->extension_service();
-  DCHECK(service);
-  for (ExtensionSet::const_iterator extension = service->extensions()->begin();
-       extension != service->extensions()->end(); ++extension) {
+  const ExtensionSet& enabled_extensions =
+      ExtensionRegistry::Get(GetBrowserContext())->enabled_extensions();
+  for (ExtensionSet::const_iterator extension = enabled_extensions.begin();
+       extension != enabled_extensions.end();
+       ++extension) {
     CreateBackgroundHostForExtensionLoad(this, extension->get());
 
     RuntimeEventRouter::DispatchOnStartupEvent(GetBrowserContext(),
                                                (*extension)->id());
   }
   startup_background_hosts_created_ = true;
 
   // Background pages should only be loaded once. To prevent any further loads
   // occurring, we remove the notification listeners.
   BrowserContext* original_context =
@@ skipping 114 matching lines @@
     if (IsIncognitoEnabled(extension))
       return ProcessManager::CreateBackgroundHost(extension, url);
   } else {
     // Do nothing. If an extension is spanning, then its original-profile
     // background page is shared with incognito, so we don't create another.
   }
   return NULL;
 }
 
 SiteInstance* IncognitoProcessManager::GetSiteInstanceForURL(const GURL& url) {
-  ExtensionService* service = ExtensionSystem::GetForBrowserContext(
-      GetBrowserContext())->extension_service();
-  if (service) {
+  ExtensionRegistry* registry = ExtensionRegistry::Get(GetBrowserContext());
+  if (registry) {
     const Extension* extension =
-        service->extensions()->GetExtensionOrAppByURL(url);
+        registry->enabled_extensions().GetExtensionOrAppByURL(url);
     if (extension && !IncognitoInfo::IsSplitMode(extension)) {
       return original_manager_->GetSiteInstanceForURL(url);
     }
   }
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 bool IncognitoProcessManager::IsIncognitoEnabled(const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   return extension_util::IsIncognitoEnabled(extension->id(), service);
 }
 
 }  // namespace extensions