[Extensions Bindings] Return result from event dispatch

extensions/renderer/api_event_handler.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_event_handler.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
@@ skipping 90 matching lines @@
   gin::Converter<EventEmitter*>::FromV8(isolate, v8_emitter.Get(isolate),
                                         &emitter);
   CHECK(emitter);
   emitter->Fire(context, &args, nullptr);
 }
 
 }  // namespace
 
 APIEventHandler::APIEventHandler(
     const binding::RunJSFunction& call_js,
+    const binding::RunJSFunctionSync& call_js_sync,
     const EventListenersChangedMethod& listeners_changed)
-    : call_js_(call_js), listeners_changed_(listeners_changed) {}
+    : call_js_(call_js),
+      call_js_sync_(call_js_sync),
+      listeners_changed_(listeners_changed) {}
 APIEventHandler::~APIEventHandler() {}
 
 v8::Local<v8::Object> APIEventHandler::CreateEventInstance(
     const std::string& event_name,
     bool supports_filters,
     int max_listeners,
     bool notify_on_change,
     v8::Local<v8::Context> context) {
   // We need a context scope since gin::CreateHandle only takes the isolate
   // and infers the context from that.
   // TODO(devlin): This could be avoided if gin::CreateHandle could take a
   // context directly.
   v8::Context::Scope context_scope(context);
 
   APIEventPerContextData* data = GetContextData(context, true);
   DCHECK(data->emitters.find(event_name) == data->emitters.end());
 
   APIEventListeners::ListenersUpdated updated =
       notify_on_change ? base::Bind(listeners_changed_, event_name)
                        : base::Bind(&DoNothingOnListenersChanged);
   std::unique_ptr<APIEventListeners> listeners;
   if (supports_filters) {
     listeners = base::MakeUnique<FilteredEventListeners>(
         updated, event_name, max_listeners, &event_filter_);
   } else {
     listeners =
         base::MakeUnique<UnfilteredEventListeners>(updated, max_listeners);
   }
 
-  gin::Handle<EventEmitter> emitter_handle = gin::CreateHandle(
-      context->GetIsolate(),
-      new EventEmitter(supports_filters, std::move(listeners), call_js_));
+  gin::Handle<EventEmitter> emitter_handle =
+      gin::CreateHandle(context->GetIsolate(),
+                        new EventEmitter(supports_filters, std::move(listeners),
+                                         call_js_, call_js_sync_));
   CHECK(!emitter_handle.IsEmpty());
   v8::Local<v8::Value> emitter_value = emitter_handle.ToV8();
   CHECK(emitter_value->IsObject());
   v8::Local<v8::Object> emitter_object =
       v8::Local<v8::Object>::Cast(emitter_value);
   data->emitters[event_name] =
       v8::Global<v8::Object>(context->GetIsolate(), emitter_object);
 
   return emitter_object;
 }
 
 v8::Local<v8::Object> APIEventHandler::CreateAnonymousEventInstance(
     v8::Local<v8::Context> context) {
   v8::Context::Scope context_scope(context);
   APIEventPerContextData* data = GetContextData(context, true);
   bool supports_filters = false;
   std::unique_ptr<APIEventListeners> listeners =
       base::MakeUnique<UnfilteredEventListeners>(
           base::Bind(&DoNothingOnListenersChanged), binding::kNoListenerMax);
-  gin::Handle<EventEmitter> emitter_handle = gin::CreateHandle(
-      context->GetIsolate(),
-      new EventEmitter(supports_filters, std::move(listeners), call_js_));
+  gin::Handle<EventEmitter> emitter_handle =
+      gin::CreateHandle(context->GetIsolate(),
+                        new EventEmitter(supports_filters, std::move(listeners),
+                                         call_js_, call_js_sync_));
   CHECK(!emitter_handle.IsEmpty());
   v8::Local<v8::Object> emitter_object = emitter_handle.ToV8().As<v8::Object>();
   data->anonymous_emitters.push_back(
       v8::Global<v8::Object>(context->GetIsolate(), emitter_object));
   return emitter_object;
 }
 
 void APIEventHandler::InvalidateCustomEvent(v8::Local<v8::Context> context,
                                             v8::Local<v8::Object> event) {
   EventEmitter* emitter = nullptr;
@@ skipping 128 matching lines @@
   auto iter = data->emitters.find(event_name);
   DCHECK(iter != data->emitters.end());
   EventEmitter* emitter = nullptr;
   gin::Converter<EventEmitter*>::FromV8(
       context->GetIsolate(), iter->second.Get(context->GetIsolate()), &emitter);
   CHECK(emitter);
   return emitter->GetNumListeners();
 }
 
 }  // namespace extensions