Create thread-safe RendererExtensionRegistry from ExtensionSet

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/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 108 matching lines @@
 #include "extensions/common/extension_set.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/switches.h"
 #include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/extension_frame_helper.h"
 #include "extensions/renderer/extension_helper.h"
 #include "extensions/renderer/extensions_render_frame_observer.h"
 #include "extensions/renderer/guest_view/extensions_guest_view_container.h"
 #include "extensions/renderer/guest_view/extensions_guest_view_container_dispatcher.h"
 #include "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.h"
+#include "extensions/renderer/renderer_extension_registry.h"
 #include "extensions/renderer/script_context.h"
 #endif
 
 #if defined(ENABLE_IPC_FUZZER)
 #include "chrome/common/external_ipc_dumper.h"
 #endif
 
 #if defined(ENABLE_PLUGINS)
 #include "chrome/renderer/plugins/chrome_plugin_placeholder.h"
 #endif
@@ skipping 470 matching lines @@
 }
 
 #if defined(ENABLE_EXTENSIONS)
 const Extension* ChromeContentRendererClient::GetExtensionByOrigin(
     const WebSecurityOrigin& origin) const {
   if (!base::EqualsASCII(base::StringPiece16(origin.protocol()),
                          extensions::kExtensionScheme))
     return NULL;
 
   const std::string extension_id = origin.host().utf8().data();
-  return extension_dispatcher_->extensions()->GetByID(extension_id);
+  return extensions::RendererExtensionRegistry::Get()->GetByID(extension_id);
 }
 #endif
 
 scoped_ptr<blink::WebPluginPlaceholder>
 ChromeContentRendererClient::CreatePluginPlaceholder(
     content::RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const blink::WebPluginParams& orig_params) {
   return CreateShadowDOMPlaceholderForPluginInfo(
       render_frame, frame, orig_params);
@@ skipping 174 matching lines @@
             // Normal NaCl/PNaCl embed. The app URL is the page URL.
             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, info);
             app_url = manifest_url;
           }
           const Extension* extension =
-              g_current_client->extension_dispatcher_->extensions()->
-                  GetExtensionOrAppByURL(manifest_url);
+              extensions::RendererExtensionRegistry::Get()
+                  ->GetExtensionOrAppByURL(manifest_url);
           if (!IsNaClAllowed(manifest_url,
                              app_url,
                              is_nacl_unrestricted,
                              extension,
                              &params)) {
             WebString error_message;
             if (is_nacl_mime_type) {
               error_message =
                   "Only unpacked extensions and apps installed from the Chrome "
                   "Web Store can load NaCl modules without enabling Native "
@@ skipping 401 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)) {
     *send_referrer = true;
     return true;
   }
 
 #if defined(ENABLE_EXTENSIONS)
