[Extensions Bindings] Introduce a supportsLazyListeners property

extensions/renderer/bindings/api_event_listeners.cc

 // Copyright 2017 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_listeners.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/memory/ptr_util.h"
@@ skipping 61 matching lines @@
   }
 
   *filter_dict = base::DictionaryValue::From(std::move(value));
   return true;
 }
 
 }  // namespace
 
 UnfilteredEventListeners::UnfilteredEventListeners(
     const ListenersUpdated& listeners_updated,
-    int max_listeners)
-    : listeners_updated_(listeners_updated), max_listeners_(max_listeners) {
+    int max_listeners,
+    bool supports_lazy_listeners)
+    : listeners_updated_(listeners_updated),
+      max_listeners_(max_listeners),
+      supports_lazy_listeners_(supports_lazy_listeners) {
   DCHECK(max_listeners_ == binding::kNoListenerMax || max_listeners_ > 0);
 }
 UnfilteredEventListeners::~UnfilteredEventListeners() = default;
 
 bool UnfilteredEventListeners::AddListener(v8::Local<v8::Function> listener,
                                            v8::Local<v8::Object> filter,
                                            v8::Local<v8::Context> context,
                                            std::string* error) {
   // |filter| should be checked before getting here.
   DCHECK(filter.IsEmpty())
       << "Filtered events should use FilteredEventListeners";
 
   if (HasListener(listener))
     return false;
 
   if (max_listeners_ != binding::kNoListenerMax &&
       listeners_.size() >= static_cast<size_t>(max_listeners_)) {
     *error = kErrorTooManyListeners;
     return false;
   }
 
   listeners_.push_back(
       v8::Global<v8::Function>(context->GetIsolate(), listener));
   if (listeners_.size() == 1) {
     listeners_updated_.Run(binding::EventListenersChanged::HAS_LISTENERS,
-                           nullptr, true, context);
+                           nullptr, supports_lazy_listeners_, context);
   }
 
   return true;
 }
 
 void UnfilteredEventListeners::RemoveListener(v8::Local<v8::Function> listener,
                                               v8::Local<v8::Context> context) {
   auto iter = std::find(listeners_.begin(), listeners_.end(), listener);
   if (iter == listeners_.end())
     return;
 
   listeners_.erase(iter);
   if (listeners_.empty()) {
     listeners_updated_.Run(binding::EventListenersChanged::NO_LISTENERS,
-                           nullptr, true, context);
+                           nullptr, supports_lazy_listeners_, context);
   }
 }
 
 bool UnfilteredEventListeners::HasListener(v8::Local<v8::Function> listener) {
   return std::find(listeners_.begin(), listeners_.end(), listener) !=
          listeners_.end();
 }
 
 size_t UnfilteredEventListeners::GetNumListeners() {
   return listeners_.size();
 }
 
 std::vector<v8::Local<v8::Function>> UnfilteredEventListeners::GetListeners(
     const EventFilteringInfo* filter,
     v8::Local<v8::Context> context) {
   std::vector<v8::Local<v8::Function>> listeners;
   listeners.reserve(listeners_.size());
   for (const auto& listener : listeners_)
     listeners.push_back(listener.Get(context->GetIsolate()));
   return listeners;
 }
 
 void UnfilteredEventListeners::Invalidate(v8::Local<v8::Context> context) {
   if (!listeners_.empty()) {
     listeners_.clear();
+    // We don't want to update stored lazy listeners in this case, since the
+    // extension didn't unregister interest in the event.
+    bool update_lazy_listeners = false;
     listeners_updated_.Run(binding::EventListenersChanged::NO_LISTENERS,
-                           nullptr, false, context);
+                           nullptr, update_lazy_listeners, context);
   }
 }
 
 struct FilteredEventListeners::ListenerData {
   bool operator==(v8::Local<v8::Function> other_function) const {
     // Note that we only consider the listener function here, and not the
     // filter. This implies that it's invalid to try and add the same
     // function for multiple filters.
     // TODO(devlin): It's always been this way, but should it be?
     return function == other_function;
   }
 
   v8::Global<v8::Function> function;
   int filter_id;
 };
 
 FilteredEventListeners::FilteredEventListeners(
     const ListenersUpdated& listeners_updated,
     const std::string& event_name,
     int max_listeners,
+    bool supports_lazy_listeners,
     EventFilter* event_filter)
     : listeners_updated_(listeners_updated),
       event_name_(event_name),
       max_listeners_(max_listeners),
+      supports_lazy_listeners_(supports_lazy_listeners),
       event_filter_(event_filter) {}
 FilteredEventListeners::~FilteredEventListeners() = default;
 
 bool FilteredEventListeners::AddListener(v8::Local<v8::Function> listener,
                                          v8::Local<v8::Object> filter,
                                          v8::Local<v8::Context> context,
                                          std::string* error) {
   if (HasListener(listener))
     return false;
 
@@ skipping 15 matching lines @@
     *error = "Could not add listener";
     return false;
   }
 
   const EventMatcher* matcher = event_filter_->GetEventMatcher(filter_id);
   DCHECK(matcher);
   listeners_.push_back(
       {v8::Global<v8::Function>(context->GetIsolate(), listener), filter_id});
   if (value_counter_.Add(*matcher->value())) {
     listeners_updated_.Run(binding::EventListenersChanged::HAS_LISTENERS,
-                           matcher->value(), true, context);
+                           matcher->value(), supports_lazy_listeners_, context);
   }
 
   return true;
 }
 
 void FilteredEventListeners::RemoveListener(v8::Local<v8::Function> listener,
                                             v8::Local<v8::Context> context) {
   auto iter = std::find(listeners_.begin(), listeners_.end(), listener);
   if (iter == listeners_.end())
     return;
@@ skipping 35 matching lines @@
 }
 
 void FilteredEventListeners::InvalidateListener(
     const ListenerData& listener,
     bool was_manual,
     v8::Local<v8::Context> context) {
   EventMatcher* matcher = event_filter_->GetEventMatcher(listener.filter_id);
   DCHECK(matcher);
   if (value_counter_.Remove(*matcher->value())) {
     listeners_updated_.Run(binding::EventListenersChanged::NO_LISTENERS,
-                           matcher->value(), was_manual, context);
+                           matcher->value(),
+                           was_manual && supports_lazy_listeners_, context);
   }
 
   event_filter_->RemoveEventMatcher(listener.filter_id);
 }
 
 }  // namespace extensions