[Extensions Bindings] Add Events support

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/common/extension_api.h"
+#include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "gin/arguments.h"
 #include "gin/per_context_data.h"
 
 namespace extensions {
 
 namespace {
 
 const char kExtensionAPIPerContextKey[] = "extension_api_binding";
 
@@ skipping 133 matching lines @@
 }
 
 }  // namespace
 
 APIBinding::APIPerContextData::APIPerContextData() {}
 APIBinding::APIPerContextData::~APIPerContextData() {}
 
 APIBinding::APIBinding(const std::string& api_name,
                        const base::ListValue& function_definitions,
                        const base::ListValue* type_definitions,
+                       const base::ListValue* event_definitions,
                        const APIMethodCallback& callback,
                        ArgumentSpec::RefMap* type_refs)
     : api_name_(api_name),
       method_callback_(callback),
       type_refs_(type_refs),
       weak_factory_(this) {
   DCHECK(!method_callback_.is_null());
   for (const auto& func : function_definitions) {
     const base::DictionaryValue* func_dict = nullptr;
     CHECK(func->GetAsDictionary(&func_dict));
     std::string name;
     CHECK(func_dict->GetString("name", &name));
     std::unique_ptr<APISignature> spec = GetAPISignature(*func_dict);
     signatures_[name] = std::move(spec);
   }
   if (type_definitions) {
     for (const auto& type : *type_definitions) {
       const base::DictionaryValue* type_dict = nullptr;
       CHECK(type->GetAsDictionary(&type_dict));
       std::string id;
       CHECK(type_dict->GetString("id", &id));
       DCHECK(type_refs->find(id) == type_refs->end());
       // TODO(devlin): refs are sometimes preceeded by the API namespace; we
       // might need to take that into account.
       (*type_refs)[id] = base::MakeUnique<ArgumentSpec>(*type_dict);
     }
   }
+  if (event_definitions) {
+    event_names_.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));
+      event_names_.push_back(std::move(name));
+    }
+  }
 }
 
 APIBinding::~APIBinding() {}
 
 v8::Local<v8::Object> APIBinding::CreateInstance(
     v8::Local<v8::Context> context,
     v8::Isolate* isolate,
+    APIEventHandler* event_handler,
     const AvailabilityCallback& is_available) {
   // TODO(devlin): APIs may change depending on which features are available,
   // but we should be able to cache the unconditional methods on an object
   // template, create the object, and then add any conditional methods. Ideally,
   // this information should be available on the generated API specification.
   v8::Local<v8::Object> object = v8::Object::New(isolate);
   gin::PerContextData* per_context_data = gin::PerContextData::From(context);
   DCHECK(per_context_data);
   APIPerContextData* data = static_cast<APIPerContextData*>(
       per_context_data->GetUserData(kExtensionAPIPerContextKey));
@@ skipping 19 matching lines @@
                           v8::External::New(isolate, handler_callback.get()),
                           0, v8::ConstructorBehavior::kThrow);
     data->context_callbacks.push_back(std::move(handler_callback));
     v8::Maybe<bool> success = object->CreateDataProperty(
         context, gin::StringToSymbol(isolate, sig.first),
         maybe_function.ToLocalChecked());
     DCHECK(success.IsJust());
     DCHECK(success.FromJust());
   }
 
+  for (const std::string& event_name : event_names_) {
+    std::string full_event_name =
+        base::StringPrintf("%s.%s", api_name_.c_str(), event_name.c_str());
+    v8::Local<v8::Object> event =
+        event_handler->CreateEventInstance(full_event_name, context);
+    DCHECK(!event.IsEmpty());
+    v8::Maybe<bool> success = object->CreateDataProperty(
+        context, gin::StringToSymbol(isolate, event_name), event);
+    DCHECK(success.IsJust());
+    DCHECK(success.FromJust());
+  }
+
   return object;
 }
 
 void APIBinding::HandleCall(const std::string& name,
                             const APISignature* signature,
                             gin::Arguments* arguments) {
   std::string error;
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
   std::unique_ptr<base::ListValue> parsed_arguments;
@@ skipping 13 matching lines @@
     return;
   }
 
   // Since this is called synchronously from the JS entry point,
   // GetCurrentContext() should always be correct.
   method_callback_.Run(name, std::move(parsed_arguments), isolate,
                        isolate->GetCurrentContext(), callback);
 }
 
 }  // namespace extensions