-  const extensions::ExtensionSet* extensions =
-      extension_dispatcher_->extensions();
+  const extensions::RendererExtensionRegistry* extension_registry =
+      extensions::RendererExtensionRegistry::Get();
 
   // Determine if the new URL is an extension (excluding bookmark apps).
   const Extension* new_url_extension = extensions::GetNonBookmarkAppExtension(
-      *extensions, url);
+      *extension_registry->GetMainThreadExtensionSet(), 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)) {
+      CrossesExtensionExtents(frame, url, 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(url);
+        extension_registry->GetExtensionOrAppByURL(url);
     if (extension && extension->is_app()) {
       extensions::RecordAppLaunchType(
           extension_misc::APP_LAUNCH_CONTENT_NAVIGATION, extension->GetType());
     }
     return true;
   }
 
   // If this is a reload, check whether it has the wrong process type.  We
   // should send it to the browser if it's an extension URL (e.g., hosted app)
   // in a normal process, or if it's a process for an extension that has been
@@ skipping 13 matching lines @@
 bool ChromeContentRendererClient::WillSendRequest(
     blink::WebFrame* frame,
     ui::PageTransition transition_type,
     const GURL& url,
     const GURL& first_party_for_cookies,
     GURL* new_url) {
   // Check whether the request should be allowed. If not allowed, we reset the
   // URL to something invalid to prevent the request and cause an error.
 #if defined(ENABLE_EXTENSIONS)
   if (url.SchemeIs(extensions::kExtensionScheme) &&
-      !extensions::ResourceRequestPolicy::CanRequestResource(
-          url,
-          frame,
-          transition_type,
-          extension_dispatcher_->extensions())) {
+      !extensions::ResourceRequestPolicy::CanRequestResource(url, frame,
+                                                             transition_type)) {
     *new_url = GURL(chrome::kExtensionInvalidRequestURL);
     return true;
   }
 
   if (url.SchemeIs(extensions::kExtensionResourceScheme) &&
       !extensions::ResourceRequestPolicy::CanRequestExtensionResourceScheme(
           url,
           frame)) {
     *new_url = GURL(chrome::kExtensionResourceInvalidRequestURL);
     return true;
@@ skipping 56 matching lines @@
 }
 
 extensions::Dispatcher*
 ChromeContentRendererClient::GetExtensionDispatcherForTest() {
   return extension_dispatcher_.get();
 }
 
 bool ChromeContentRendererClient::CrossesExtensionExtents(
     blink::WebLocalFrame* frame,
     const GURL& new_url,
-    const extensions::ExtensionSet& extensions,
     bool is_extension_url,
     bool is_initial_navigation) {
   DCHECK(!frame->parent());
   GURL old_url(frame->document().url());
 
+  extensions::RendererExtensionRegistry* extension_registry =
+      extensions::RendererExtensionRegistry::Get();
+
   // 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.  Note that the
   // opener is a local frame in this case.
   if (is_initial_navigation && old_url.is_empty() && frame->opener()) {
     WebLocalFrame* opener_frame = frame->opener()->toWebLocalFrame();
 
     // 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 = opener_frame->document();
     WebSecurityOrigin opener_origin = opener_document.securityOrigin();
-    bool opener_is_extension_url =
-        !opener_origin.isUnique() && extensions.GetExtensionOrAppByURL(
-            opener_document.url()) != NULL;
+    bool opener_is_extension_url = !opener_origin.isUnique() &&
+                                   extension_registry->GetExtensionOrAppByURL(
+                                       opener_document.url()) != NULL;
     if (!is_extension_url &&
         !opener_is_extension_url &&
         IsStandaloneExtensionProcess() &&
         opener_origin.canRequest(WebURL(new_url)))
       return false;
 
     // In all other cases, we want to compare against the URL that determines
     // the type of process.  In default Chrome, that's the URL of the opener's
     // top frame and not the opener frame itself.  In --site-per-process, we
     // can use the opener frame itself.
     // TODO(nick): Either wire this up to SiteIsolationPolicy, or to state on
     // |opener_frame|/its ancestors.
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kSitePerProcess))
       old_url = opener_frame->document().url();
     else
       old_url = opener_frame->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, old_url, new_url, should_consider_workaround);
+      *extension_registry->GetMainThreadExtensionSet(), old_url, new_url,
+      should_consider_workaround);
 }
 #endif  // defined(ENABLE_EXTENSIONS)
 
 #if defined(ENABLE_SPELLCHECK)
 void ChromeContentRendererClient::SetSpellcheck(SpellCheck* spellcheck) {
   RenderThread* thread = RenderThread::Get();
   if (spellcheck_.get() && thread)
     thread->RemoveObserver(spellcheck_.get());
   spellcheck_.reset(spellcheck);
   SpellCheckReplacer replacer(spellcheck_.get());
@@ skipping 27 matching lines @@
   // TODO(bbudge) remove this when the trusted NaCl plugin has been removed.
   // We must defer certain plugin events for NaCl instances since we switch
   // from the in-process to the out-of-process proxy after instantiating them.
   return module_name == "Native Client";
 }
 
 #if defined(ENABLE_PLUGINS) && defined(ENABLE_EXTENSIONS)
 bool ChromeContentRendererClient::IsExtensionOrSharedModuleWhitelisted(
     const GURL& url, const std::set<std::string>& whitelist) {
   const extensions::ExtensionSet* extension_set =
-      g_current_client->extension_dispatcher_->extensions();
+      extensions::RendererExtensionRegistry::Get()->GetMainThreadExtensionSet();
   return chrome::IsExtensionOrSharedModuleWhitelisted(url, extension_set,
       whitelist);
 }
 #endif
 
 blink::WebSpeechSynthesizer*
 ChromeContentRendererClient::OverrideSpeechSynthesizer(
     blink::WebSpeechSynthesizerClient* client) {
   return new TtsDispatcher(client);
 }
@@ skipping 159 matching lines @@
 
 void
 ChromeContentRendererClient::DidInitializeServiceWorkerContextOnWorkerThread(
     v8::Local<v8::Context> context,
     const GURL& url) {
 #if defined(ENABLE_EXTENSIONS)
   extensions::Dispatcher::DidInitializeServiceWorkerContextOnWorkerThread(
       context, url);
 #endif
 }