[Extensions Bindings] Make function definitions optional for an API.

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 "extensions/renderer/api_binding.h"
@@ skipping 171 matching lines @@
     ASSERT_TRUE(arguments_) << script_source;
     EXPECT_EQ(expected_json_arguments, ValueToString(*arguments_));
   } else {
     RunFunctionAndExpectError(func, context, 1, argv, expected_error);
     EXPECT_FALSE(arguments_);
   }
 
   arguments_.reset();
 }
 
+TEST_F(APIBindingUnittest, TestEmptyAPI) {
+  ArgumentSpec::RefMap refs;
+  APIBinding binding(
+      "empty", nullptr, nullptr, nullptr,
+      base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
+      base::MakeUnique<APIBindingHooks>(binding::RunJSFunction()), &refs);
+  EXPECT_TRUE(refs.empty());
+
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = ContextLocal();
+
+  APIEventHandler event_handler(
+      base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
+  v8::Local<v8::Object> binding_object = binding.CreateInstance(
+      context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
+  EXPECT_EQ(
+      0u,
+      binding_object->GetOwnPropertyNames(context).ToLocalChecked()->Length());
+}
+
 TEST_F(APIBindingUnittest, Test) {
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
-      "test", *functions, nullptr, nullptr,
+      "test", functions.get(), nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       base::MakeUnique<APIBindingHooks>(binding::RunJSFunction()), &refs);
   EXPECT_TRUE(refs.empty());
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
@@ skipping 80 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(), nullptr,
+      "test", functions.get(), types.get(), nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       base::MakeUnique<APIBindingHooks>(binding::RunJSFunction()), &refs);
   EXPECT_EQ(2u, refs.size());
   EXPECT_TRUE(base::ContainsKey(refs, "refObj"));
   EXPECT_TRUE(base::ContainsKey(refs, "refEnum"));
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
@@ skipping 25 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, nullptr,
+      "test", functions.get(), nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       base::MakeUnique<APIBindingHooks>(binding::RunJSFunction()), &refs);
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   auto is_available = [](const std::string& name) {
     std::set<std::string> functions = {"test.allowedOne", "test.allowedTwo",
                                        "test.restrictedOne",
                                        "test.restrictedTwo"};
@@ skipping 22 matching lines @@
 // Tests that events specified in the API are created as properties of the API
 // object.
 TEST_F(APIBindingUnittest, 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(),
+      "test", functions.get(), nullptr, events.get(),
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       base::MakeUnique<APIBindingHooks>(binding::RunJSFunction()), &refs);
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
@@ skipping 15 matching lines @@
       binding_object->Has(context, gin::StringToV8(isolate(), "onBaz"));
   EXPECT_TRUE(has_on_baz.IsJust());
   EXPECT_FALSE(has_on_baz.FromJust());
 }
 
 TEST_F(APIBindingUnittest, TestDisposedContext) {
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
   APIBinding binding(
-      "test", *functions, nullptr, nullptr,
+      "test", functions.get(), nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       base::MakeUnique<APIBindingHooks>(binding::RunJSFunction()), &refs);
   EXPECT_TRUE(refs.empty());
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
@@ skipping 25 matching lines @@
     *did_call = true;
     EXPECT_EQ(1, arguments->Length());
     std::string argument;
     EXPECT_TRUE(arguments->GetNext(&argument));
     EXPECT_EQ("foo", argument);
     return APIBindingHooks::RequestResult::HANDLED;
   };
   hooks->RegisterHandleRequest("test.oneString", base::Bind(hook, &did_call));
 
   APIBinding binding(
-      "test", *functions, nullptr, nullptr,
+      "test", functions.get(), nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       std::move(hooks), &refs);
   EXPECT_TRUE(refs.empty());
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
@@ skipping 30 matching lines @@
       gin::StringToV8(isolate(), "custom_hook");
   hooks->RegisterJsSource(
       v8::Global<v8::String>(isolate(), source_string),
       v8::Global<v8::String>(isolate(), source_name));
 
   std::unique_ptr<base::ListValue> functions = ListValueFromString(kFunctions);
   ASSERT_TRUE(functions);
   ArgumentSpec::RefMap refs;
 
   APIBinding binding(
-      "test", *functions, nullptr, nullptr,
+      "test", functions.get(), nullptr, nullptr,
       base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
       std::move(hooks), &refs);
   EXPECT_TRUE(refs.empty());
 
   APIEventHandler event_handler(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult));
   v8::Local<v8::Object> binding_object = binding.CreateInstance(
       context, isolate(), &event_handler, base::Bind(&AllowAllAPIs));
 
   // First try calling with an invalid invocation. An error should be raised and
@@ skipping 15 matching lines @@
       GetBaseValuePropertyFromObject(context->Global(), context,
                                      "requestArguments");
   ASSERT_TRUE(response_args);
   EXPECT_EQ("[\"foo\"]", ValueToString(*response_args));
 
   // Other methods, like stringAndInt(), should behave normally.
   ExpectPass(binding_object, "obj.stringAndInt('foo', 42);", "['foo',42]");
 }
 
 }  // namespace extensions