[Extensions Bindings] Remove ScriptContext::DispatchEvent

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 <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 342 matching lines @@
   {
     std::unique_ptr<ModuleSystem> module_system(
         new ModuleSystem(context, &source_map_));
     context->set_module_system(std::move(module_system));
   }
   ModuleSystem* module_system = context->module_system();
 
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
 
-  RegisterNativeHandlers(module_system, context,
-                         bindings_system_->GetRequestSender(),
+  RegisterNativeHandlers(module_system, context, bindings_system_.get(),
                          v8_schema_registry_.get());
 
   bindings_system_->DidCreateScriptContext(context);
   UpdateBindingsForContext(context);
 
   // Inject custom JS into the platform app context.
   if (IsWithinPlatformApp()) {
     module_system->Require("platformApp");
   }
 
@@ skipping 89 matching lines @@
     // TODO(lazyboy): Make sure accessing |source_map_| in worker thread is
     // safe.
     context->set_module_system(
         base::MakeUnique<ModuleSystem>(context, &source_map_));
 
     ModuleSystem* module_system = context->module_system();
     // Enable natives in startup.
     ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
     ExtensionBindingsSystem* worker_bindings_system =
         WorkerThreadDispatcher::GetBindingsSystem();
-    RegisterNativeHandlers(module_system, context,
-                           worker_bindings_system->GetRequestSender(),
+    RegisterNativeHandlers(module_system, context, worker_bindings_system,
                            WorkerThreadDispatcher::GetV8SchemaRegistry());
 
     worker_bindings_system->DidCreateScriptContext(context);
     worker_bindings_system->UpdateBindingsForContext(context);
 
     // TODO(lazyboy): Get rid of RequireGuestViewModules() as this doesn't seem
     // necessary for Extension SW.
     RequireGuestViewModules(context);
     delegate_->RequireAdditionalModules(context);
   }
@@ skipping 303 matching lines @@
     resources.emplace_back("guestViewIframe", IDR_GUEST_VIEW_IFRAME_JS);
     resources.emplace_back("guestViewIframeContainer",
                            IDR_GUEST_VIEW_IFRAME_CONTAINER_JS);
   }
 
   return resources;
 }
 
 // NOTE: please use the naming convention "foo_natives" for these.
 // static
-void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
-                                        ScriptContext* context,
-                                        Dispatcher* dispatcher,
-                                        RequestSender* request_sender,
-                                        V8SchemaRegistry* v8_schema_registry) {
+void Dispatcher::RegisterNativeHandlers(
+    ModuleSystem* module_system,
+    ScriptContext* context,
+    Dispatcher* dispatcher,
+    ExtensionBindingsSystem* bindings_system,
+    V8SchemaRegistry* v8_schema_registry) {
   module_system->RegisterNativeHandler(
       "chrome",
       std::unique_ptr<NativeHandler>(new ChromeNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "logging",
       std::unique_ptr<NativeHandler>(new LoggingNativeHandler(context)));
   module_system->RegisterNativeHandler("schema_registry",
                                        v8_schema_registry->AsNativeHandler());
   module_system->RegisterNativeHandler(
       "test_features",
@@ skipping 11 matching lines @@
       std::unique_ptr<NativeHandler>(new V8ContextNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "event_natives",
       std::unique_ptr<NativeHandler>(new EventBindings(context)));
   module_system->RegisterNativeHandler(
       "messaging_natives", base::MakeUnique<MessagingBindings>(context));
   module_system->RegisterNativeHandler(
       "apiDefinitions", std::unique_ptr<NativeHandler>(
                             new ApiDefinitionsNatives(dispatcher, context)));
   module_system->RegisterNativeHandler(
-      "sendRequest", std::unique_ptr<NativeHandler>(
-                         new SendRequestNatives(request_sender, context)));
+      "sendRequest",
+      base::MakeUnique<SendRequestNatives>(
+          // Note: |bindings_system| can be null in unit tests.
+          bindings_system ? bindings_system->GetRequestSender() : nullptr,
+          context));
   module_system->RegisterNativeHandler(
       "setIcon", std::unique_ptr<NativeHandler>(new SetIconNatives(context)));
   module_system->RegisterNativeHandler(
       "activityLogger", std::unique_ptr<NativeHandler>(
                             new APIActivityLogger(context, dispatcher)));
   module_system->RegisterNativeHandler(
       "renderFrameObserverNatives",
       std::unique_ptr<NativeHandler>(new RenderFrameObserverNatives(context)));
 
   // Natives used by multiple APIs.
@@ skipping 18 matching lines @@
       "guest_view_internal", std::unique_ptr<NativeHandler>(
                                  new GuestViewInternalCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "id_generator",
       std::unique_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "runtime",
       std::unique_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "display_source",
-      std::unique_ptr<NativeHandler>(new DisplaySourceCustomBindings(context)));
+      base::MakeUnique<DisplaySourceCustomBindings>(context, bindings_system));
 }
 
 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)
@@ skipping 442 matching lines @@
 void Dispatcher::UpdateBindingsForContext(ScriptContext* context) {
   bindings_system_->UpdateBindingsForContext(context);
   Feature::Context context_type = context->context_type();
   if (context_type == Feature::WEB_PAGE_CONTEXT ||
       context_type == Feature::BLESSED_WEB_PAGE_CONTEXT) {
     UpdateContentCapabilities(context);
   }
 }
 
 // NOTE: please use the naming convention "foo_natives" for these.
-void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
-                                        ScriptContext* context,
-                                        RequestSender* request_sender,
-                                        V8SchemaRegistry* v8_schema_registry) {
-  RegisterNativeHandlers(module_system, context, this, request_sender,
+void Dispatcher::RegisterNativeHandlers(
+    ModuleSystem* module_system,
+    ScriptContext* context,
+    ExtensionBindingsSystem* bindings_system,
+    V8SchemaRegistry* v8_schema_registry) {
+  RegisterNativeHandlers(module_system, context, this, bindings_system,
                          v8_schema_registry);
   const Extension* extension = context->extension();
   int manifest_version = extension ? extension->manifest_version() : 1;
   bool is_component_extension =
       extension && Manifest::IsComponentLocation(extension->location());
   bool send_request_disabled =
       (extension && Manifest::IsUnpackedLocation(extension->location()) &&
        BackgroundInfo::HasLazyBackgroundPage(extension));
   module_system->RegisterNativeHandler(
       "process",
       std::unique_ptr<NativeHandler>(new ProcessInfoNativeHandler(
           context, context->GetExtensionID(),
           context->GetContextTypeDescription(),
           ExtensionsRendererClient::Get()->IsIncognitoProcess(),
           is_component_extension, manifest_version, send_request_disabled)));
 
-  delegate_->RegisterNativeHandlers(this, module_system, context);
+  delegate_->RegisterNativeHandlers(this, module_system, bindings_system,
+                                    context);
 }
 
 void Dispatcher::UpdateContentCapabilities(ScriptContext* context) {
   APIPermissionSet permissions;
   for (const auto& extension :
        *RendererExtensionRegistry::Get()->GetMainThreadExtensionSet()) {
     blink::WebLocalFrame* web_frame = context->web_frame();
     GURL url = context->url();
     // We allow about:blank pages to take on the privileges of their parents if
     // they aren't sandboxed.
@@ skipping 73 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions