[Extensions Bindings] Handle updating context permissions

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 "extensions/renderer/api_binding.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 51 matching lines @@
     "  'name': 'intAndCallback',"
     "  'parameters': [{"
     "    'name': 'int',"
     "    'type': 'integer'"
     "  }, {"
     "    'name': 'callback',"
     "    'type': 'function'"
     "  }]"
     "}]";
 
-bool AllowAllAPIs(const std::string& name) {
+bool AllowAllFeatures(v8::Local<v8::Context> context, const std::string& name) {
   return true;
 }
 
 void OnEventListenersChanged(const std::string& event_name,
                              binding::EventListenersChanged change,
                              const base::DictionaryValue* filter,
                              bool was_manual,
                              v8::Local<v8::Context> context) {}
 
 }  // namespace
@@ skipping 58 matching lines @@
   void SetHooksDelegate(
       std::unique_ptr<APIBindingHooksDelegate> hooks_delegate) {
     binding_hooks_delegate_ = std::move(hooks_delegate);
     ASSERT_TRUE(binding_hooks_delegate_);
   }
 
   void SetCreateCustomType(const APIBinding::CreateCustomType& callback) {
     create_custom_type_ = callback;
   }
 
+  void SetAvailabilityCallback(
+      const APIBinding::AvailabilityCallback& callback) {
+    availability_callback_ = callback;
+  }
+
   void InitializeBinding() {
     if (!binding_hooks_) {
       binding_hooks_ = base::MakeUnique<APIBindingHooks>(
           kBindingName, binding::RunJSFunctionSync());
     }
     if (binding_hooks_delegate_)
       binding_hooks_->SetDelegate(std::move(binding_hooks_delegate_));
+    if (!availability_callback_)
+      availability_callback_ = base::Bind(&AllowAllFeatures);
     event_handler_ = base::MakeUnique<APIEventHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         base::Bind(&OnEventListenersChanged));
     binding_ = base::MakeUnique<APIBinding>(
         kBindingName, binding_functions_.get(), binding_types_.get(),
         binding_events_.get(), binding_properties_.get(), create_custom_type_,
-        std::move(binding_hooks_), &type_refs_, request_handler_.get(),
-        event_handler_.get());
+        availability_callback_, std::move(binding_hooks_), &type_refs_,
+        request_handler_.get(), event_handler_.get());
     EXPECT_EQ(!binding_types_.get(), type_refs_.empty());
   }
 
   void ExpectPass(v8::Local<v8::Object> object,
                   const std::string& script_source,
                   const std::string& expected_json_arguments_single_quotes,
                   bool expect_callback) {
     ExpectPass(MainContext(), object, script_source,
                expected_json_arguments_single_quotes, expect_callback);
   }
@@ skipping 47 matching lines @@
   std::unique_ptr<APIRequestHandler> request_handler_;
   APITypeReferenceMap type_refs_;
 
   std::unique_ptr<base::ListValue> binding_functions_;
   std::unique_ptr<base::ListValue> binding_events_;
   std::unique_ptr<base::ListValue> binding_types_;
   std::unique_ptr<base::DictionaryValue> binding_properties_;
   std::unique_ptr<APIBindingHooks> binding_hooks_;
   std::unique_ptr<APIBindingHooksDelegate> binding_hooks_delegate_;
   APIBinding::CreateCustomType create_custom_type_;
