Create thread-safe RendererExtensionRegistry from ExtensionSet

extensions/renderer/script_context_set.cc

 // Copyright 2014 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 "extensions/renderer/script_context_set.h"
 
 #include "base/message_loop/message_loop.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "extensions/common/extension.h"
 #include "extensions/renderer/extension_groups.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_injection.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 namespace {
 // There is only ever one instance of the ScriptContextSet.
 ScriptContextSet* g_context_set = nullptr;
 }
 
-ScriptContextSet::ScriptContextSet(ExtensionSet* extensions,
-                                   ExtensionIdSet* active_extension_ids)
-    : extensions_(extensions), active_extension_ids_(active_extension_ids) {
+ScriptContextSet::ScriptContextSet(ExtensionIdSet* active_extension_ids)
+    : active_extension_ids_(active_extension_ids) {
   DCHECK(!g_context_set);
   g_context_set = this;
 }
 
 ScriptContextSet::~ScriptContextSet() {
   g_context_set = nullptr;
 }
 
 ScriptContext* ScriptContextSet::Register(
     blink::WebLocalFrame* frame,
@@ skipping 101 matching lines @@
   std::string extension_id;
   if (world_id != 0) {
     // Isolated worlds (content script).
     extension_id = ScriptInjection::GetHostIdForIsolatedWorld(world_id);
   } else if (!frame->document().securityOrigin().isUnique()) {
     // TODO(kalman): Delete the above check.
     // Extension pages (chrome-extension:// URLs).
     GURL frame_url = ScriptContext::GetDataSourceURLForFrame(frame);
     frame_url = ScriptContext::GetEffectiveDocumentURL(frame, frame_url,
                                                        use_effective_url);
-    extension_id = extensions_->GetExtensionOrAppIDByURL(frame_url);
+    extension_id =
+        RendererExtensionRegistry::Get()->GetExtensionOrAppIDByURL(frame_url);
   }
 
   // There are conditions where despite a context being associated with an
   // extension, no extension actually gets found. Ignore "invalid" because CSP
   // blocks extension page loading by switching the extension ID to "invalid".
-  const Extension* extension = extensions_->GetByID(extension_id);
+  const Extension* extension =
+      RendererExtensionRegistry::Get()->GetByID(extension_id);
   if (!extension && !extension_id.empty() && extension_id != "invalid") {
     // TODO(kalman): Do something here?
   }
   return extension;
 }
 
 Feature::Context ScriptContextSet::ClassifyJavaScriptContext(
     const Extension* extension,
     int extension_group,
     const GURL& url,
     const blink::WebSecurityOrigin& origin) {
   // WARNING: This logic must match ProcessMap::GetContextType, as much as
   // possible.
 
   DCHECK_GE(extension_group, 0);
   if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
     return extension ?  // TODO(kalman): when does this happen?
                Feature::CONTENT_SCRIPT_CONTEXT
                      : Feature::UNSPECIFIED_CONTEXT;
   }
 
   // We have an explicit check for sandboxed pages before checking whether the
   // extension is active in this process because:
   // 1. Sandboxed pages run in the same process as regular extension pages, so
   //    the extension is considered active.
   // 2. ScriptContext creation (which triggers bindings injection) happens
   //    before the SecurityContext is updated with the sandbox flags (after
   //    reading the CSP header), so the caller can't check if the context's
   //    security origin is unique yet.
-  if (ScriptContext::IsSandboxedPage(*extensions_, url))
+  if (ScriptContext::IsSandboxedPage(url))
     return Feature::WEB_PAGE_CONTEXT;
 
   if (extension && active_extension_ids_->count(extension->id()) > 0) {
     // |extension| is active in this process, but it could be either a true
     // extension process or within the extent of a hosted app. In the latter
     // case this would usually be considered a (blessed) web page context,
     // unless the extension in question is a component extension, in which case
     // we cheat and call it blessed.
     return (extension->is_hosted_app() &&
             extension->location() != Manifest::COMPONENT)
                ? Feature::BLESSED_WEB_PAGE_CONTEXT
                : Feature::BLESSED_EXTENSION_CONTEXT;
   }
 
   // TODO(kalman): This isUnique() check is wrong, it should be performed as
   // part of ScriptContext::IsSandboxedPage().
-  if (!origin.isUnique() && extensions_->ExtensionBindingsAllowed(url)) {
+  if (!origin.isUnique() &&
+      RendererExtensionRegistry::Get()->ExtensionBindingsAllowed(url)) {
     if (!extension)  // TODO(kalman): when does this happen?
       return Feature::UNSPECIFIED_CONTEXT;
     return extension->is_hosted_app() ? Feature::BLESSED_WEB_PAGE_CONTEXT
                                       : Feature::UNBLESSED_EXTENSION_CONTEXT;
   }
 
   if (!url.is_valid())
     return Feature::UNSPECIFIED_CONTEXT;
 
   if (url.SchemeIs(content::kChromeUIScheme))
     return Feature::WEBUI_CONTEXT;
 
   return Feature::WEB_PAGE_CONTEXT;
 }
 
 void ScriptContextSet::DispatchOnUnloadEventAndRemove(
     std::set<ScriptContext*>* out,
     ScriptContext* context) {
   context->DispatchOnUnloadEvent();
   Remove(context);  // deleted asynchronously
   out->insert(context);
 }
 
 }  // namespace extensions