Remove ExtensionURLInfo, make security decisions in render process

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 622 matching lines @@
     // attribute because this code path is run during Extension uninstall
     // to do cleanup after the Extension has already been unloaded from the
     // ExtensionService.
     bool is_isolated = !can_be_default;
     if (can_be_default) {
       const Extension* extension = NULL;
       Profile* profile = Profile::FromBrowserContext(browser_context);
       ExtensionService* extension_service =
           extensions::ExtensionSystem::Get(profile)->extension_service();
       if (extension_service) {
-        extension = extension_service->extensions()->
-            GetExtensionOrAppByURL(ExtensionURLInfo(site));
+        extension =
+            extension_service->extensions()->GetExtensionOrAppByURL(site);
         if (extension &&
             extensions::AppIsolationInfo::HasIsolatedStorage(extension)) {
           is_isolated = true;
         }
       }
     }
 
     if (is_isolated) {
       CHECK(site.has_host());
       // For extensions with isolated storage, the the host of the |site| is
@@ skipping 29 matching lines @@
     WebContents* guest_web_contents,
     WebContents* embedder_web_contents,
     int browser_plugin_instance_id) {
   Profile* profile = Profile::FromBrowserContext(
       embedder_web_contents->GetBrowserContext());
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
   const GURL& url = embedder_web_contents->GetSiteInstance()->GetSiteURL();
-  const Extension* extension = service->extensions()->
-      GetExtensionOrAppByURL(ExtensionURLInfo(url));
+  const Extension* extension =
+      service->extensions()->GetExtensionOrAppByURL(url);
   if (!extension)
     return;
   std::vector<ExtensionMsg_Loaded_Params> extensions;
   extensions.push_back(ExtensionMsg_Loaded_Params(extension));
   guest_web_contents->Send(new ExtensionMsg_Loaded(extensions));
   new WebViewGuest(guest_web_contents,
                    embedder_web_contents,
                    extension->id(),
                    browser_plugin_instance_id);
 }
@@ skipping 89 matching lines @@
 
   // 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(ExtensionURLInfo(url));
+      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.
@@ skipping 20 matching lines @@
 #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(ExtensionURLInfo(effective_url));
+  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->HasAPIPermission(APIPermission::kBackground) ||
         !extensions::BackgroundInfo::AllowJSAccess(extension)) {
@@ skipping 44 matching lines @@
   // 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(ExtensionURLInfo(url));
+      service->extensions()->GetExtensionOrAppByURL(url);
   if (new_extension &&
       new_extension->is_hosted_app() &&
       new_extension->id() == extension_misc::kWebStoreAppId &&
       !service->process_map()->Contains(new_extension->id(),
                                         process_host->GetID())) {
     return false;
   }
 
   return true;
 }
@@ skipping 63 matching lines @@
     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(ExtensionURLInfo(url));
+      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
@@ skipping 54 matching lines @@
                    extensions::ExtensionSystem::Get(profile)->info_map(),
                    site_instance->GetProcess()->GetID()));
   }
 #endif
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
 
