Move more extensions code from ChromeContentBrowserClient to ChromeContentBrowserClientExtensionsPa…

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 15 matching lines @@
 #include "chrome/browser/chrome_net_benchmarking_message_filter.h"
 #include "chrome/browser/chrome_quota_permission_context.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/content_settings/permission_request_id.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
 #include "chrome/browser/download/download_prefs.h"
-#include "chrome/browser/extensions/browser_permissions_policy_delegate.h"
 #include "chrome/browser/extensions/chrome_content_browser_client_extensions_part.h"
-#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/extension_util.h"
-#include "chrome/browser/extensions/suggest_permission_util.h"
 #include "chrome/browser/geolocation/chrome_access_token_store.h"
 #include "chrome/browser/geolocation/geolocation_permission_context.h"
 #include "chrome/browser/geolocation/geolocation_permission_context_factory.h"
 #include "chrome/browser/media/cast_transport_host_filter.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/midi_permission_context.h"
 #include "chrome/browser/media/midi_permission_context_factory.h"
 #include "chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.h"
 #include "chrome/browser/nacl_host/nacl_browser_delegate_impl.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/plugins/plugin_info_message_filter.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/prerender/prerender_message_filter.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/printing/printing_message_filter.h"
 #include "chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/search_provider_install_state_message_filter.h"
 #include "chrome/browser/signin/principals_message_filter.h"
 #include "chrome/browser/speech/chrome_speech_recognition_manager_delegate.h"
 #include "chrome/browser/speech/extension_api/tts_engine_extension_api.h"
 #include "chrome/browser/speech/tts_controller.h"
 #include "chrome/browser/speech/tts_message_filter.h"
 #include "chrome/browser/ssl/ssl_add_certificate.h"
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 #include "chrome/browser/ssl/ssl_client_certificate_selector.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/blocked_content/blocked_window_params.h"
 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/sync/sync_promo_ui.h"
 #include "chrome/browser/ui/tab_contents/chrome_web_contents_view_delegate.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "chrome/common/extensions/extension_process_policy.h"
-#include "chrome/common/extensions/manifest_handlers/app_isolation_info.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pepper_permission_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chromeos/chromeos_constants.h"
 #include "components/cdm/browser/cdm_message_filter_android.h"
 #include "components/cloud_devices/common/cloud_devices_switches.h"
 #include "components/dom_distiller/core/url_constants.h"
@@ skipping 13 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/show_desktop_notification_params.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/common/web_preferences.h"
-#include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_system.h"
-#include "extensions/browser/info_map.h"
-#include "extensions/browser/process_manager.h"
-#include "extensions/browser/process_map.h"
-#include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
-#include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
-#include "extensions/common/manifest_handlers/web_accessible_resources_info.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/socket_permission.h"
 #include "extensions/common/switches.h"
 #include "grit/generated_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/mime_util.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/host/ppapi_host.h"
@@ skipping 75 matching lines @@
 
 #if !defined(DISABLE_NACL)
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/nacl_host_message_filter.h"
 #include "components/nacl/browser/nacl_process_host.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "components/nacl/common/nacl_switches.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_util.h"
+#include "chrome/browser/extensions/suggest_permission_util.h"
 #include "chrome/browser/guest_view/guest_view_base.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
 #include "chrome/browser/guest_view/guest_view_manager.h"
 #include "chrome/browser/guest_view/web_view/web_view_guest.h"
 #include "chrome/browser/guest_view/web_view/web_view_permission_helper.h"
 #include "chrome/browser/guest_view/web_view/web_view_renderer_state.h"
+#include "extensions/common/manifest_handlers/background_info.h"
 #endif
 
 #if defined(ENABLE_SPELLCHECK)
 #include "chrome/browser/spellchecker/spellcheck_message_filter.h"
 #endif
 
 #if defined(ENABLE_SERVICE_DISCOVERY)
 #include "chrome/browser/local_discovery/storage/privet_filesystem_backend.h"
 #endif
 
 #if defined(ENABLE_WEBRTC)
 #include "chrome/browser/media/webrtc_logging_handler_host.h"
 #endif
 
 using base::FileDescriptor;
 using blink::WebWindowFeatures;
 using content::AccessTokenStore;
 using content::BrowserThread;
 using content::BrowserURLHandler;
 using content::ChildProcessSecurityPolicy;
 using content::QuotaPermissionContext;
 using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::ResourceType;
 using content::SiteInstance;
 using content::WebContents;
 using content::WebPreferences;
 using extensions::APIPermission;
