[Extensions Bindings] Add a registerEventArgumentMassager

extensions/renderer/api_binding_bridge.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/api_binding_bridge.h"
 
 #include "base/values.h"
 #include "extensions/renderer/api_binding_hooks.h"
+#include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "extensions/renderer/api_signature.h"
 #include "extensions/renderer/api_type_reference_map.h"
 #include "gin/converter.h"
 #include "gin/object_template_builder.h"
 
 namespace extensions {
 
 namespace {
 
 const char kApiObjectKey[] = "extensions::bridge::api_object";
 const char kHookInterfaceKey[] = "extensions::bridge::hook_object";
 
 v8::Local<v8::Private> GetPrivatePropertyName(v8::Isolate* isolate,
                                               const char* key) {
   return v8::Private::ForApi(isolate, gin::StringToSymbol(isolate, key));
 }
 
 }  // namespace
 
 gin::WrapperInfo APIBindingBridge::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 APIBindingBridge::APIBindingBridge(const APITypeReferenceMap* type_refs,
                                    APIRequestHandler* request_handler,
+                                   APIEventHandler* event_handler,
                                    APIBindingHooks* hooks,
                                    v8::Local<v8::Context> context,
                                    v8::Local<v8::Value> api_object,
                                    const std::string& extension_id,
                                    const std::string& context_type,
                                    const binding::RunJSFunction& run_js)
     : type_refs_(type_refs),
       request_handler_(request_handler),
+      event_handler_(event_handler),
       hooks_(hooks),
       extension_id_(extension_id),
       context_type_(context_type),
       run_js_(run_js) {
   v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Object> wrapper = GetWrapper(isolate);
   v8::Maybe<bool> result = wrapper->SetPrivate(
       context, GetPrivatePropertyName(isolate, kApiObjectKey), api_object);
   if (!result.IsJust() || !result.FromJust()) {
     NOTREACHED();
     return;
   }
   v8::Local<v8::Object> js_hook_interface = hooks_->GetJSHookInterface(context);
   result = wrapper->SetPrivate(context,
                                GetPrivatePropertyName(isolate,
                                                       kHookInterfaceKey),
                                js_hook_interface);
   DCHECK(result.IsJust() && result.FromJust());
 }
 
 APIBindingBridge::~APIBindingBridge() {}
 
 gin::ObjectTemplateBuilder APIBindingBridge::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<APIBindingBridge>::GetObjectTemplateBuilder(isolate)
       .SetMethod("registerCustomHook", &APIBindingBridge::RegisterCustomHook)
-      .SetMethod("sendRequest", &APIBindingBridge::SendRequest);
+      .SetMethod("sendRequest", &APIBindingBridge::SendRequest)
+      .SetMethod("registerEventArgumentMassager",
+                 &APIBindingBridge::RegisterEventArgumentMassager);
 }
 
 void APIBindingBridge::RegisterCustomHook(v8::Isolate* isolate,
                                           v8::Local<v8::Function> function) {
   // The object and arguments here are meant to match those passed to the hook
   // functions in binding.js.
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> hook_object = v8::Object::New(isolate);
   v8::Local<v8::Object> wrapper = GetWrapper(isolate);
   v8::Local<v8::Value> hook_interface =
@@ skipping 48 matching lines @@
   std::string error;
   CHECK(signature->ParseArgumentsToJSON(context, request_args, *type_refs_,
                                         &converted_arguments, &callback,
                                         &error));
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback,
                                  hooks_->GetCustomJSCallback(name, context));
 }
 
+void APIBindingBridge::RegisterEventArgumentMassager(
+    gin::Arguments* arguments,
+    const std::string& event_name,
+    v8::Local<v8::Function> massager) {
+  v8::Isolate* isolate = arguments->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Object> holder;
+  CHECK(arguments->GetHolder(&holder));
+  v8::Local<v8::Context> context = holder->CreationContext();
+
+  event_handler_->RegisterArgumentMassager(context, event_name, massager);
+}
+
 }  // namespace extensions