Refactor away most of ExtensionRendererInfo

chrome/renderer/render_view.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/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 369 matching lines @@
 
   return false;
 }
 
 // Returns true if the frame is navigating to an URL either into or out of an
 // extension app's extent.
 // TODO(creis): Temporary workaround for crbug.com/65953: Only return true if
 // we would enter an extension app's extent from a non-app.  We avoid swapping
 // processes to exit an app for now, since we do not yet restore context (such
 // as window.opener) if the window navigates back.
-static bool CrossesIntoExtensionExtent(WebFrame* frame, const GURL& new_url) {
+static bool CrossesIntoExtensionExtent(const ExtensionRendererInfo* extensions,
+                                       WebFrame* frame,
+                                       const GURL& new_url) {
   // If the URL is still empty, this is a window.open navigation. Check the
   // opener's URL.
   GURL old_url(frame->url());
   if (old_url.is_empty() && frame->opener())
     old_url = frame->opener()->url();
 
-  return !ExtensionRendererInfo::InSameExtent(old_url, new_url) &&
-         !ExtensionRendererInfo::GetByURL(old_url);
+  return !extensions->InSameExtent(old_url, new_url) &&
+         !extensions->GetByURL(old_url);
 }
 
 // Returns the ISO 639_1 language code of the specified |text|, or 'unknown'
 // if it failed.
 static std::string DetermineTextLanguage(const string16& text) {
   std::string language = chrome::kUnknownLanguageCode;
   int num_languages = 0;
   int text_bytes = 0;
   bool is_reliable = false;
   Language cld_language =
@@ skipping 1471 matching lines @@
 
 // WebViewDelegate ------------------------------------------------------------
 
 void RenderView::LoadNavigationErrorPage(WebFrame* frame,
                                          const WebURLRequest& failed_request,
                                          const WebURLError& error,
                                          const std::string& html,
                                          bool replace) {
   GURL failed_url = error.unreachableURL;
   std::string alt_html;
-  ExtensionRendererInfo* extension = NULL;
+  const Extension* extension = NULL;
   if (html.empty()) {
     // Use a local error page.
     int resource_id;
     DictionaryValue error_strings;
 
     if (failed_url.is_valid() && !failed_url.SchemeIs(chrome::kExtensionScheme))
-      extension = ExtensionRendererInfo::GetByURL(failed_url);
+      extension = render_thread_->GetExtensions()->GetByURL(failed_url);
     if (extension) {
       LocalizedError::GetAppErrorStrings(error, failed_url, extension,
                                          &error_strings);
 
       // TODO(erikkay): Should we use a different template for different
       // error messages?
       resource_id = IDR_ERROR_APP_HTML;
     } else {
       if (error.domain == WebString::fromUTF8(net::kErrorDomain) &&
           error.reason == net::ERR_CACHE_MISS &&
@@ skipping 710 matching lines @@
 void RenderView::show(WebNavigationPolicy policy) {
   DCHECK(!did_show_) << "received extraneous Show call";
   DCHECK(opener_id_ != MSG_ROUTING_NONE);
 
   if (did_show_)
     return;
   did_show_ = true;
 
   // Extensions and apps always allowed to create unrequested popups. The second
   // check is necessary to include content scripts.
-  if (ExtensionRendererInfo::GetByURL(creator_url_) ||
+  if (render_thread_->GetExtensions()->GetByURL(creator_url_) ||
       bindings_utils::GetInfoForCurrentContext()) {
     opened_by_user_gesture_ = true;
   }
 
   // Force new windows to a popup if they were not opened with a user gesture.
   if (!opened_by_user_gesture_) {
     // We exempt background tabs for compat with older versions of Chrome.
     // TODO(darin): This seems bogus.  These should have a user gesture, so
     // we probably don't need this check.
     if (policy != WebKit::WebNavigationPolicyNewBackgroundTab)
@@ skipping 317 matching lines @@
         url.SchemeIs(chrome::kViewSourceScheme);
 
     // If the navigation would cross an app extent boundary, we also need
     // to defer to the browser to ensure process isolation.
     // TODO(erikkay) This is happening inside of a check to is_content_initiated
     // which means that things like the back button won't trigger it.  Is that
     // OK?
     // TODO(creis): For now, we only swap processes to enter an app and not
     // exit it, since we currently lose context (e.g., window.opener) if the
     // window navigates back.  See crbug.com/65953.
-    if (!should_fork && CrossesIntoExtensionExtent(frame, url)) {
+    if (!should_fork &&
+        CrossesIntoExtensionExtent(
+            render_thread_->GetExtensions(),
+            frame,
+            url)) {
       // 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)
       should_fork = true;
       send_referrer = true;
     }
 
     if (should_fork) {
       GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
       OpenURL(url, send_referrer ? referrer : GURL(), default_policy);
@@ skipping 942 matching lines @@
     }
   }
 
   // Check for Native Client modules.
   if (mime_type == "application/x-nacl-srpc" &&
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInternalNaCl)) {
     // NaCl is only permitted when we're in an extension/application with the
     // appropriate permission, or when explicitly enabled on the command line.
 
     GURL main_frame_url(webview()->mainFrame()->url());
-    ExtensionRendererInfo* extension =
-        ExtensionRendererInfo::GetByURL(main_frame_url);
+    const Extension* extension =
+        render_thread_->GetExtensions()->GetByURL(main_frame_url);
     bool in_ext = extension != NULL;
     bool explicit_enable =
         CommandLine::ForCurrentProcess()->HasSwitch(switches::kInternalNaCl);
 
     if (in_ext) {
       // TODO(cbiffle): NaCl is back to experimental for M7.
       if (ExtensionProcessBindings::HasPermission(extension->id(),
               Extension::kExperimentalPermission)) {
         in_process_plugin = true;
         use_pepper_host = true;
@@ skipping 1447 matching lines @@
                                  const ViewMsg_ExecuteCode_Params& params) {
   std::vector<WebFrame*> frame_vector;
   frame_vector.push_back(frame);
   if (params.all_frames)
     GetAllChildFrames(frame, &frame_vector);
 
   for (std::vector<WebFrame*>::iterator frame_it = frame_vector.begin();
        frame_it != frame_vector.end(); ++frame_it) {
     WebFrame* frame = *frame_it;
     if (params.is_javascript) {
-      ExtensionRendererInfo* extension =
-          ExtensionRendererInfo::GetByID(params.extension_id);
+      const Extension* extension =
+          render_thread_->GetExtensions()->GetByID(params.extension_id);
 
     // Since extension info is sent separately from user script info, they can
     // be out of sync. We just ignore this situation.
     if (!extension)
       continue;
 
-      const std::vector<URLPattern> host_permissions =
-          extension->host_permissions();
-      if (!Extension::CanExecuteScriptOnPage(
-              frame->url(),
-              extension->allowed_to_execute_script_everywhere(),
-              &host_permissions,
-              NULL,
-              NULL)) {
+      if (!extension->CanExecuteScriptOnPage(frame->url(), NULL, NULL))
         continue;
-      }
 
       std::vector<WebScriptSource> sources;
       sources.push_back(
           WebScriptSource(WebString::fromUTF8(params.code)));
       UserScriptSlave::InsertInitExtensionCode(&sources, params.extension_id);
       frame->executeScriptInIsolatedWorld(
           UserScriptSlave::GetIsolatedWorldId(params.extension_id),
           &sources.front(), sources.size(), EXTENSION_GROUP_CONTENT_SCRIPTS);
     } else {
       frame->insertStyleText(WebString::fromUTF8(params.code), WebString());
@@ skipping 321 matching lines @@
   if (cmd == kJavaScriptStressTestSetStressRunType) {
     v8::Testing::SetStressRunType(static_cast<v8::Testing::StressType>(param));
   } else if (cmd == kJavaScriptStressTestPrepareStressRun) {
     v8::Testing::PrepareStressRun(param);
   }
 }
 
 void RenderView::OnContextMenuClosed() {
   context_menu_node_.reset();
 }