+using extensions::ChromeContentBrowserClientExtensionsPart;
 using extensions::Extension;
 using extensions::InfoMap;
 using extensions::Manifest;
 using message_center::NotifierId;
 
 #if defined(OS_POSIX)
 using content::FileDescriptorInfo;
 #endif
 
 namespace {
@@ skipping 131 matching lines @@
 
 // Reverse URL handler for Web UI. Maps "chrome://chrome/foo/" to
 // "chrome://foo/".
 bool HandleWebUIReverse(GURL* url, content::BrowserContext* browser_context) {
   if (!url->is_valid() || !url->SchemeIs(content::kChromeUIScheme))
     return false;
 
   return RemoveUberHost(url);
 }
 
-// Used by the GetPrivilegeRequiredByUrl() and GetProcessPrivilege() functions
-// below.  Extension, and isolated apps require different privileges to be
-// granted to their RenderProcessHosts.  This classification allows us to make
-// sure URLs are served by hosts with the right set of privileges.
-enum RenderProcessHostPrivilege {
-  PRIV_NORMAL,
-  PRIV_HOSTED,
-  PRIV_ISOLATED,
-  PRIV_EXTENSION,
-};
-
-RenderProcessHostPrivilege GetPrivilegeRequiredByUrl(
-    const GURL& url,
-    ExtensionService* service) {
-  // Default to a normal renderer cause it is lower privileged. This should only
-  // occur if the URL on a site instance is either malformed, or uninitialized.
-  // If it is malformed, then there is no need for better privileges anyways.
-  // If it is uninitialized, but eventually settles on being an a scheme other
-  // than normal webrenderer, the navigation logic will correct us out of band
-  // anyways.
-  if (!url.is_valid())
-    return PRIV_NORMAL;
-
-  if (url.SchemeIs(extensions::kExtensionScheme)) {
-    const Extension* extension =
-        service->extensions()->GetByID(url.host());
-    if (extension &&
-        extensions::AppIsolationInfo::HasIsolatedStorage(extension))
-      return PRIV_ISOLATED;
-    if (extension && extension->is_hosted_app())
-      return PRIV_HOSTED;
-
-    return PRIV_EXTENSION;
-  }
-
-  return PRIV_NORMAL;
-}
-
-RenderProcessHostPrivilege GetProcessPrivilege(
-    content::RenderProcessHost* process_host,
-    extensions::ProcessMap* process_map,
-    ExtensionService* service) {
-  std::set<std::string> extension_ids =
-      process_map->GetExtensionsInProcess(process_host->GetID());
-  if (extension_ids.empty())
-    return PRIV_NORMAL;
-
-  for (std::set<std::string>::iterator iter = extension_ids.begin();
-       iter != extension_ids.end(); ++iter) {
-    const Extension* extension = service->GetExtensionById(*iter, false);
-    if (extension &&
-        extensions::AppIsolationInfo::HasIsolatedStorage(extension))
-      return PRIV_ISOLATED;
-    if (extension && extension->is_hosted_app())
-      return PRIV_HOSTED;
-  }
-
-  return PRIV_EXTENSION;
-}
-
 bool CertMatchesFilter(const net::X509Certificate& cert,
                        const base::DictionaryValue& filter) {
   // TODO(markusheintz): This is the minimal required filter implementation.
   // Implement a better matcher.
 
   // An empty filter matches any client certificate since no requirements are
   // specified at all.
   if (filter.empty())
     return true;
 
@@ skipping 164 matching lines @@
       weak_factory_(this) {
 #if defined(ENABLE_PLUGINS)
   for (size_t i = 0; i < arraysize(kPredefinedAllowedDevChannelOrigins); ++i)
     allowed_dev_channel_origins_.insert(kPredefinedAllowedDevChannelOrigins[i]);
   for (size_t i = 0; i < arraysize(kPredefinedAllowedFileHandleOrigins); ++i)
     allowed_file_handle_origins_.insert(kPredefinedAllowedFileHandleOrigins[i]);
   for (size_t i = 0; i < arraysize(kPredefinedAllowedSocketOrigins); ++i)
     allowed_socket_origins_.insert(kPredefinedAllowedSocketOrigins[i]);
 #endif
 
-  permissions_policy_delegate_.reset(
-      new extensions::BrowserPermissionsPolicyDelegate());
-
 #if !defined(OS_ANDROID)
   TtsExtensionEngine* tts_extension_engine = TtsExtensionEngine::GetInstance();
   TtsController::GetInstance()->SetTtsEngineDelegate(tts_extension_engine);
 #endif
 
-  extra_parts_.push_back(
-      new extensions::ChromeContentBrowserClientExtensionsPart);
+  extra_parts_.push_back(new ChromeContentBrowserClientExtensionsPart);
 }
 
 ChromeContentBrowserClient::~ChromeContentBrowserClient() {
   for (int i = static_cast<int>(extra_parts_.size()) - 1; i >= 0; --i)
     delete extra_parts_[i];
   extra_parts_.clear();
 }
 
 // static
 void ChromeContentBrowserClient::RegisterProfilePrefs(
@@ skipping 248 matching lines @@
 
 #if !defined(OS_CHROMEOS)
   // If the input |url| should be assigned to the Signin renderer, make its
   // effective URL distinct from other URLs on the signin service's domain.
   // Note that the signin renderer will be allowed to sign the user in to
   // Chrome.
   if (SigninManager::IsWebBasedSigninFlowURL(url))
     return GetEffectiveURLForSignin(url);
 #endif
 
-  // If the input |url| is part of an installed app, the effective URL is an
-  // extension URL with the ID of that extension as the host. This has the
-  // effect of grouping apps together in a common SiteInstance.
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (!extension_service)
-    return url;
-
-  const Extension* extension = extension_service->extensions()->
-      GetHostedAppByURL(url);
-  if (!extension)
-    return url;
-
-  // Bookmark apps do not use the hosted app process model, and should be
-  // treated as normal URLs.
-  if (extension->from_bookmark())
-    return url;
-
-  // If the URL is part of an extension's web extent, convert it to an
-  // extension URL.
-  return extension->GetResourceURL(url.path());
+  return ChromeContentBrowserClientExtensionsPart::GetEffectiveURL(
+      profile, url);
 }
 
 bool ChromeContentBrowserClient::ShouldUseProcessPerSite(
     content::BrowserContext* browser_context, const GURL& effective_url) {
   // Non-extension, non-Instant URLs should generally use
   // process-per-site-instance.  Because we expect to use the effective URL,
   // URLs for hosted apps (apart from bookmark apps) should have an extension
   // scheme by now.
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (!profile)
     return false;
 
   if (chrome::ShouldUseProcessPerSiteForInstantURL(effective_url, profile))
     return true;
 
 #if !defined(OS_CHROMEOS)
   if (SigninManager::IsWebBasedSigninFlowURL(effective_url))
     return true;
 #endif
 
-  if (!effective_url.SchemeIs(extensions::kExtensionScheme))
-    return false;
-
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (!extension_service)
-    return false;
-
-  const Extension* extension =
-      extension_service->extensions()->GetExtensionOrAppByURL(effective_url);
-  if (!extension)
-    return false;
-
-  // If the URL is part of a hosted app that does not have the background
-  // permission, or that does not allow JavaScript access to the background
-  // page, we want to give each instance its own process to improve
-  // responsiveness.
-  if (extension->GetType() == Manifest::TYPE_HOSTED_APP) {
-    if (!extension->permissions_data()->HasAPIPermission(
-            APIPermission::kBackground) ||
-        !extensions::BackgroundInfo::AllowJSAccess(extension)) {
-      return false;
-    }
-  }
-
-  // Hosted apps that have script access to their background page must use
-  // process per site, since all instances can make synchronous calls to the
-  // background window.  Other extensions should use process per site as well.
-  return true;
+  return ChromeContentBrowserClientExtensionsPart::ShouldUseProcessPerSite(
+      profile, effective_url);
 }
 
 // These are treated as WebUI schemes but do not get WebUI bindings. Also,
 // view-source is allowed for these schemes.
 void ChromeContentBrowserClient::GetAdditionalWebUISchemes(
     std::vector<std::string>* additional_schemes) {
   additional_schemes->push_back(chrome::kChromeSearchScheme);
   additional_schemes->push_back(dom_distiller::kDomDistillerScheme);
 }
 
@@ skipping 32 matching lines @@
       request_interceptors.Pass());
 }
 
 bool ChromeContentBrowserClient::IsHandledURL(const GURL& url) {
   return ProfileIOData::IsHandledURL(url);
 }
 
 bool ChromeContentBrowserClient::CanCommitURL(
     content::RenderProcessHost* process_host,
     const GURL& url) {
-  // We need to let most extension URLs commit in any process, since this can
-  // be allowed due to web_accessible_resources.  Most hosted app URLs may also
-  // load in any process (e.g., in an iframe).  However, the Chrome Web Store
-  // cannot be loaded in iframes and should never be requested outside its
-  // process.
-  Profile* profile =
-      Profile::FromBrowserContext(process_host->GetBrowserContext());
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (!service)
-    return true;
-  const Extension* new_extension =
-      service->extensions()->GetExtensionOrAppByURL(url);
-  if (new_extension &&
-      new_extension->is_hosted_app() &&
-      new_extension->id() == extension_misc::kWebStoreAppId &&
-      !extensions::ProcessMap::Get(profile)->
-          Contains(new_extension->id(), process_host->GetID())) {
-    return false;
-  }
-
-  return true;
+  return ChromeContentBrowserClientExtensionsPart::CanCommitURL(
+      process_host, url);
 }
 
 bool ChromeContentBrowserClient::ShouldAllowOpenURL(
     content::SiteInstance* site_instance, const GURL& url) {
   GURL from_url = site_instance->GetSiteURL();
-  // Do not allow pages from the web or other extensions navigate to
-  // non-web-accessible extension resources.
-  if (url.SchemeIs(extensions::kExtensionScheme) &&
-      (from_url.SchemeIsHTTPOrHTTPS() ||
-          from_url.SchemeIs(extensions::kExtensionScheme))) {
-    Profile* profile = Profile::FromBrowserContext(
-        site_instance->GetProcess()->GetBrowserContext());
-    ExtensionService* service =
-        extensions::ExtensionSystem::Get(profile)->extension_service();
-    if (!service)
-      return true;
-    const Extension* extension =
-        service->extensions()->GetExtensionOrAppByURL(url);
-    if (!extension)
-      return true;
-    const Extension* from_extension =
-        service->extensions()->GetExtensionOrAppByURL(
-            site_instance->GetSiteURL());
-    if (from_extension && from_extension->id() == extension->id())
-      return true;
 
-    if (!extensions::WebAccessibleResourcesInfo::IsResourceWebAccessible(
-            extension, url.path()))
-      return false;
-  }
+  bool result;
+  if (ChromeContentBrowserClientExtensionsPart::ShouldAllowOpenURL(
+      site_instance, from_url, url, &result))
+    return result;
 
   // Do not allow chrome://chrome-signin navigate to other chrome:// URLs, since
   // the signin page may host untrusted web content.
   if (from_url.GetOrigin().spec() == chrome::kChromeUIChromeSigninURL &&
       url.SchemeIs(content::kChromeUIScheme) &&
       url.host() != chrome::kChromeUIChromeSigninHost) {
     VLOG(1) << "Blocked navigation to " << url.spec() << " from "
             << chrome::kChromeUIChromeSigninURL;
     return false;
   }
@@ skipping 24 matching lines @@
       return is_instant_process && should_be_in_instant_process;
   }
 
 #if !defined(OS_CHROMEOS)
   SigninClient* signin_client =
       ChromeSigninClientFactory::GetForProfile(profile);
   if (signin_client && signin_client->IsSigninProcess(process_host->GetID()))
     return SigninManager::IsWebBasedSigninFlowURL(site_url);
 #endif
 
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  extensions::ProcessMap* process_map = extensions::ProcessMap::Get(profile);
-
-  // These may be NULL during tests. In that case, just assume any site can
-  // share any host.
-  if (!service || !process_map)
-    return true;
-
-  // Otherwise, just make sure the process privilege matches the privilege
-  // required by the site.
-  RenderProcessHostPrivilege privilege_required =
-      GetPrivilegeRequiredByUrl(site_url, service);
-  return GetProcessPrivilege(process_host, process_map, service) ==
-      privilege_required;
+  return ChromeContentBrowserClientExtensionsPart::IsSuitableHost(
+      profile, process_host, site_url);
 }
 
 bool ChromeContentBrowserClient::MayReuseHost(
     content::RenderProcessHost* process_host) {
   // If there is currently a prerender in progress for the host provided,
   // it may not be shared. We require prerenders to be by themselves in a
   // separate process, so that we can monitor their resource usage, and so that
   // we can track the cookies that they change.
   Profile* profile = Profile::FromBrowserContext(
       process_host->GetBrowserContext());
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(profile);
   if (prerender_manager &&
       !prerender_manager->MayReuseProcessHost(process_host)) {
     return false;
   }
 
   return true;
 }
 
