[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 176 matching lines @@
   }
 
   arguments_.reset();
 }
 
 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 13 matching lines @@
 
   std::unique_ptr<base::Value> response_args =
       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]");
 }
 

[Devlin, 2017/01/04 15:49:14]

Let's add a new unittest for this.  It's a pretty simple change, but it's also
pretty simple to test. :)  (And currently no other tests pass in null functions,
whereas there are tests that pass in null events/types).

[jbroman, 2017/01/04 19:55:43]

Done.

I added a unit test which passes in null for everything (an empty API), and
checks that no own properties are added to the object.

 }  // namespace extensions