[Extensions Bindings] Add Events support

extensions/renderer/api_binding_unittest.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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "extensions/renderer/api_binding.h"
 #include "extensions/renderer/api_binding_test_util.h"
+#include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "gin/converter.h"
 #include "gin/public/context_holder.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/test/v8_test.h"
 #include "gin/try_catch.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
@@ skipping 172 matching lines @@
   }
 
   arguments_.reset();
 }
 
 TEST_F(APIBindingTest, Test) {
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
-      "test", *functions, nullptr,
+      "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingTest::OnFunctionCall, base::Unretained(this)),
       &refs);
   EXPECT_TRUE(refs.empty());
 
   v8::Isolate* isolate = instance_->isolate();
 
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, context_);
 
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object =
-      binding.CreateInstance(context, isolate, base::Bind(&AllowAllAPIs));
+      binding.CreateInstance(context, isolate, &event_handler,
+                             base::Bind(&AllowAllAPIs));
 
   ExpectPass(binding_object, "obj.oneString('foo');", "['foo']");
   ExpectPass(binding_object, "obj.oneString('');", "['']");
   ExpectFailure(binding_object, "obj.oneString(1);", kError);
   ExpectFailure(binding_object, "obj.oneString();", kError);
   ExpectFailure(binding_object, "obj.oneString({});", kError);
   ExpectFailure(binding_object, "obj.oneString('foo', 'bar');", kError);
 
   ExpectPass(binding_object, "obj.stringAndInt('foo', 42);", "['foo',42]");
   ExpectPass(binding_object, "obj.stringAndInt('foo', -1);", "['foo',-1]");
@@ skipping 69 matching lines @@
       "   }]"
       "}]";
 
   std::unique_ptr<base::ListValue> functions =
       ListValueFromString(kRefFunctions);
   ASSERT_TRUE(functions);
   std::unique_ptr<base::ListValue> types = ListValueFromString(kTypes);
   ASSERT_TRUE(types);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
-      "test", *functions, types.get(),
+      "test", *functions, types.get(), nullptr,
       base::Bind(&APIBindingTest::OnFunctionCall, base::Unretained(this)),
       &refs);
   EXPECT_EQ(2u, refs.size());
   EXPECT_TRUE(base::ContainsKey(refs, "refObj"));
   EXPECT_TRUE(base::ContainsKey(refs, "refEnum"));
 
   v8::Isolate* isolate = instance_->isolate();
 
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, context_);
 
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object =
-      binding.CreateInstance(context, isolate, base::Bind(&AllowAllAPIs));
+      binding.CreateInstance(context, isolate, &event_handler,
+                             base::Bind(&AllowAllAPIs));
 
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo'})",
              "[{'prop1':'foo'}]");
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 2})",
              "[{'prop1':'foo','prop2':2}]");
   ExpectFailure(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
                 kError);
   ExpectPass(binding_object, "obj.takesRefEnum('alpha')", "['alpha']");
   ExpectPass(binding_object, "obj.takesRefEnum('beta')", "['beta']");
   ExpectFailure(binding_object, "obj.takesRefEnum('gamma')", kError);
@@ skipping 12 matching lines @@
       "  'parameters': []"
       "}, {"
       "  'name': 'restrictedTwo',"
       "  'parameters': []"
       "}]";
   std::unique_ptr<base::ListValue> functions =
       ListValueFromString(kRestrictedFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
-      "test", *functions, nullptr,
+      "test", *functions, nullptr, nullptr,
       base::Bind(&APIBindingTest::OnFunctionCall, base::Unretained(this)),
       &refs);
 
   v8::Isolate* isolate = instance_->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate, context_);
 
   auto is_available = [](const std::string& name) {
     std::set<std::string> functions = {"test.allowedOne", "test.allowedTwo",
                                        "test.restrictedOne",
                                        "test.restrictedTwo"};
     EXPECT_TRUE(functions.count(name));
     return name == "test.allowedOne" || name == "test.allowedTwo";
   };
 
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object =
-      binding.CreateInstance(context, isolate, base::Bind(is_available));
+      binding.CreateInstance(context, isolate, &event_handler,
+                             base::Bind(is_available));
 
   auto is_defined = [&binding_object, context](const std::string& name) {
     v8::Local<v8::Value> val =
         GetPropertyFromObject(binding_object, context, name);
     EXPECT_FALSE(val.IsEmpty());
     return !val->IsUndefined() && !val->IsNull();
   };
 
   EXPECT_TRUE(is_defined("allowedOne"));
   EXPECT_TRUE(is_defined("allowedTwo"));
   EXPECT_FALSE(is_defined("restrictedOne"));
   EXPECT_FALSE(is_defined("restrictedTwo"));
 }
 
+// Tests that events specified in the API are created as properties of the API
+// object.
+TEST_F(APIBindingTest, TestEventCreation) {
+  const char kEvents[] = "[{'name': 'onFoo'}, {'name': 'onBar'}]";
+  std::unique_ptr<base::ListValue> events = ListValueFromString(kEvents);
+  ASSERT_TRUE(events);
+  std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
+  ASSERT_TRUE(functions);
+  ArgumentSpec::RefMap refs;
+  APIBinding binding(
+      "test", *functions, nullptr, events.get(),
+      base::Bind(&APIBindingTest::OnFunctionCall, base::Unretained(this)),
+      &refs);
+
+  v8::Isolate* isolate = instance_->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Context> context =
+      v8::Local<v8::Context>::New(isolate, context_);
+
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
+  v8::Local<v8::Object> binding_object =
+      binding.CreateInstance(context, isolate, &event_handler,
+                             base::Bind(&AllowAllAPIs));
+
+  // Event behavior is tested in the APIEventHandler unittests as well as the
+  // APIBindingsSystem tests, so we really only need to check that the events
+  // are being initialized on the object.
+  v8::Maybe<bool> has_on_foo =
+      binding_object->Has(context, gin::StringToV8(isolate, "onFoo"));
+  EXPECT_TRUE(has_on_foo.IsJust());
+  EXPECT_TRUE(has_on_foo.FromJust());
+
+  v8::Maybe<bool> has_on_bar =
+      binding_object->Has(context, gin::StringToV8(isolate, "onBar"));
+  EXPECT_TRUE(has_on_bar.IsJust());
+  EXPECT_TRUE(has_on_bar.FromJust());
+
+  v8::Maybe<bool> has_on_baz =
+      binding_object->Has(context, gin::StringToV8(isolate, "onBaz"));
+  EXPECT_TRUE(has_on_baz.IsJust());
+  EXPECT_FALSE(has_on_baz.FromJust());
+}
+
 }  // namespace extensions