+  APIBinding::AvailabilityCallback availability_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(APIBindingUnittest);
 };
 
 void APIBindingUnittest::RunTest(v8::Local<v8::Context> context,
                                  v8::Local<v8::Object> object,
                                  const std::string& script_source,
                                  bool should_pass,
                                  const std::string& expected_json_arguments,
                                  bool expect_callback,
@@ skipping 21 matching lines @@
 
   last_request_.reset();
 }
 
 TEST_F(APIBindingUnittest, TestEmptyAPI) {
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
   EXPECT_EQ(
       0u,
       binding_object->GetOwnPropertyNames(context).ToLocalChecked()->Length());
 }
 
 // Tests the basic call -> request flow of the API binding (ensuring that
 // functions are set up correctly and correctly enforced).
 TEST_F(APIBindingUnittest, TestBasicAPICalls) {
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // Argument parsing is tested primarily in APISignature and ArgumentSpec
   // tests, so do a few quick sanity checks...
   ExpectPass(binding_object, "obj.oneString('foo');", "['foo']", false);
   ExpectFailure(
       binding_object, "obj.oneString(1);",
       InvocationError(
           "test.oneString", "string str",
           ArgumentError("str", InvalidType(kTypeString, kTypeInteger))));
   ExpectPass(binding_object, "obj.stringAndInt('foo', 1)", "['foo',1]", false);
@@ skipping 29 matching lines @@
       "  'type': 'string',"
       "  'enum': [{'name': 'omega'}]"
       "}]";
 
   SetTypes(kTypes);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   const char kExpected[] =
       "{'ALPHA':'alpha','CAMEL_CASE':'camelCase','HYPHEN_ATED':'Hyphen-ated',"
       "'NUMS123':'nums123','SCREAMING':'SCREAMING','_42NUMS':'42nums'}";
   EXPECT_EQ(ReplaceSingleQuotes(kExpected),
             GetStringPropertyFromObject(binding_object, context, "first"));
   EXPECT_EQ(ReplaceSingleQuotes("{'OMEGA':'omega'}"),
             GetStringPropertyFromObject(binding_object, context, "last"));
 }
 
 // Test that empty enum entries are (unfortunately) allowed.
 TEST_F(APIBindingUnittest, EnumWithEmptyEntry) {
   const char kTypes[] =
       "[{"
       "  'id': 'enumWithEmpty',"
       "  'type': 'string',"
       "  'enum': [{'name': ''}, {'name': 'other'}]"
       "}]";
 
   SetTypes(kTypes);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   EXPECT_EQ(
       "{\"\":\"\",\"OTHER\":\"other\"}",
       GetStringPropertyFromObject(binding_object, context, "enumWithEmpty"));
 }
 
 // Test that type references are correctly set up in the API.
 TEST_F(APIBindingUnittest, TypeRefsTest) {
   const char kTypes[] =
       "[{"
@@ skipping 26 matching lines @@
   SetFunctions(kRefFunctions);
   SetTypes(kTypes);
   InitializeBinding();
   EXPECT_EQ(2u, type_refs().size());
   EXPECT_TRUE(type_refs().GetSpec("refObj"));
   EXPECT_TRUE(type_refs().GetSpec("refEnum"));
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // Parsing in general is tested in APISignature and ArgumentSpec tests, but
   // we test that the binding a) correctly finds the definitions, and b) accepts
   // properties from the API object.
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo'})",
              "[{'prop1':'foo'}]", false);
   ExpectFailure(
       binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
       InvocationError(
           "test.takesRefObj", "refObj o",
@@ skipping 21 matching lines @@
       "  'name': 'restrictedOne',"
       "  'parameters': []"
       "}, {"
       "  'name': 'restrictedTwo',"
       "  'parameters': []"
       "}]";
   SetFunctions(kFunctions);
   const char kEvents[] =
       "[{'name': 'allowedEvent'}, {'name': 'restrictedEvent'}]";
   SetEvents(kEvents);
-  InitializeBinding();
-
-  v8::HandleScope handle_scope(isolate());
-  v8::Local<v8::Context> context = MainContext();
-
-  auto is_available = [](const std::string& name) {
+  auto is_available = [](v8::Local<v8::Context> context,
+                         const std::string& name) {
     std::set<std::string> allowed = {"test.allowedOne", "test.allowedTwo",
                                      "test.allowedEvent"};
     std::set<std::string> restricted = {
         "test.restrictedOne", "test.restrictedTwo", "test.restrictedEvent"};
     EXPECT_TRUE(allowed.count(name) || restricted.count(name)) << name;
     return allowed.count(name) != 0;
   };
+  SetAvailabilityCallback(base::Bind(is_available));
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(is_available));
+  InitializeBinding();
+
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = MainContext();
+
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   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_TRUE(is_defined("allowedEvent"));
   EXPECT_FALSE(is_defined("restrictedOne"));
   EXPECT_FALSE(is_defined("restrictedTwo"));
   EXPECT_FALSE(is_defined("restrictedEvent"));
 }
 
 // Tests that events specified in the API are created as properties of the API
 // object.
 TEST_F(APIBindingUnittest, TestEventCreation) {
   SetEvents("[{'name': 'onFoo'}, {'name': 'onBar'}]");
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // 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 =
@@ skipping 16 matching lines @@
       "    'properties': {"
       "      'subprop1': { 'value': 'some value', 'type': 'string' },"
       "      'subprop2': { 'value': true, 'type': 'boolean' }"
       "    }"
       "  }"
       "}");
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
   EXPECT_EQ("17",
             GetStringPropertyFromObject(binding_object, context, "prop1"));
   EXPECT_EQ(R"({"subprop1":"some value","subprop2":true})",
             GetStringPropertyFromObject(binding_object, context, "prop2"));
 }
 
 TEST_F(APIBindingUnittest, TestRefProperties) {
   SetProperties(
       "{"
       "  'alpha': {"
@@ skipping 30 matching lines @@
     }
     return result;
   };
 
   SetCreateCustomType(base::Bind(create_custom_type));
 
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
   EXPECT_EQ(R"({"alphaProp":"alphaVal"})",
             GetStringPropertyFromObject(binding_object, context, "alpha"));
   EXPECT_EQ(
       R"({"betaProp":"betaVal"})",
       GetStringPropertyFromObject(binding_object, context, "beta"));
 }
 
 TEST_F(APIBindingUnittest, TestDisposedContext) {
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   v8::Local<v8::Function> func =
       FunctionFromString(context, "(function(obj) { obj.oneString('foo'); })");
   v8::Local<v8::Value> argv[] = {binding_object};
   DisposeContext(context);
   RunFunction(func, context, arraysize(argv), argv);
   EXPECT_FALSE(HandlerWasInvoked());
   // This test passes if this does not crash, even under AddressSanitizer
   // builds.
 }
 
 TEST_F(APIBindingUnittest, MultipleContexts) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context_a = MainContext();
   v8::Local<v8::Context> context_b = AddContext();
 
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object_a =
-      binding()->CreateInstance(context_a, base::Bind(&AllowAllAPIs));
-  v8::Local<v8::Object> binding_object_b =
-      binding()->CreateInstance(context_b, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object_a = binding()->CreateInstance(context_a);
+  v8::Local<v8::Object> binding_object_b = binding()->CreateInstance(context_b);
 
   ExpectPass(context_a, binding_object_a, "obj.oneString('foo');", "['foo']",
              false);
   ExpectPass(context_b, binding_object_b, "obj.oneString('foo');", "['foo']",
              false);
   DisposeContext(context_a);
   ExpectPass(context_b, binding_object_b, "obj.oneString('foo');", "['foo']",
              false);
 }
 
@@ skipping 19 matching lines @@
     return result;
   };
   hooks->AddHandler("test.oneString", base::Bind(hook, &did_call));
   SetHooksDelegate(std::move(hooks));
 
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // First try calling the oneString() method, which has a custom hook
   // installed.
   v8::Local<v8::Function> func =
       FunctionFromString(context, "(function(obj) { obj.oneString('foo'); })");
   v8::Local<v8::Value> args[] = {binding_object};
   RunFunction(func, context, 1, args);
   EXPECT_TRUE(did_call);
 
   // Other methods, like stringAndInt(), should behave normally.
@@ skipping 19 matching lines @@
     v8::Local<v8::Function> function =
         FunctionFromString(context, kRegisterHook);
     v8::Local<v8::Value> args[] = {js_hooks};
     RunFunctionOnGlobal(function, context, arraysize(args), args);
   }
 
   SetFunctions(kFunctions);
   SetHooks(std::move(hooks));
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // First try calling with an invalid invocation. An error should be raised and
   // the hook should never have been called, since the arguments didn't match.
   ExpectFailure(
       binding_object, "obj.oneString(1);",
       InvocationError(
           "test.oneString", "string str",
           ArgumentError("str", InvalidType(kTypeString, kTypeInteger))));
   v8::Local<v8::Value> property =
       GetPropertyFromObject(context->Global(), context, "requestArguments");
