Consider the origin when computing extension permissions

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_interface_factory.h"
 
 using WebKit::WebCache;
 using WebKit::WebDataSource;
+using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebPlugin;
 using WebKit::WebPluginParams;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
@@ skipping 334 matching lines @@
             break;
           }
         }
         break;
       }
     }
   }
 
   // Determine if the manifest URL is part of an extension.
   const Extension* extension =
-      extension_dispatcher_->extensions()->GetByURL(manifest_url);
+      extension_dispatcher_->extensions()->GetByURL(
+          ExtensionURLInfo(manifest_url));
   // Only component, unpacked, and Chrome Web Store extensions are allowed.
   bool allowed_extension = extension &&
       (extension->from_webstore() ||
       extension->location() == Extension::COMPONENT ||
       extension->location() == Extension::LOAD);
 
   // Block any other use of NaCl plugin, unless --enable-nacl is set.
   if (!allowed_extension && !enable_nacl)
     return false;
 
@@ skipping 51 matching lines @@
     const WebKit::WebURLError& error,
     std::string* error_html,
     string16* error_description) {
   const GURL failed_url = error.unreachableURL;
   const Extension* extension = NULL;
   const bool is_repost =
       error.reason == net::ERR_CACHE_MISS &&
       error.domain == WebString::fromUTF8(net::kErrorDomain) &&
       EqualsASCII(failed_request.httpMethod(), "POST");
 
-  if (failed_url.is_valid() && !failed_url.SchemeIs(chrome::kExtensionScheme))
-    extension = extension_dispatcher_->extensions()->GetByURL(failed_url);
+  if (failed_url.is_valid() && !failed_url.SchemeIs(chrome::kExtensionScheme)) {
+    extension = extension_dispatcher_->extensions()->GetByURL(
+        ExtensionURLInfo(failed_url));
+  }
 
   if (error_html) {
     // Use a local error page.
     int resource_id;
     DictionaryValue error_strings;
     if (extension) {
       LocalizedError::GetAppErrorStrings(error, failed_url, extension,
                                          &error_strings);
 
       // TODO(erikkay): Should we use a different template for different
@@ skipping 48 matching lines @@
   if (!CrossesExtensionExtents(frame, url, is_initial_navigation))
     return false;
 
   // 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;
 
   if (is_content_initiated) {
     const Extension* extension =
-        extension_dispatcher_->extensions()->GetByURL(url);
+        extension_dispatcher_->extensions()->GetByURL(ExtensionURLInfo(url));
     if (extension && extension->is_app()) {
       UMA_HISTOGRAM_ENUMERATION(
           extension_misc::kAppLaunchHistogram,
           extension_misc::APP_LAUNCH_CONTENT_NAVIGATION,
           extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
     }
   }
 
   return true;
 }
@@ skipping 88 matching lines @@
 }
 
 void ChromeContentRendererClient::SetExtensionDispatcher(
     ExtensionDispatcher* extension_dispatcher) {
   extension_dispatcher_.reset(extension_dispatcher);
 }
 
 const Extension* ChromeContentRendererClient::GetNonBookmarkAppExtension(
     const ExtensionSet* extensions, const GURL& url) {
   // Exclude bookmark apps, which do not use the app process model.
-  const Extension* extension = extensions->GetByURL(url);
+  const Extension* extension = extensions->GetByURL(ExtensionURLInfo(url));
   if (extension && extension->from_bookmark())
     extension = NULL;
   return extension;
 }
 
 bool ChromeContentRendererClient::CrossesExtensionExtents(
     WebFrame* frame,
     const GURL& new_url,
     bool is_initial_navigation) {
   const ExtensionSet* extensions = extension_dispatcher_->extensions();
   GURL old_url(frame->top()->document().url());
 
   // Determine if the new URL is an extension (excluding bookmark apps).
   const Extension* new_url_extension = GetNonBookmarkAppExtension(extensions,
                                                                   new_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.
-    GURL opener_url = frame->opener()->document().url();
-    bool opener_is_extension_url = !!extensions->GetByURL(opener_url);
+    WebDocument opener_document = frame->opener()->document();
+    GURL opener_url = opener_document.url();
+    WebSecurityOrigin opener_origin = opener_document.securityOrigin();
+    bool opener_is_extension_url = !!extensions->GetByURL(
+        ExtensionURLInfo(opener_origin, opener_url));
     WebSecurityOrigin opener = frame->opener()->document().securityOrigin();
     if (!new_url_extension &&
         !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.
@@ skipping 50 matching lines @@
 bool ChromeContentRendererClient::IsOtherExtensionWithWebRequestInstalled() {
   return extension_dispatcher_->IsOtherExtensionWithWebRequestInstalled();
 }
 
 void ChromeContentRendererClient::RegisterPPAPIInterfaceFactories(
     webkit::ppapi::PpapiInterfaceFactoryManager* factory_manager) {
   factory_manager->RegisterFactory(ChromePPAPIInterfaceFactory);
 }
 
 }  // namespace chrome