[Extensions Bindings] Request JS execution from messaging bindings

extensions/renderer/messaging_bindings.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/messaging_bindings.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/api/messaging/message.h"
 #include "extensions/common/api/messaging/port_id.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/externally_connectable.h"
+#include "extensions/renderer/dispatcher.h"
+#include "extensions/renderer/extension_bindings_system.h"
 #include "extensions/renderer/extension_frame_helper.h"
 #include "extensions/renderer/extension_port.h"
+#include "extensions/renderer/extensions_renderer_client.h"
 #include "extensions/renderer/gc_callback.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebScopedWindowFocusAllowedIndicator.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "v8/include/v8.h"
@@ skipping 38 matching lines @@
     ScriptContext* script_context) {
   MessagingBindings* bindings = g_messaging_map.Get()[script_context];
   DCHECK(bindings);
 
   // If the channel was opened by this same context, ignore it. This should only
   // happen when messages are sent to an entire process (rather than a single
   // frame) as an optimization; otherwise the browser process filters this out.
   if (bindings->context_id() == target_port_id.context_id)
     return;
 
+  // First, determine the event we'll use to connect.
+  std::string target_extension_id = script_context->GetExtensionID();
+  bool is_external = info.source_id != target_extension_id;
+  std::string event_name;
+  if (channel_name == "chrome.extension.sendRequest") {
+    event_name =
+        is_external ? "extension.onRequestExternal" : "extension.onRequest";
+  } else if (channel_name == "chrome.runtime.sendMessage") {
+    event_name =
+        is_external ? "runtime.onMessageExternal" : "runtime.onMessage";
+  } else {
+    event_name =
+        is_external ? "runtime.onConnectExternal" : "runtime.onConnect";
+  }
+
+  ExtensionBindingsSystem* bindings_system =
+      ExtensionsRendererClient::Get()->GetDispatcher()->bindings_system();
+  // If there are no listeners for the given event, then we know the port won't
+  // be used in this context.
+  if (!bindings_system->HasEventListenerInContext(event_name, script_context)) {
+    return;
+  }
+  *port_created = true;
+
   ExtensionPort* port = bindings->CreateNewPortWithId(target_port_id);
-  // Remove the port.
-  base::ScopedClosureRunner remove_port(
-      base::Bind(&MessagingBindings::RemovePortWithJsId, bindings->GetWeakPtr(),
-                 port->js_id()));
 
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
-
   const std::string& source_url_spec = info.source_url.spec();
-  std::string target_extension_id = script_context->GetExtensionID();
   const Extension* extension = script_context->extension();
 
   v8::Local<v8::Value> tab = v8::Null(isolate);
   v8::Local<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
   v8::Local<v8::Value> guest_process_id = v8::Undefined(isolate);
   v8::Local<v8::Value> guest_render_frame_routing_id = v8::Undefined(isolate);
 
   if (extension) {
     if (!source->tab.empty() && !extension->is_platform_app()) {
       std::unique_ptr<content::V8ValueConverter> converter(
@@ skipping 46 matching lines @@
       // sourceExtensionId
       v8_source_id,
       // targetExtensionId
       v8_target_extension_id,
       // sourceUrl
       v8_source_url_spec,
       // tlsChannelId
       tls_channel_id_value,
   };
 
-  v8::Local<v8::Value> retval =
-      script_context->module_system()->CallModuleMethod(
-          "messaging", "dispatchOnConnect", arraysize(arguments), arguments);
-
-  if (!retval.IsEmpty() && !retval->IsUndefined()) {
-    CHECK(retval->IsBoolean());
-    bool used = retval.As<v8::Boolean>()->Value();
-    *port_created |= used;
-    if (used)  // Port was used; don't remove it.
-      remove_port.ReplaceClosure(base::Closure());
-  } else {
-    LOG(ERROR) << "Empty return value from dispatchOnConnect.";
-  }
+  // Note: this can execute asynchronously if JS is suspended.
+  script_context->module_system()->CallModuleMethodSafe(
+      "messaging", "dispatchOnConnect", arraysize(arguments), arguments);
 }
 
 void DeliverMessageToScriptContext(const Message& message,
                                    const PortId& target_port_id,
                                    ScriptContext* script_context) {
   MessagingBindings* bindings = g_messaging_map.Get()[script_context];
   DCHECK(bindings);
   ExtensionPort* port = bindings->GetPortWithId(target_port_id);
   if (!port)
     return;
@@ skipping 167 matching lines @@
   return nullptr;
 }
 
 ExtensionPort* MessagingBindings::CreateNewPortWithId(const PortId& id) {
   int js_id = GetNextJsId();
   auto port = base::MakeUnique<ExtensionPort>(context(), id, js_id);
   return ports_.insert(std::make_pair(js_id, std::move(port)))
       .first->second.get();
 }
 
-void MessagingBindings::RemovePortWithJsId(int js_id) {
-  ports_.erase(js_id);
-}
-
 base::WeakPtr<MessagingBindings> MessagingBindings::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void MessagingBindings::PostMessage(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   // Arguments are (int32_t port_id, string message).
   CHECK(args.Length() == 2);
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsString());
@@ skipping 164 matching lines @@
     ports_.erase(iter);
     port->Close(force_close);
   }
 }
 
 int MessagingBindings::GetNextJsId() {
   return next_js_id_++;
 }
 
 }  // namespace extensions