Revert of [Extensions Bindings] Avoid passing the event filter to JS

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/extension_urls.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 {
 
@@ skipping 46 matching lines @@
 }
 
 // Decrements the number of event-listeners for the given |event_name| and
 // ScriptContext. Returns the count after the increment.
 int DecrementEventListenerCount(ScriptContext* script_context,
                                 const std::string& event_name) {
   return --g_listener_counts
                .Get()[GetKeyForScriptContext(script_context)][event_name];
 }
 
+EventFilteringInfo ParseFromObject(v8::Local<v8::Object> object,
+                                   v8::Isolate* isolate) {
+  EventFilteringInfo info;
+  v8::Local<v8::String> url(v8::String::NewFromUtf8(isolate, "url"));
+  if (object->Has(url)) {
+    v8::Local<v8::Value> url_value(object->Get(url));
+    info.SetURL(GURL(*v8::String::Utf8Value(url_value)));
+  }
+  v8::Local<v8::String> instance_id(
+      v8::String::NewFromUtf8(isolate, "instanceId"));
+  if (object->Has(instance_id)) {
+    v8::Local<v8::Value> instance_id_value(object->Get(instance_id));
+    info.SetInstanceID(instance_id_value->IntegerValue());
+  }
+  v8::Local<v8::String> service_type(
+      v8::String::NewFromUtf8(isolate, "serviceType"));
+  if (object->Has(service_type)) {
+    v8::Local<v8::Value> service_type_value(object->Get(service_type));
+    info.SetServiceType(*v8::String::Utf8Value(service_type_value));
+  }
+  v8::Local<v8::String> window_types(
+      v8::String::NewFromUtf8(isolate, "windowType"));
+  if (object->Has(window_types)) {
+    v8::Local<v8::Value> window_types_value(object->Get(window_types));
+    info.SetWindowType(*v8::String::Utf8Value(window_types_value));
+  }
+
+  v8::Local<v8::String> window_exposed(
+      v8::String::NewFromUtf8(isolate, "windowExposedByDefault"));
+  if (object->Has(window_exposed)) {
+    v8::Local<v8::Value> window_exposed_value(object->Get(window_exposed));
+    info.SetWindowExposedByDefault(
+        window_exposed_value.As<v8::Boolean>()->Value());
+  }
+
+  return info;
+}
+
 // Add a filter to |event_name| in |extension_id|, returning true if it
 // was the first filter for that event in that extension.
 bool AddFilter(const std::string& event_name,
                const std::string& extension_id,
                const base::DictionaryValue& filter) {
   FilteredEventListenerKey key(extension_id, event_name);
   FilteredEventListenerCounts& all_counts = g_filtered_listener_counts.Get();
   FilteredEventListenerCounts::const_iterator counts = all_counts.find(key);
   if (counts == all_counts.end()) {
     counts =
@@ skipping 17 matching lines @@
   // |filter|. If there are more equivalent filters, or if there weren't any in
   // the first place, it returns false.
   if (counts->second->Remove(*filter)) {
     if (counts->second->is_empty())
       all_counts.erase(counts);  // Clean up if there are no more filters.
     return true;
   }
   return false;
 }
 
-// Returns a v8::Array containing the ids of the listeners that match the given
-// |event_filter_dict| in the given |script_context|.
-v8::Local<v8::Array> GetMatchingListeners(
-    ScriptContext* script_context,
-    const std::string& event_name,
-    const base::DictionaryValue& event_filter_dict) {
-  const EventFilter& event_filter = g_event_filter.Get();
-  EventFilteringInfo info(event_filter_dict);
-  v8::Isolate* isolate = script_context->isolate();
-  v8::Local<v8::Context> context = script_context->v8_context();
-
-  // Only match events routed to this context's RenderFrame or ones that don't
-  // have a routingId in their filter.
-  std::set<EventFilter::MatcherID> matched_event_filters =
-      event_filter.MatchEvent(event_name, info,
-                              script_context->GetRenderFrame()->GetRoutingID());
-  v8::Local<v8::Array> array(
-      v8::Array::New(isolate, matched_event_filters.size()));
-  int i = 0;
-  for (EventFilter::MatcherID id : matched_event_filters) {
-    CHECK(array->CreateDataProperty(context, i++, v8::Integer::New(isolate, id))
-              .ToChecked());
-  }
-
-  return array;
-}
-
 }  // namespace
 
 EventBindings::EventBindings(ScriptContext* context)
     : ObjectBackedNativeHandler(context) {
   RouteFunction("AttachEvent", base::Bind(&EventBindings::AttachEventHandler,
                                           base::Unretained(this)));
   RouteFunction("DetachEvent", base::Bind(&EventBindings::DetachEventHandler,
                                           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(
@@ skipping 16 matching lines @@
   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;
 }
 
-// static
-void EventBindings::DispatchEventInContext(
-    const std::string& event_name,
-    const base::ListValue* event_args,
-    const base::DictionaryValue* filtering_info,
-    ScriptContext* context) {
-  v8::HandleScope handle_scope(context->isolate());
-  v8::Context::Scope context_scope(context->v8_context());
-
-  v8::Local<v8::Array> listener_ids;
-  if (filtering_info && !filtering_info->empty())
-    listener_ids = GetMatchingListeners(context, event_name, *filtering_info);
-  else
-    listener_ids = v8::Array::New(context->isolate());
-
-  std::unique_ptr<content::V8ValueConverter> converter(
-      content::V8ValueConverter::create());
-  v8::Local<v8::Value> v8_args[] = {
-      gin::StringToSymbol(context->isolate(), event_name),
-      converter->ToV8Value(event_args, context->v8_context()), listener_ids,
-  };
-
-  context->module_system()->CallModuleMethodSafe(
-      kEventBindings, "dispatchEvent", arraysize(v8_args), v8_args);
-}
-
 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 59 matching lines @@
     if (is_lazy_context) {
       sender->Send(new ExtensionHostMsg_RemoveLazyListener(
           extension_id, event_name, worker_thread_id));
     }
   }
 }
 
 // MatcherID AttachFilteredEvent(string event_name, object filter)
 // event_name - Name of the event to attach.
 // filter - Which instances of the named event are we interested in.
-// returns the id assigned to the listener, which will be provided to calls to
-// dispatchEvent().
+// returns the id assigned to the listener, which will be returned from calls
+// to MatchAgainstEventFilter where this listener matches.
 void EventBindings::AttachFilteredEvent(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsString());
   CHECK(args[1]->IsObject());
 
   std::string event_name = *v8::String::Utf8Value(args[0]);
   if (!context()->HasAccessOrThrowError(event_name))
     return;
 
@@ skipping 53 matching lines @@
         is_manual && ExtensionFrameHelper::IsContextForEventPage(context());
     content::RenderThread::Get()->Send(
         new ExtensionHostMsg_RemoveFilteredListener(
             extension_id, event_name, *event_matcher->value(), remove_lazy));
   }
 
   event_filter.RemoveEventMatcher(matcher_id);
   attached_matcher_ids_.erase(matcher_id);
 }
 
+void EventBindings::MatchAgainstEventFilter(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  typedef std::set<EventFilter::MatcherID> MatcherIDs;
+  EventFilter& event_filter = g_event_filter.Get();
+  std::string event_name = *v8::String::Utf8Value(args[0]);
+  EventFilteringInfo info =
+      ParseFromObject(args[1]->ToObject(isolate), isolate);
+  // Only match events routed to this context's RenderFrame or ones that don't
+  // have a routingId in their filter.
+  MatcherIDs matched_event_filters = event_filter.MatchEvent(
+      event_name, info, context()->GetRenderFrame()->GetRoutingID());
+  v8::Local<v8::Array> array(
+      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);
 }
 
@@ skipping 38 matching lines @@
   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