-// This function is trying to limit the amount of processes used by extensions
-// with background pages. It uses a globally set percentage of processes to
-// run such extensions and if the limit is exceeded, it returns true, to
-// indicate to the content module to group extensions together.
 bool ChromeContentBrowserClient::ShouldTryToUseExistingProcessHost(
     content::BrowserContext* browser_context, const GURL& url) {
   // It has to be a valid URL for us to check for an extension.
   if (!url.is_valid())
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  ExtensionService* service = !profile ? NULL :
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (!service)
-    return false;
-
-  // We have to have a valid extension with background page to proceed.
-  const Extension* extension =
-      service->extensions()->GetExtensionOrAppByURL(url);
-  if (!extension)
-    return false;
-  if (!extensions::BackgroundInfo::HasBackgroundPage(extension))
-    return false;
-
-  std::set<int> process_ids;
-  size_t max_process_count =
-      content::RenderProcessHost::GetMaxRendererProcessCount();
-
-  // Go through all profiles to ensure we have total count of extension
-  // processes containing background pages, otherwise one profile can
-  // starve the other.
-  std::vector<Profile*> profiles = g_browser_process->profile_manager()->
-      GetLoadedProfiles();
-  for (size_t i = 0; i < profiles.size(); ++i) {
-    extensions::ProcessManager* epm =
-        extensions::ExtensionSystem::Get(profiles[i])->process_manager();
-    for (extensions::ProcessManager::const_iterator iter =
-             epm->background_hosts().begin();
-         iter != epm->background_hosts().end(); ++iter) {
-      const extensions::ExtensionHost* host = *iter;
-      process_ids.insert(host->render_process_host()->GetID());
-    }
-  }
-
-  if (process_ids.size() >
-      (max_process_count * chrome::kMaxShareOfExtensionProcesses)) {
-    return true;
-  }
-
-  return false;
+  return ChromeContentBrowserClientExtensionsPart::
+      ShouldTryToUseExistingProcessHost(
+          profile, url);
 }
 
 void ChromeContentBrowserClient::SiteInstanceGotProcess(
     SiteInstance* site_instance) {
   CHECK(site_instance->HasProcess());
 
   Profile* profile = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
   if (!profile)
     return;
@@ skipping 10 matching lines @@
 
 #if !defined(OS_CHROMEOS)
   // We only expect there to be one signin process as we use process-per-site
   // for signin URLs. The signin process will be cleared from SigninManager
   // when the renderer is destroyed.
   if (SigninManager::IsWebBasedSigninFlowURL(site_instance->GetSiteURL())) {
     SigninClient* signin_client =
         ChromeSigninClientFactory::GetForProfile(profile);
     if (signin_client)
       signin_client->SetSigninProcess(site_instance->GetProcess()->GetID());
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&InfoMap::SetSigninProcess,
-                   extensions::ExtensionSystem::Get(profile)->info_map(),
-                   site_instance->GetProcess()->GetID()));
+    ChromeContentBrowserClientExtensionsPart::SetSigninProcess(site_instance);
   }
 #endif
 
   for (size_t i = 0; i < extra_parts_.size(); ++i)
     extra_parts_[i]->SiteInstanceGotProcess(site_instance);
 }
 
 void ChromeContentBrowserClient::SiteInstanceDeleting(
     SiteInstance* site_instance) {
   if (!site_instance->HasProcess())
@@ skipping 14 matching lines @@
     SiteInstance* site_instance,
     int worker_process_id) {
   for (size_t i = 0; i < extra_parts_.size(); ++i)
     extra_parts_[i]->WorkerProcessTerminated(site_instance, worker_process_id);
 }
 
 bool ChromeContentBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
     SiteInstance* site_instance,
     const GURL& current_url,
     const GURL& new_url) {
-  // If we don't have an ExtensionService, then rely on the SiteInstance logic
-  // in RenderFrameHostManager to decide when to swap.
-  Profile* profile =
-      Profile::FromBrowserContext(site_instance->GetBrowserContext());
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  if (!service)
-    return false;
-
-  // We must use a new BrowsingInstance (forcing a process swap and disabling
-  // scripting by existing tabs) if one of the URLs is an extension and the
-  // other is not the exact same extension.
-  //
-  // We ignore hosted apps here so that other tabs in their BrowsingInstance can
-  // use postMessage with them.  (The exception is the Chrome Web Store, which
-  // is a hosted app that requires its own BrowsingInstance.)  Navigations
-  // to/from a hosted app will still trigger a SiteInstance swap in
-  // RenderFrameHostManager.
-  const Extension* current_extension =
-      service->extensions()->GetExtensionOrAppByURL(current_url);
-  if (current_extension &&
-      current_extension->is_hosted_app() &&
-      current_extension->id() != extension_misc::kWebStoreAppId)
-    current_extension = NULL;
-
-  const Extension* new_extension =
-      service->extensions()->GetExtensionOrAppByURL(new_url);
-  if (new_extension &&
-      new_extension->is_hosted_app() &&
-      new_extension->id() != extension_misc::kWebStoreAppId)
-    new_extension = NULL;
-
-  // First do a process check.  We should force a BrowsingInstance swap if the
-  // current process doesn't know about new_extension, even if current_extension
-  // is somehow the same as new_extension.
-  extensions::ProcessMap* process_map = extensions::ProcessMap::Get(profile);
-  if (new_extension &&
-      site_instance->HasProcess() &&
-      !process_map->Contains(
-          new_extension->id(), site_instance->GetProcess()->GetID()))
-    return true;
-
-  // Otherwise, swap BrowsingInstances if current_extension and new_extension
-  // differ.
-  return current_extension != new_extension;
+  return ChromeContentBrowserClientExtensionsPart::
+      ShouldSwapBrowsingInstancesForNavigation(
+          site_instance, current_url, new_url);
 }
 
 bool ChromeContentBrowserClient::ShouldSwapProcessesForRedirect(
     content::ResourceContext* resource_context, const GURL& current_url,
     const GURL& new_url) {
 #if defined(ENABLE_EXTENSIONS)
-  ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
-  return extensions::CrossesExtensionProcessBoundary(
-      io_data->GetExtensionInfoMap()->extensions(),
-      current_url, new_url, false);
+  return ChromeContentBrowserClientExtensionsPart::
+      ShouldSwapProcessesForRedirect(resource_context, current_url, new_url);
 #else
   return false;
 #endif
 }
 
 bool ChromeContentBrowserClient::ShouldAssignSiteForURL(const GURL& url) {
   return !url.SchemeIs(chrome::kChromeNativeScheme);
 }
 
 std::string ChromeContentBrowserClient::GetCanonicalEncodingNameByAliasName(
@@ skipping 929 matching lines @@
   }
 #endif
 
   return true;
 }
 
 std::string ChromeContentBrowserClient::GetWorkerProcessTitle(
     const GURL& url, content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 #if defined(ENABLE_EXTENSIONS)
-  // Check if it's an extension-created worker, in which case we want to use
-  // the name of the extension.
-  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
-  const Extension* extension =
-      io_data->GetExtensionInfoMap()->extensions().GetByID(url.host());
-  return extension ? extension->name() : std::string();
+  return ChromeContentBrowserClientExtensionsPart::GetWorkerProcessTitle(
+      url, context);
 #else
   return std::string();
 #endif
 }
 
 void ChromeContentBrowserClient::ResourceDispatcherHostCreated() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prerender_tracker_ = g_browser_process->prerender_tracker();
   return g_browser_process->ResourceDispatcherHostCreated();
 }
@@ skipping 527 matching lines @@
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome