Create thread-safe RendererExtensionRegistry from ExtensionSet

extensions/renderer/dispatcher.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/dispatcher.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 52 matching lines @@
 #include "extensions/renderer/guest_view/guest_view_internal_custom_bindings.h"
 #include "extensions/renderer/i18n_custom_bindings.h"
 #include "extensions/renderer/id_generator_custom_bindings.h"
 #include "extensions/renderer/lazy_background_page_native_handler.h"
 #include "extensions/renderer/logging_native_handler.h"
 #include "extensions/renderer/messaging_bindings.h"
 #include "extensions/renderer/module_system.h"
 #include "extensions/renderer/print_native_handler.h"
 #include "extensions/renderer/process_info_native_handler.h"
 #include "extensions/renderer/render_frame_observer_natives.h"
+#include "extensions/renderer/renderer_extension_registry.h"
 #include "extensions/renderer/request_sender.h"
 #include "extensions/renderer/runtime_custom_bindings.h"
 #include "extensions/renderer/safe_builtins.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
 #include "extensions/renderer/script_injection.h"
 #include "extensions/renderer/script_injection_manager.h"
 #include "extensions/renderer/send_request_natives.h"
 #include "extensions/renderer/set_icon_natives.h"
 #include "extensions/renderer/test_features_native_handler.h"
@@ skipping 111 matching lines @@
       *(base::CommandLine::ForCurrentProcess());
   set_idle_notifications_ =
       command_line.HasSwitch(switches::kExtensionProcess) ||
       command_line.HasSwitch(::switches::kSingleProcess);
 
   if (set_idle_notifications_) {
     RenderThread::Get()->SetIdleNotificationDelayInMs(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
-  script_context_set_.reset(
-      new ScriptContextSet(&extensions_, &active_extension_ids_));
-  user_script_set_manager_.reset(new UserScriptSetManager(&extensions_));
+  script_context_set_.reset(new ScriptContextSet(&active_extension_ids_));
+  user_script_set_manager_.reset(new UserScriptSetManager());
   script_injection_manager_.reset(
-      new ScriptInjectionManager(&extensions_, user_script_set_manager_.get()));
+      new ScriptInjectionManager(user_script_set_manager_.get()));
   user_script_set_manager_observer_.Add(user_script_set_manager_.get());
   request_sender_.reset(new RequestSender(this));
   PopulateSourceMap();
 }
 
 Dispatcher::~Dispatcher() {
 }
 
 void Dispatcher::OnRenderFrameCreated(content::RenderFrame* render_frame) {
   script_injection_manager_->OnRenderFrameCreated(render_frame);
 }
 
 bool Dispatcher::IsExtensionActive(const std::string& extension_id) const {
   bool is_active =
       active_extension_ids_.find(extension_id) != active_extension_ids_.end();
   if (is_active)
-    CHECK(extensions_.Contains(extension_id));
+    CHECK(RendererExtensionRegistry::Get()->Contains(extension_id));
   return is_active;
 }
 
 void Dispatcher::DidCreateScriptContext(
     blink::WebLocalFrame* frame,
     const v8::Local<v8::Context>& v8_context,
     int extension_group,
     int world_id) {
   const base::TimeTicks start_time = base::TimeTicks::Now();
 
@@ skipping 87 matching lines @@
 }
 
 void Dispatcher::DidCreateDocumentElement(blink::WebLocalFrame* frame) {
   // Note: use GetEffectiveDocumentURL not just frame->document()->url()
   // so that this also injects the stylesheet on about:blank frames that
   // are hosted in the extension process.
   GURL effective_document_url = ScriptContext::GetEffectiveDocumentURL(
       frame, frame->document().url(), true /* match_about_blank */);
 
   const Extension* extension =
-      extensions_.GetExtensionOrAppByURL(effective_document_url);
+      RendererExtensionRegistry::Get()->GetExtensionOrAppByURL(
+          effective_document_url);
 
   if (extension &&
       (extension->is_extension() || extension->is_platform_app())) {
     int resource_id = extension->is_platform_app() ? IDR_PLATFORM_APP_CSS
                                                    : IDR_EXTENSION_FONTS_CSS;
     std::string stylesheet = ResourceBundle::GetSharedInstance()
                                  .GetRawDataResource(resource_id)
                                  .as_string();
     base::ReplaceFirstSubstringAfterOffset(
         &stylesheet, 0, "$FONTFAMILY", system_font_family_);
@@ skipping 61 matching lines @@
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch, for which Invoke is the chokepoint.
   if (set_idle_notifications_) {
     RenderThread::Get()->ScheduleIdleHandler(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   // Tell the browser process when an event has been dispatched with a lazy
   // background page active.
-  const Extension* extension = extensions_.GetByID(extension_id);
+  const Extension* extension =
+      RendererExtensionRegistry::Get()->GetByID(extension_id);
   if (extension && BackgroundInfo::HasLazyBackgroundPage(extension) &&
       module_name == kEventBindings &&
       function_name == kEventDispatchFunction) {
     content::RenderFrame* background_frame =
         ExtensionFrameHelper::GetBackgroundPageFrame(extension_id);
     if (background_frame) {
       int message_id;
       args.GetInteger(3, &message_id);
       background_frame->Send(new ExtensionHostMsg_EventAck(
           background_frame->GetRoutingID(), message_id));
@@ skipping 267 matching lines @@
           new GuestViewInternalCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "i18n", scoped_ptr<NativeHandler>(new I18NCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "id_generator",
       scoped_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "runtime", scoped_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
 }
 
-void Dispatcher::LoadExtensionForTest(const Extension* extension) {
-  CHECK(extensions_.Insert(extension));
-}
-
 bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
   IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
   IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect, OnDispatchOnDisconnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
   IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
@@ skipping 31 matching lines @@
     forced_idle_timer_->Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
         RenderThread::Get(),
         &RenderThread::IdleHandler);
   }
 
   // Initialize host permissions for any extensions that were activated before
   // WebKit was initialized.
   for (const std::string& extension_id : active_extension_ids_) {
-    const Extension* extension = extensions_.GetByID(extension_id);
+    const Extension* extension =
+        RendererExtensionRegistry::Get()->GetByID(extension_id);
     CHECK(extension);
     InitOriginPermissions(extension);
   }
 
   EnableCustomElementWhiteList();
 
   is_webkit_initialized_ = true;
 }
 
 void Dispatcher::IdleNotification() {
@@ skipping 13 matching lines @@
   }
 }
 
 void Dispatcher::OnRenderProcessShutdown() {
   v8_schema_registry_.reset();
   forced_idle_timer_.reset();
   content_watcher_.reset();
 }
 
 void Dispatcher::OnActivateExtension(const std::string& extension_id) {
-  const Extension* extension = extensions_.GetByID(extension_id);
+  const Extension* extension =
+      RendererExtensionRegistry::Get()->GetByID(extension_id);
   if (!extension) {
     // Extension was activated but was never loaded. This probably means that
     // the renderer failed to load it (or the browser failed to tell us when it
     // did). Failures shouldn't happen, but instead of crashing there (which
     // executes on all renderers) be conservative and only crash in the renderer
     // of the extension which failed to load; this one.
     std::string& error = extension_load_errors_[extension_id];
     char minidump[256];
     base::debug::Alias(&minidump);
     base::snprintf(minidump,
@@ skipping 69 matching lines @@
     std::string error;
     scoped_refptr<const Extension> extension = param.ConvertToExtension(&error);
     if (!extension.get()) {
       NOTREACHED() << error;
       // Note: in tests |param.id| has been observed to be empty (see comment
       // just below) so this isn't all that reliable.
       extension_load_errors_[param.id] = error;
       continue;
     }
 
+    RendererExtensionRegistry* extensions = RendererExtensionRegistry::Get();
     // TODO(kalman): This test is deliberately not a CHECK (though I wish it
     // could be) and uses extension->id() not params.id:
     // 1. For some reason params.id can be empty. I've only seen it with
     //    the webstore extension, in tests, and I've spent some time trying to
     //    figure out why - but cost/benefit won.
     // 2. The browser only sends this IPC to RenderProcessHosts once, but the
     //    Dispatcher is attached to a RenderThread. Presumably there is a
     //    mismatch there. In theory one would think it's possible for the
     //    browser to figure this out itself - but again, cost/benefit.
-    if (!extensions_.Contains(extension->id()))
-      extensions_.Insert(extension);
+    if (!extensions->Contains(extension->id()))
+      extensions->Insert(extension);
   }
 
   // Update the available bindings for all contexts. These may have changed if
   // an externally_connectable extension was loaded that can connect to an
   // open webpage.
   UpdateBindings("");
 }
 
 void Dispatcher::OnMessageInvoke(const std::string& extension_id,
                                  const std::string& module_name,
@@ skipping 42 matching lines @@
   RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id));
 }
 
 void Dispatcher::OnTransferBlobs(const std::vector<std::string>& blob_uuids) {
   RenderThread::Get()->Send(new ExtensionHostMsg_TransferBlobsAck(blob_uuids));
 }
 
 void Dispatcher::OnUnloaded(const std::string& id) {
   // See comment in OnLoaded for why it would be nice, but perhaps incorrect,
   // to CHECK here rather than guarding.
-  if (!extensions_.Remove(id))
+  if (!RendererExtensionRegistry::Get()->Remove(id))
     return;
 
   active_extension_ids_.erase(id);
 
   script_injection_manager_->OnExtensionUnloaded(id);
 
   // If the extension is later reloaded with a different set of permissions,
   // we'd like it to get a new isolated world ID, so that it can pick up the
   // changed origin whitelist.
   ScriptInjection::RemoveIsolatedWorld(id);
@@ skipping 15 matching lines @@
   // reloaded with a new messages map.
   EraseL10nMessagesMap(id);
 
   // We don't do anything with existing platform-app stylesheets. They will
   // stay resident, but the URL pattern corresponding to the unloaded
   // extension's URL just won't match anything anymore.
 }
 
 void Dispatcher::OnUpdatePermissions(
     const ExtensionMsg_UpdatePermissions_Params& params) {
-  const Extension* extension = extensions_.GetByID(params.extension_id);
+  const Extension* extension =
+      RendererExtensionRegistry::Get()->GetByID(params.extension_id);
   if (!extension)
     return;
 
   scoped_refptr<const PermissionSet> active =
       params.active_permissions.ToPermissionSet();
   scoped_refptr<const PermissionSet> withheld =
       params.withheld_permissions.ToPermissionSet();
 
   if (is_webkit_initialized_) {
     UpdateOriginPermissions(
         extension->url(),
         extension->permissions_data()->GetEffectiveHostPermissions(),
         active->effective_hosts());
   }
 
   extension->permissions_data()->SetPermissions(active, withheld);
   UpdateBindings(extension->id());
 }
 
 void Dispatcher::OnUpdateTabSpecificPermissions(const GURL& visible_url,
                                                 const std::string& extension_id,
                                                 const URLPatternSet& new_hosts,
                                                 bool update_origin_whitelist,
                                                 int tab_id) {
-  const Extension* extension = extensions_.GetByID(extension_id);
+  const Extension* extension =
+      RendererExtensionRegistry::Get()->GetByID(extension_id);
   if (!extension)
     return;
 
   URLPatternSet old_effective =
       extension->permissions_data()->GetEffectiveHostPermissions();
   extension->permissions_data()->UpdateTabSpecificPermissions(
       tab_id,
       new extensions::PermissionSet(extensions::APIPermissionSet(),
                                     extensions::ManifestPermissionSet(),
                                     new_hosts,
                                     extensions::URLPatternSet()));
 
   if (is_webkit_initialized_ && update_origin_whitelist) {
     UpdateOriginPermissions(
         extension->url(),
         old_effective,
         extension->permissions_data()->GetEffectiveHostPermissions());
   }
 }
 
 void Dispatcher::OnClearTabSpecificPermissions(
     const std::vector<std::string>& extension_ids,
     bool update_origin_whitelist,
     int tab_id) {
   for (const std::string& id : extension_ids) {
-    const Extension* extension = extensions_.GetByID(id);
+    const Extension* extension = RendererExtensionRegistry::Get()->GetByID(id);
     if (extension) {
       URLPatternSet old_effective =
           extension->permissions_data()->GetEffectiveHostPermissions();
       extension->permissions_data()->ClearTabSpecificPermissions(tab_id);
       if (is_webkit_initialized_ && update_origin_whitelist) {
         UpdateOriginPermissions(
             extension->url(),
             old_effective,
             extension->permissions_data()->GetEffectiveHostPermissions());
       }
@@ skipping 220 matching lines @@
           send_request_disabled)));
 
   delegate_->RegisterNativeHandlers(this, module_system, context);
 }
 
 bool Dispatcher::IsRuntimeAvailableToContext(ScriptContext* context) {
   if (extensions::FeatureSwitch::surface_worker()->IsEnabled() &&
       context->GetAvailability("surfaceWorkerInternal").is_available()) {
     return true;
   }
-  for (const auto& extension : extensions_) {
+  for (const auto& extension :
+       *RendererExtensionRegistry::Get()->GetMainThreadExtensionSet()) {
     ExternallyConnectableInfo* info = static_cast<ExternallyConnectableInfo*>(
         extension->GetManifestData(manifest_keys::kExternallyConnectable));
     if (info && info->matches.MatchesURL(context->GetURL()))
       return true;
   }
   return false;
 }
 
 void Dispatcher::UpdateContentCapabilities(ScriptContext* context) {
   APIPermissionSet permissions;
-  for (const auto& extension : extensions_) {
+  for (const auto& extension :
+       *RendererExtensionRegistry::Get()->GetMainThreadExtensionSet()) {
     const ContentCapabilitiesInfo& info =
         ContentCapabilitiesInfo::Get(extension.get());
     if (info.url_patterns.MatchesURL(context->GetURL())) {
       APIPermissionSet new_permissions;
       APIPermissionSet::Union(permissions, info.permissions, &new_permissions);
       permissions = new_permissions;
     }
   }
   context->SetContentCapabilities(permissions);
 }
 
 void Dispatcher::PopulateSourceMap() {
   const std::vector<std::pair<std::string, int> > resources = GetJsResources();
   for (std::vector<std::pair<std::string, int> >::const_iterator resource =
            resources.begin();
        resource != resources.end();
        ++resource) {
     source_map_.RegisterSource(resource->first, resource->second);
   }
   delegate_->PopulateSourceMap(&source_map_);
 }
 
 bool Dispatcher::IsWithinPlatformApp() {
   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
        iter != active_extension_ids_.end();
        ++iter) {
-    const Extension* extension = extensions_.GetByID(*iter);
+    const Extension* extension =
+        RendererExtensionRegistry::Get()->GetByID(*iter);
     if (extension && extension->is_platform_app())
       return true;
   }
   return false;
 }
 
 v8::Local<v8::Object> Dispatcher::GetOrCreateObject(
     const v8::Local<v8::Object>& object,
     const std::string& field,
     v8::Isolate* isolate) {
@@ skipping 116 matching lines @@
 void Dispatcher::AddChannelSpecificFeatures() {
   // chrome-extension: resources should be allowed to register a Service Worker.
   if (FeatureProvider::GetBehaviorFeature(BehaviorFeature::kServiceWorker)
           ->IsAvailableToEnvironment()
           .is_available())
     WebSecurityPolicy::registerURLSchemeAsAllowingServiceWorkers(
         WebString::fromUTF8(kExtensionScheme));
 }
 
 }  // namespace extensions