Remove ExtensionURLInfo, make security decisions in render process

chrome/renderer/chrome_content_renderer_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/renderer/chrome_content_renderer_client.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
@@ skipping 600 matching lines @@
               manifest_url = url;
               app_url = frame->top()->document().url();
             } else {
               // NaCl is being invoked as a content handler. Look up the NaCl
               // module using the MIME type. The app URL is the manifest URL.
               manifest_url = GetNaClContentHandlerURL(actual_mime_type, plugin);
               app_url = manifest_url;
             }
             const Extension* extension =
                 g_current_client->extension_dispatcher_->extensions()->
-                    GetExtensionOrAppByURL(ExtensionURLInfo(manifest_url));
+                    GetExtensionOrAppByURL(manifest_url);
             if (!IsNaClAllowed(manifest_url,
                                app_url,
                                is_nacl_unrestricted,
                                extension,
                                &params)) {
               frame->addMessageToConsole(
                   WebConsoleMessage(
                       WebConsoleMessage::LevelError,
                       "Only unpacked extensions and apps installed from the "
                       "Chrome Web Store can load NaCl modules without enabling "
@@ skipping 222 matching lines @@
     const WebKit::WebURLRequest& failed_request,
     const WebKit::WebURLError& error,
     std::string* error_html,
     string16* error_description) {
   const GURL failed_url = error.unreachableURL;
   const Extension* extension = NULL;
 
   if (failed_url.is_valid() &&
       !failed_url.SchemeIs(extensions::kExtensionScheme)) {
     extension = extension_dispatcher_->extensions()->GetExtensionOrAppByURL(
-        ExtensionURLInfo(failed_url));
+        failed_url);
   }
 
   bool is_post = EqualsASCII(failed_request.httpMethod(), "POST");
 
   if (error_html) {
     // Use a local error page.
     int resource_id;
     base::DictionaryValue error_strings;
     if (extension && !extension->from_bookmark()) {
       LocalizedError::GetAppErrorStrings(error, failed_url, extension,
@@ skipping 78 matching lines @@
   // to swap in the prerendered page on the browser process. If the prerendered
   // page no longer exists by the time the OpenURL IPC is handled, a normal
   // navigation is attempted.
   if (prerender_dispatcher_.get() && prerender_dispatcher_->IsPrerenderURL(url))
     return true;
 
   const ExtensionSet* extensions = extension_dispatcher_->extensions();
 
   // Determine if the new URL is an extension (excluding bookmark apps).
   const Extension* new_url_extension = extensions::GetNonBookmarkAppExtension(
-      *extensions, ExtensionURLInfo(url));
+      *extensions, url);
   bool is_extension_url = !!new_url_extension;
 
   // If the navigation would cross an app extent boundary, we also need
   // to defer to the browser to ensure process isolation.  This is not necessary
   // for server redirects, which will be transferred to a new process by the
   // browser process when they are ready to commit.  It is necessary for client
   // redirects, which won't be transferred in the same way.
   if (!is_server_redirect &&
       CrossesExtensionExtents(frame, url, *extensions, is_extension_url,
           is_initial_navigation)) {
     // Include the referrer in this case since we're going from a hosted web
     // page. (the packaged case is handled previously by the extension
     // navigation test)
     *send_referrer = true;
 
     const Extension* extension =
-        extension_dispatcher_->extensions()->GetExtensionOrAppByURL(
-            ExtensionURLInfo(url));
+        extension_dispatcher_->extensions()->GetExtensionOrAppByURL(url);
     if (extension && extension->is_app()) {
       UMA_HISTOGRAM_ENUMERATION(
           extension->is_platform_app() ?
           extension_misc::kPlatformAppLaunchHistogram :
           extension_misc::kAppLaunchHistogram,
           extension_misc::APP_LAUNCH_CONTENT_NAVIGATION,
           extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
     }
     return true;
   }
@@ skipping 140 matching lines @@
     bool is_initial_navigation) {
   GURL old_url(frame->top()->document().url());
 
   // If old_url is still empty and this is an initial navigation, then this is
   // a window.open operation.  We should look at the opener URL.
   if (is_initial_navigation && old_url.is_empty() && frame->opener()) {
     // If we're about to open a normal web page from a same-origin opener stuck
     // in an extension process, we want to keep it in process to allow the
     // opener to script it.
     WebDocument opener_document = frame->opener()->document();
-    GURL opener_url = opener_document.url();
-    WebSecurityOrigin opener_origin = opener_document.securityOrigin();
-    bool opener_is_extension_url = !!extensions.GetExtensionOrAppByURL(
-        ExtensionURLInfo(opener_origin, opener_url));
     WebSecurityOrigin opener = frame->opener()->document().securityOrigin();
+    bool opener_is_extension_url =
+        !opener.isUnique() && extensions.GetExtensionOrAppByURL(

[not at google - send to devlin, 2013/07/15 22:09:12]

not totally sure why the isUnique check is needed here, but it does seem like
this condition should be folded into the expression below, because either way
isUnique has nothing to do about whether the opener is an extension URL.

+            opener_document.url()) != NULL;
     if (!is_extension_url &&
         !opener_is_extension_url &&
         extension_dispatcher_->is_extension_process() &&
         opener.canRequest(WebURL(new_url)))
       return false;
 
     // In all other cases, we want to compare against the top frame's URL (as
     // opposed to the opener frame's), since that's what determines the type of
     // process.  This allows iframes outside an app to open a popup in the app.
     old_url = frame->top()->opener()->top()->document().url();
   }
 
   // Only consider keeping non-app URLs in an app process if this window
   // has an opener (in which case it might be an OAuth popup that tries to
   // script an iframe within the app).
   bool should_consider_workaround = !!frame->opener();
 
   return extensions::CrossesExtensionProcessBoundary(
-      extensions, ExtensionURLInfo(old_url), ExtensionURLInfo(new_url),
-      should_consider_workaround);
+      extensions, old_url, new_url, should_consider_workaround);
 }
 
 void ChromeContentRendererClient::SetSpellcheck(SpellCheck* spellcheck) {
   RenderThread* thread = RenderThread::Get();
   if (spellcheck_.get() && thread)
     thread->RemoveObserver(spellcheck_.get());
   spellcheck_.reset(spellcheck);
   SpellCheckReplacer replacer(spellcheck_.get());
   content::RenderView::ForEach(&replacer);
   if (thread)
@@ skipping 101 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePepperTesting)) {
     return true;
   }
 #endif  // !defined(OS_ANDROID)
   return false;
 }
 
 
 }  // namespace chrome