-  const Extension* extension =
-      service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(
-          site_instance->GetSiteURL()));
+  const Extension* extension = service->extensions()->GetExtensionOrAppByURL(
+      site_instance->GetSiteURL());
   if (!extension)
     return;
 
   service->process_map()->Insert(extension->id(),
                                  site_instance->GetProcess()->GetID(),
                                  site_instance->GetId());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ExtensionInfoMap::RegisterExtensionProcess,
                  extensions::ExtensionSystem::Get(profile)->info_map(),
                  extension->id(),
                  site_instance->GetProcess()->GetID(),
                  site_instance->GetId()));
 }
 
 void ChromeContentBrowserClient::SiteInstanceDeleting(
     SiteInstance* site_instance) {
   if (!site_instance->HasProcess())
     return;
 
   Profile* profile = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
 
-  const Extension* extension =
-      service->extensions()->GetExtensionOrAppByURL(
-          ExtensionURLInfo(site_instance->GetSiteURL()));
+  const Extension* extension = service->extensions()->GetExtensionOrAppByURL(
+      site_instance->GetSiteURL());
   if (!extension)
     return;
 
   service->process_map()->Remove(extension->id(),
                                  site_instance->GetProcess()->GetID(),
                                  site_instance->GetId());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ExtensionInfoMap::UnregisterExtensionProcess,
                  extensions::ExtensionSystem::Get(profile)->info_map(),
@@ skipping 29 matching lines @@
   Profile* profile =
       Profile::FromBrowserContext(site_instance->GetBrowserContext());
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return false;
 
   // We must swap if the URL is for an extension and we are not using an
   // extension process.
   const Extension* new_extension =
-      service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(new_url));
+      service->extensions()->GetExtensionOrAppByURL(new_url);
   // Ignore all hosted apps except the Chrome Web Store, since they do not
   // require their own BrowsingInstance (e.g., postMessage is ok).
   if (new_extension &&
       new_extension->is_hosted_app() &&
       new_extension->id() != extension_misc::kWebStoreAppId)
     new_extension = NULL;
   if (new_extension &&
       site_instance->HasProcess() &&
       !service->process_map()->Contains(new_extension->id(),
                                         site_instance->GetProcess()->GetID()))
     return true;
 
   return false;
 }
 
 bool ChromeContentBrowserClient::ShouldSwapProcessesForRedirect(
     content::ResourceContext* resource_context, const GURL& current_url,
     const GURL& new_url) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   return extensions::CrossesExtensionProcessBoundary(
       io_data->GetExtensionInfoMap()->extensions(),
-      ExtensionURLInfo(current_url), ExtensionURLInfo(new_url), false);
+      current_url, new_url, false);
 }
 
 std::string ChromeContentBrowserClient::GetCanonicalEncodingNameByAliasName(
     const std::string& alias_name) {
   return CharacterEncoding::GetCanonicalEncodingNameByAliasName(alias_name);
 }
 
 void ChromeContentBrowserClient::AppendExtraCommandLineSwitches(
     CommandLine* command_line, int child_process_id) {
 #if defined(USE_LINUX_BREAKPAD)
@@ skipping 624 matching lines @@
             APIPermission::kBackground)) {
       return false;
     }
 
     // Note: this use of GetExtensionOrAppByURL is safe but imperfect.  It may
     // return a recently installed Extension even if this CanCreateWindow call
     // was made by an old copy of the page in a normal web process.  That's ok,
     // because the permission check above would have caused an early return
     // already. We must use the full URL to find hosted apps, though, and not
     // just the origin.
-    const Extension* extension = map->extensions().GetExtensionOrAppByURL(
-        ExtensionURLInfo(opener_url));
+    const Extension* extension =
+        map->extensions().GetExtensionOrAppByURL(opener_url);
     if (extension && !extensions::BackgroundInfo::AllowJSAccess(extension))
       *no_javascript_access = true;
   }
 
   // No new browser window (popup or tab) in app mode.
   if (container_type == WINDOW_CONTAINER_TYPE_NORMAL &&
       chrome::IsRunningInForcedAppMode()) {
     return false;
   }
 
@@ skipping 303 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserPluginForAllViewTypes))
     return true;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return false;
 
-  const Extension* extension = service->extensions()->
-      GetExtensionOrAppByURL(ExtensionURLInfo(site_url));
+  const Extension* extension =
+      service->extensions()->GetExtensionOrAppByURL(site_url);
   if (!extension)
     return false;
 
   return extension->HasAPIPermission(APIPermission::kWebView) ||
          extension->HasAPIPermission(APIPermission::kAdView);
 }
 
 bool ChromeContentBrowserClient::AllowPepperSocketAPI(
     content::BrowserContext* browser_context,
     const GURL& url,
@@ skipping 140 matching lines @@
 #if defined(USE_NSS)
 crypto::CryptoModuleBlockingPasswordDelegate*
     ChromeContentBrowserClient::GetCryptoPasswordDelegate(
         const GURL& url) {
   return chrome::NewCryptoModuleBlockingDialogDelegate(
       chrome::kCryptoModulePasswordKeygen, url.host());
 }
 #endif
 
 }  // namespace chrome