[Reland][Extensions Bindings] Add support for filtered 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 72 matching lines @@
   std::string full_name;
   // The expected API signature.
   const APISignature* signature;
   // The callback used by the v8 function.
   APIBinding::HandlerCallback callback;
 };
 
 struct APIBinding::EventData {
   EventData(std::string exposed_name,
             std::string full_name,
+            bool supports_filters,
             APIEventHandler* event_handler)
       : exposed_name(std::move(exposed_name)),
         full_name(std::move(full_name)),
+        supports_filters(supports_filters),
         event_handler(event_handler) {}
 
   // 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;
   // The associated event handler. 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).
   APIEventHandler* event_handler;
 };
 
 struct APIBinding::CustomPropertyData {
   CustomPropertyData(const std::string& type_name,
                      const std::string& property_name,
@@ skipping 95 matching lines @@
 
   if (event_definitions) {
     events_.reserve(event_definitions->GetSize());
     for (const auto& event : *event_definitions) {
       const base::DictionaryValue* event_dict = nullptr;
       CHECK(event->GetAsDictionary(&event_dict));
       std::string name;
       CHECK(event_dict->GetString("name", &name));
       std::string full_name =
           base::StringPrintf("%s.%s", api_name_.c_str(), name.c_str());
-      events_.push_back(base::MakeUnique<EventData>(
-          std::move(name), std::move(full_name), event_handler));
+      const base::ListValue* filters = nullptr;
+      bool supports_filters =
+          event_dict->GetList("filters", &filters) && !filters->empty();
+      events_.push_back(
+          base::MakeUnique<EventData>(std::move(name), std::move(full_name),
+                                      supports_filters, event_handler));
     }
   }
 }
 
 APIBinding::~APIBinding() {}
 
 v8::Local<v8::Object> APIBinding::CreateInstance(
     v8::Local<v8::Context> context,
     v8::Isolate* isolate,
     const AvailabilityCallback& is_available) {
@@ skipping 139 matching lines @@
   v8::Isolate* isolate = info.GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = info.Holder()->CreationContext();
   if (!IsContextValid(context))
     return;
 
   CHECK(info.Data()->IsExternal());
   auto* event_data =
       static_cast<EventData*>(info.Data().As<v8::External>()->Value());
   info.GetReturnValue().Set(event_data->event_handler->CreateEventInstance(
-      event_data->full_name, context));
+      event_data->full_name, event_data->supports_filters, context));
 }
 
 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();
   if (!IsContextValid(context))
     return;
@@ skipping 74 matching lines @@
   if (invalid_invocation) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback);
 }
 
 }  // namespace extensions