@@ skipping 34 matching lines @@
       "})";
   v8::Local<v8::Object> js_hooks = hooks->GetJSHookInterface(context);
   v8::Local<v8::Function> function = FunctionFromString(context, kRegisterHook);
   v8::Local<v8::Value> args[] = {js_hooks};
   RunFunctionOnGlobal(function, context, arraysize(args), args);
 
   SetHooks(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // Call the method with a hook. Since the hook updates arguments before
   // validation, we should be able to pass in invalid arguments and still
   // have the hook called.
   ExpectFailure(
       binding_object, "obj.oneString(false);",
       InvocationError(
           "test.oneString", "string str",
           ArgumentError("str", InvalidType(kTypeString, kTypeBoolean))));
   EXPECT_EQ("[false]", GetStringPropertyFromObject(
@@ skipping 40 matching lines @@
     v8::Local<v8::Function> function =
         FunctionFromString(context, kRegisterHook);
     v8::Local<v8::Value> args[] = {js_hooks};
     RunFunctionOnGlobal(function, context, arraysize(args), args);
   }
 
   SetHooks(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   v8::Local<v8::Function> function =
       FunctionFromString(context,
                          "(function(obj) { return obj.oneString('ping'); })");
   v8::Local<v8::Value> args[] = {binding_object};
   RunFunctionAndExpectError(function, context, v8::Undefined(isolate()),
                             arraysize(args), args,
                             "Uncaught Error: Custom Hook Error");
 
   // Other methods, like stringAndInt(), should behave normally.
@@ skipping 20 matching lines @@
     v8::Local<v8::Function> function =
         FunctionFromString(context, kRegisterHook);
     v8::Local<v8::Value> args[] = {js_hooks};
     RunFunctionOnGlobal(function, context, arraysize(args), args);
   }
 
   SetHooks(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   v8::Local<v8::Function> function =
       FunctionFromString(context,
                          "(function(obj) { return obj.oneString('ping'); })");
   v8::Local<v8::Value> args[] = {binding_object};
   v8::Local<v8::Value> result =
       RunFunction(function, context, arraysize(args), args);
   ASSERT_FALSE(result.IsEmpty());
   std::unique_ptr<base::Value> json_result = V8ToBaseValue(result, context);
   ASSERT_TRUE(json_result);
@@ skipping 39 matching lines @@
     v8::Local<v8::Function> function =
         FunctionFromString(context, kRegisterHook);
     v8::Local<v8::Value> args[] = {js_hooks};
     RunFunctionOnGlobal(function, context, arraysize(args), args);
   }
 
   SetHooks(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   v8::Local<v8::Function> function =
       FunctionFromString(context,
                          "(function(obj) { return obj.oneString('ping'); })");
   v8::Local<v8::Value> args[] = {binding_object};
   RunFunctionAndExpectError(function, context, v8::Undefined(isolate()),
                             arraysize(args), args,
                             "Uncaught Error: Custom Hook Error");
 }
 
@@ skipping 28 matching lines @@
     result.return_value =
         gin::StringToV8(context->GetIsolate(), arg_value + " pong");
     return result;
   };
   hooks->AddHandler("test.oneString", base::Bind(hook, &did_call));
 
   SetHooksDelegate(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   {
     // Test an invocation that we expect to throw an exception.
     v8::Local<v8::Function> function =
         FunctionFromString(
             context, "(function(obj) { return obj.oneString('throw'); })");
     v8::Local<v8::Value> args[] = {binding_object};
     RunFunctionAndExpectError(function, context, v8::Undefined(isolate()),
                               arraysize(args), args,
                               "Uncaught Error: Custom Hook Error");
@@ skipping 34 matching lines @@
     v8::Local<v8::Function> function =
         FunctionFromString(context, kRegisterHook);
     v8::Local<v8::Value> args[] = {js_hooks};
     RunFunctionOnGlobal(function, context, arraysize(args), args);
   }
 
   SetHooks(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // Try calling the method with an invalid signature. Since it's invalid, we
   // should never enter the hook.
   ExpectFailure(
       binding_object, "obj.oneString(false);",
       InvocationError(
           "test.oneString", "string str",
           ArgumentError("str", InvalidType(kTypeString, kTypeBoolean))));
   EXPECT_EQ("undefined", GetStringPropertyFromObject(
                              context->Global(), context, "requestArguments"));
@@ skipping 30 matching lines @@
     v8::Local<v8::Function> function =
         FunctionFromString(context, kRegisterHook);
     v8::Local<v8::Value> args[] = {js_hooks};
     RunFunctionOnGlobal(function, context, arraysize(args), args);
   }
 
   SetHooks(std::move(hooks));
   SetFunctions(kFunctions);
   InitializeBinding();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // Call the method with a valid signature. The hook should be entered and
   // manipulate the arguments.
   ExpectPass(binding_object, "obj.oneString('ping');", "[{}]", false);
 }
 
 // Test that user gestures are properly recorded when calling APIs.
 TEST_F(APIBindingUnittest, TestUserGestures) {
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   v8::Local<v8::Function> function =
       FunctionFromString(context, "(function(obj) { obj.oneString('foo');})");
   ASSERT_FALSE(function.IsEmpty());
 
   v8::Local<v8::Value> argv[] = {binding_object};
   RunFunction(function, context, arraysize(argv), argv);
   ASSERT_TRUE(last_request());
   EXPECT_FALSE(last_request()->has_user_gesture);
   reset_last_request();
@@ skipping 29 matching lines @@
       "    {'name': 'url', 'type': 'array', 'items': {'type': 'any'}}"
       "  ],"
       "  'parameters': []"
       "}]";
   SetEvents(kEvents);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   const char kAddFilteredListener[] =
       "(function(evt) {\n"
       "  evt.addListener(function() {},\n"
       "                  {url: [{pathContains: 'simple2.html'}]});\n"
       "})";
   v8::Local<v8::Function> function =
       FunctionFromString(context, kAddFilteredListener);
   ASSERT_FALSE(function.IsEmpty());
 
@@ skipping 32 matching lines @@
                          gin::ConvertToV8(isolate, 42));
   };
   hooks->SetTemplateInitializer(base::Bind(hook));
   SetHooksDelegate(std::move(hooks));
 
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
+  v8::Local<v8::Object> binding_object = binding()->CreateInstance(context);
 
   // The extra property should be present on the binding object.
   EXPECT_EQ("42", GetStringPropertyFromObject(binding_object, context,
                                               "hookedProperty"));
   // Sanity check: other values should still be there.
   EXPECT_EQ("function",
             GetStringPropertyFromObject(binding_object, context, "oneString"));
 }
 
 }  // namespace extensions