[Extensions Bindings] Request JS execution from messaging bindings

extensions/renderer/event_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/event_bindings.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/event_filter.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/value_counter.h"
 #include "extensions/renderer/extension_frame_helper.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/service_worker_request_sender.h"
 #include "extensions/renderer/worker_thread_dispatcher.h"
+#include "gin/converter.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 // A map of event names to the number of contexts listening to that event.
 // We notify the browser about event listeners when we transition between 0
 // and 1.
 typedef std::map<std::string, int> EventListenerCounts;
 
 // A map of extension IDs to listener counts for that extension.
 base::LazyInstance<std::map<std::string, EventListenerCounts>>::DestructorAtExit
     g_listener_counts = LAZY_INSTANCE_INITIALIZER;
 
+// A collection of the unmanaged events (i.e., those for which the browser is
+// not notified of changes) that have listeners, by context.
+base::LazyInstance<std::map<ScriptContext*, std::set<std::string>>>::Leaky
+    g_unmanaged_listeners = LAZY_INSTANCE_INITIALIZER;
+
 // A map of (extension ID, event name) pairs to the filtered listener counts
 // for that pair. The map is used to keep track of which filters are in effect
 // for which events.  We notify the browser about filtered event listeners when
 // we transition between 0 and 1.
 using FilteredEventListenerKey = std::pair<std::string, std::string>;
 using FilteredEventListenerCounts =
     std::map<FilteredEventListenerKey, std::unique_ptr<ValueCounter>>;
 base::LazyInstance<FilteredEventListenerCounts>::DestructorAtExit
     g_filtered_listener_counts = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 112 matching lines @@
                                           base::Unretained(this)));
   RouteFunction(
       "AttachFilteredEvent",
       base::Bind(&EventBindings::AttachFilteredEvent, base::Unretained(this)));
   RouteFunction("DetachFilteredEvent",
                 base::Bind(&EventBindings::DetachFilteredEventHandler,
                            base::Unretained(this)));
   RouteFunction("MatchAgainstEventFilter",
                 base::Bind(&EventBindings::MatchAgainstEventFilter,
                            base::Unretained(this)));
+  RouteFunction(
+      "AttachUnmanagedEvent",
+      base::Bind(&EventBindings::AttachUnmanagedEvent, base::Unretained(this)));
+  RouteFunction(
+      "DetachUnmanagedEvent",
+      base::Bind(&EventBindings::DetachUnmanagedEvent, base::Unretained(this)));
 
   // It's safe to use base::Unretained here because |context| will always
   // outlive us.
   context->AddInvalidationObserver(
       base::Bind(&EventBindings::OnInvalidated, base::Unretained(this)));
 }
 
 EventBindings::~EventBindings() {}
 
+bool EventBindings::HasListener(ScriptContext* script_context,
+                                const std::string& event_name) {
+  const auto& unmanaged_listeners = g_unmanaged_listeners.Get();
+  auto unmanaged_iter = unmanaged_listeners.find(script_context);
+  if (unmanaged_iter != unmanaged_listeners.end() &&
+      base::ContainsKey(unmanaged_iter->second, event_name)) {
+    return true;
+  }
+  const auto& managed_listeners = g_listener_counts.Get();
+  auto managed_iter =
+      managed_listeners.find(GetKeyForScriptContext(script_context));
+  if (managed_iter != managed_listeners.end()) {
+    auto event_iter = managed_iter->second.find(event_name);
+    if (event_iter != managed_iter->second.end() && event_iter->second > 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void EventBindings::AttachEventHandler(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsString());
   AttachEvent(*v8::String::Utf8Value(args[0]));
 }
 
 void EventBindings::AttachEvent(const std::string& event_name) {
   if (!context()->HasAccessOrThrowError(event_name))
     return;
@@ skipping 157 matching lines @@
       v8::Array::New(isolate, matched_event_filters.size()));
   int i = 0;
   for (MatcherIDs::iterator it = matched_event_filters.begin();
        it != matched_event_filters.end();
        ++it) {
     array->Set(v8::Integer::New(isolate, i++), v8::Integer::New(isolate, *it));
   }
   args.GetReturnValue().Set(array);
 }
 
+void EventBindings::AttachUnmanagedEvent(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+  CHECK_EQ(1, args.Length());
+  CHECK(args[0]->IsString());
+  std::string event_name = gin::V8ToString(args[0]);
+  g_unmanaged_listeners.Get()[context()].insert(event_name);
+}
+
+void EventBindings::DetachUnmanagedEvent(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+  CHECK_EQ(1, args.Length());
+  CHECK(args[0]->IsString());
+  std::string event_name = gin::V8ToString(args[0]);
+  g_unmanaged_listeners.Get()[context()].erase(event_name);
+}
+
 std::unique_ptr<EventMatcher> EventBindings::ParseEventMatcher(
     std::unique_ptr<base::DictionaryValue> filter) {
   return base::MakeUnique<EventMatcher>(
       std::move(filter), context()->GetRenderFrame()->GetRoutingID());
 }
 
 IPC::Sender* EventBindings::GetIPCSender() {
   const bool is_service_worker_context =
       context()->context_type() == Feature::SERVICE_WORKER_CONTEXT;
   DCHECK_EQ(is_service_worker_context,
@@ skipping 13 matching lines @@
   DCHECK(attached_event_names_.empty())
       << "Events cannot be attached during invalidation";
 
   // Same for filtered events.
   std::set<int> attached_matcher_ids_safe = attached_matcher_ids_;
   for (int matcher_id : attached_matcher_ids_safe) {
     DetachFilteredEvent(matcher_id, false /* is_manual */);
   }
   DCHECK(attached_matcher_ids_.empty())
       << "Filtered events cannot be attached during invalidation";
+
+  g_unmanaged_listeners.Get().erase(context());
 }
 
 }  // namespace extensions