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

extensions/renderer/js_extension_bindings_system.cc

 // Copyright 2016 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/js_extension_bindings_system.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/content_switches.h"
@@ skipping 10 matching lines @@
 #include "extensions/renderer/renderer_extension_registry.h"
 #include "extensions/renderer/resource_bundle_source_map.h"
 #include "extensions/renderer/script_context.h"
 #include "gin/converter.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 namespace {
 
+static const char kEventDispatchFunction[] = "dispatchEvent";
+
 // Gets |field| from |object| or creates it as an empty object if it doesn't
 // exist.
 v8::Local<v8::Object> GetOrCreateObject(const v8::Local<v8::Object>& object,
                                         const std::string& field,
                                         v8::Isolate* isolate) {
   v8::Local<v8::String> key = v8::String::NewFromUtf8(isolate, field.c_str());
   // If the object has a callback property, it is assumed it is an unavailable
   // API, so it is safe to delete. This is checked before GetOrCreateObject is
   // called.
   if (object->HasRealNamedCallbackProperty(key)) {
@@ skipping 202 matching lines @@
 
 RequestSender* JsExtensionBindingsSystem::GetRequestSender() {
   return request_sender_.get();
 }
 
 void JsExtensionBindingsSystem::DispatchEventInContext(
     const std::string& event_name,
     const base::ListValue* event_args,
     const base::DictionaryValue* filtering_info,
     ScriptContext* context) {
-  EventBindings::DispatchEventInContext(event_name, event_args, filtering_info,
-                                        context);
+  v8::HandleScope handle_scope(context->isolate());
+  v8::Context::Scope context_scope(context->v8_context());
+
+  std::vector<v8::Local<v8::Value>> arguments;
+  arguments.push_back(gin::StringToSymbol(context->isolate(), event_name));
+
+  {
+    std::unique_ptr<content::V8ValueConverter> converter(
+        content::V8ValueConverter::create());
+    arguments.push_back(
+        converter->ToV8Value(event_args, context->v8_context()));
+    if (filtering_info && !filtering_info->empty()) {
+      arguments.push_back(
+          converter->ToV8Value(filtering_info, context->v8_context()));
+    }
+  }
+
+  context->module_system()->CallModuleMethodSafe(
+      kEventBindings, kEventDispatchFunction, arguments.size(),
+      arguments.data());
 }
 
 bool JsExtensionBindingsSystem::HasEventListenerInContext(
     const std::string& event_name,
     ScriptContext* context) {
   return EventBindings::HasListener(context, event_name);
 }
 
 void JsExtensionBindingsSystem::RegisterBinding(
     const std::string& api_name,
@@ skipping 33 matching lines @@
         std::unique_ptr<NativeHandler>(
             new BindingGeneratingNativeHandler(context, api_name, "binding")));
     module_system->SetNativeLazyField(bind_object, bind_name, api_bind_name,
                                       "binding");
   } else {
     module_system->SetLazyField(bind_object, bind_name, api_name, "binding");
   }
 }
 
 }  // namespace extensions