Hosted apps VS --site-per-process.

chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc

 // Copyright 2014 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/chrome_content_browser_client_extensions_part.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 70 matching lines @@
 namespace extensions {
 
 namespace {
 
 // 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,
 };
 
 // Specifies the scheme of the SiteInstance responsible for a failed
 // web-accessible resource check in ShouldAllowOpenURL.
 //
 // This enum backs an UMA histogram.  The order of existing values
 // should not be changed.  Add any new values before SCHEME_LAST, and also run
 // update_should_allow_open_url_histograms.py to update the corresponding enum
@@ skipping 38 matching lines @@
     return PRIV_NORMAL;
 
   if (!url.SchemeIs(kExtensionScheme))
     return PRIV_NORMAL;
 
   const Extension* extension =
       registry->enabled_extensions().GetByID(url.host());
   if (extension && AppIsolationInfo::HasIsolatedStorage(extension))
     return PRIV_ISOLATED;
   if (extension && extension->is_hosted_app())
-    return PRIV_HOSTED;
+    return PRIV_NORMAL;
   return PRIV_EXTENSION;
 }
 
 RenderProcessHostPrivilege GetProcessPrivilege(
     content::RenderProcessHost* process_host,
     ProcessMap* process_map,
     ExtensionRegistry* registry) {
   std::set<std::string> extension_ids =
       process_map->GetExtensionsInProcess(process_host->GetID());
   if (extension_ids.empty())
     return PRIV_NORMAL;
 
   for (const std::string& extension_id : extension_ids) {
     const Extension* extension =
         registry->enabled_extensions().GetByID(extension_id);
     if (extension && AppIsolationInfo::HasIsolatedStorage(extension))
       return PRIV_ISOLATED;
     if (extension && extension->is_hosted_app())
-      return PRIV_HOSTED;
+      return PRIV_NORMAL;
   }
 
   return PRIV_EXTENSION;
 }
 
 // Determines whether the extension |origin| is legal to use in an Origin header
 // from the process identified by |child_id|.  Returns CONTINUE if so, FAIL if
 // the extension is not recognized (and may recently have been uninstalled), and
 // KILL if the origin is from a platform app but the request does not come from
 // that app.
@@ skipping 75 matching lines @@
 
 ChromeContentBrowserClientExtensionsPart::
     ChromeContentBrowserClientExtensionsPart() {
 }
 
 ChromeContentBrowserClientExtensionsPart::
     ~ChromeContentBrowserClientExtensionsPart() {
 }
 
 // static
-GURL ChromeContentBrowserClientExtensionsPart::GetEffectiveURL(
-    Profile* profile, const GURL& url) {
-  // 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.
-  ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
-  if (!registry)
-    return url;
-
-  const Extension* extension =
-      registry->enabled_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());
-}
-
-// static
 bool ChromeContentBrowserClientExtensionsPart::ShouldUseProcessPerSite(
     Profile* profile, const GURL& effective_url) {
   if (!effective_url.SchemeIs(kExtensionScheme))
     return false;
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
   if (!registry)
     return false;
 
   const Extension* extension =
@@ skipping 110 matching lines @@
 
   // These may be NULL during tests. In that case, just assume any site can
   // share any host.
   if (!registry || !process_map)
     return true;
 
   // Otherwise, just make sure the process privilege matches the privilege
   // required by the site.
   RenderProcessHostPrivilege privilege_required =
       GetPrivilegeRequiredByUrl(site_url, registry);
-  return GetProcessPrivilege(process_host, process_map, registry) ==
-         privilege_required;
+  RenderProcessHostPrivilege privilege_of_process =
+      GetProcessPrivilege(process_host, process_map, registry);
+  return privilege_of_process == privilege_required;
 }
 
 // static
 bool
 ChromeContentBrowserClientExtensionsPart::ShouldTryToUseExistingProcessHost(
     Profile* profile, const GURL& url) {
   // 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.
@@ skipping 452 matching lines @@
     command_line->AppendSwitch(switches::kExtensionProcess);
   }
 }
 
 void ChromeContentBrowserClientExtensionsPart::ResourceDispatcherHostCreated() {
   content::ResourceDispatcherHost::Get()->RegisterInterceptor(
       "Origin", kExtensionScheme, base::Bind(&OnHttpHeaderReceived));
 }
 
 }  // namespace extensions