[Extensions Bindings] Introduce a supportsLazyListeners property

extensions/renderer/bindings/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/bindings/api_event_handler.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/supports_user_data.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "extensions/renderer/bindings/api_event_listeners.h"
 #include "extensions/renderer/bindings/event_emitter.h"
 #include "gin/handle.h"
 #include "gin/per_context_data.h"
 
 namespace extensions {
 
 namespace {
 
 void DoNothingOnListenersChanged(binding::EventListenersChanged change,
                                  const base::DictionaryValue* filter,
-                                 bool was_manual,
+                                 bool update_lazy_listeners,
                                  v8::Local<v8::Context> context) {}
 
 const char kExtensionAPIEventPerContextKey[] = "extension_api_events";
 
 struct APIEventPerContextData : public base::SupportsUserData::Data {
   APIEventPerContextData(v8::Isolate* isolate) : isolate(isolate) {}
   ~APIEventPerContextData() override {
     DCHECK(emitters.empty())
         << "|emitters| should have been cleared by InvalidateContext()";
     DCHECK(massagers.empty())
@@ skipping 73 matching lines @@
     ExceptionHandler* exception_handler)
     : call_js_(call_js),
       call_js_sync_(call_js_sync),
       listeners_changed_(listeners_changed),
       exception_handler_(exception_handler) {}
 APIEventHandler::~APIEventHandler() {}
 
 v8::Local<v8::Object> APIEventHandler::CreateEventInstance(
     const std::string& event_name,
     bool supports_filters,
+    bool supports_lazy_listeners,
     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_);
+        updated, event_name, max_listeners, supports_lazy_listeners,
+        &event_filter_);
   } else {
-    listeners =
-        base::MakeUnique<UnfilteredEventListeners>(updated, max_listeners);
+    listeners = base::MakeUnique<UnfilteredEventListeners>(
+        updated, max_listeners, supports_lazy_listeners);
   }
 
   gin::Handle<EventEmitter> emitter_handle = gin::CreateHandle(
       context->GetIsolate(),
       new EventEmitter(supports_filters, std::move(listeners), call_js_,
                        call_js_sync_, exception_handler_));
   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);
+          base::Bind(&DoNothingOnListenersChanged), binding::kNoListenerMax,
+          false);
   gin::Handle<EventEmitter> emitter_handle = gin::CreateHandle(
       context->GetIsolate(),
       new EventEmitter(supports_filters, std::move(listeners), call_js_,
                        call_js_sync_, exception_handler_));
   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;
 }
@@ skipping 148 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