[Extenisons Bindings] Support `unmanaged` property for events

extensions/renderer/api_binding.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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 87 matching lines @@
 };
 
 // TODO(devlin): Maybe separate EventData into two classes? Rules, actions, and
 // conditions should never be present on vanilla events.
 struct APIBinding::EventData {
   EventData(std::string exposed_name,
             std::string full_name,
             bool supports_filters,
             bool supports_rules,
             int max_listeners,
+            bool notify_on_change,
             std::vector<std::string> actions,
             std::vector<std::string> conditions,
             APIBinding* binding)
       : exposed_name(std::move(exposed_name)),
         full_name(std::move(full_name)),
         supports_filters(supports_filters),
         supports_rules(supports_rules),
         max_listeners(max_listeners),
+        notify_on_change(notify_on_change),
         actions(std::move(actions)),
         conditions(std::move(conditions)),
         binding(binding) {}
 
   // The name of the event on the API object (e.g. onCreated).
   std::string exposed_name;
 
   // The fully-specified name of the event (e.g. tabs.onCreated).
   std::string full_name;
 
   // Whether the event supports filters.
   bool supports_filters;
 
   // Whether the event supports rules.
   bool supports_rules;
 
   // The maximum number of listeners this event supports.
   int max_listeners;
 
+  // Whether to notify the browser of listener changes.
+  bool notify_on_change;
+
   // The associated actions and conditions for declarative events.
   std::vector<std::string> actions;
   std::vector<std::string> conditions;
 
   // The associated APIBinding. This raw pointer is safe because the
   // EventData is only accessed from the callbacks associated with the
   // APIBinding, and both the APIBinding and APIEventHandler are owned by the
   // same object (the APIBindingsSystem).
   APIBinding* binding;
 };
@@ skipping 114 matching lines @@
       std::string full_name =
           base::StringPrintf("%s.%s", api_name_.c_str(), name.c_str());
       const base::ListValue* filters = nullptr;
       bool supports_filters =
           event_dict->GetList("filters", &filters) && !filters->empty();
 
       std::vector<std::string> rule_actions;
       std::vector<std::string> rule_conditions;
       const base::DictionaryValue* options = nullptr;
       bool supports_rules = false;
+      bool notify_on_change = true;
       int max_listeners = binding::kNoListenerMax;
       if (event_dict->GetDictionary("options", &options)) {
         bool temp_supports_filters = false;
         // TODO(devlin): For some reason, schemas indicate supporting filters
         // either through having a 'filters' property *or* through having
         // a 'supportsFilters' property. We should clean that up.
         supports_filters |=
             (options->GetBoolean("supportsFilters", &temp_supports_filters) &&
              temp_supports_filters);
         if (options->GetBoolean("supportsRules", &supports_rules) &&
             supports_rules) {
           bool supports_listeners = false;
           DCHECK(options->GetBoolean("supportsListeners", &supports_listeners));
           DCHECK(!supports_listeners)
               << "Events cannot support rules and listeners.";
           auto get_values = [options](base::StringPiece name,
                                       std::vector<std::string>* out_value) {
             const base::ListValue* list = nullptr;
             CHECK(options->GetList(name, &list));
             for (const auto& entry : *list) {
               DCHECK(entry.is_string());
               out_value->push_back(entry.GetString());
             }
           };
           get_values("actions", &rule_actions);
           get_values("conditions", &rule_conditions);
         }
 
         options->GetInteger("maxListeners", &max_listeners);
+        bool unmanaged = false;
+        if (options->GetBoolean("unmanaged", &unmanaged))
+          notify_on_change = !unmanaged;
       }
 
       events_.push_back(base::MakeUnique<EventData>(
           std::move(name), std::move(full_name), supports_filters,
-          supports_rules, max_listeners, std::move(rule_actions),
-          std::move(rule_conditions), this));
+          supports_rules, max_listeners, notify_on_change,
+          std::move(rule_actions), std::move(rule_conditions), this));
     }
   }
 }
 
 APIBinding::~APIBinding() {}
 
 v8::Local<v8::Object> APIBinding::CreateInstance(
     v8::Local<v8::Context> context) {
   DCHECK(IsContextValid(context));
   v8::Isolate* isolate = context->GetIsolate();
@@ skipping 161 matching lines @@
   } else if (event_data->supports_rules) {
     gin::Handle<DeclarativeEvent> event = gin::CreateHandle(
         isolate, new DeclarativeEvent(
                      event_data->full_name, event_data->binding->type_refs_,
                      event_data->binding->request_handler_, event_data->actions,
                      event_data->conditions));
     retval = event.ToV8();
   } else {
     retval = event_data->binding->event_handler_->CreateEventInstance(
         event_data->full_name, event_data->supports_filters,
-        event_data->max_listeners, context);
+        event_data->max_listeners, event_data->notify_on_change, context);
   }
   info.GetReturnValue().Set(retval);
 }
 
 void APIBinding::GetCustomPropertyObject(
     v8::Local<v8::Name> property_name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = info.Holder()->CreationContext();
@@ skipping 110 matching lines @@
         name, signature->GetExpectedSignature(), error));
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback,
                                  binding::RequestThread::UI);
 }
 
 }  // namespace extensions