[Extensions Bindings] Handle updating context permissions

extensions/renderer/api_bindings_system_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_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
@@ skipping 73 matching lines @@
 
 const char kGammaAPIName[] = "gamma";
 const char kGammaAPISpec[] =
     "{"
     "  'functions': [{"
     "    'name': 'functionWithExternalRef',"
     "    'parameters': [{ 'name': 'someRef', '$ref': 'alpha.objRef' }]"
     "  }]"
     "}";
 
-bool AllowAllAPIs(const std::string& name) {
+bool AllowAllAPIs(v8::Local<v8::Context> context, const std::string& name) {
   return true;
 }
 
 }  // namespace
 
 APIBindingsSystemTest::APIBindingsSystemTest() {}
 APIBindingsSystemTest::~APIBindingsSystemTest() = default;
 
 void APIBindingsSystemTest::SetUp() {
   APIBindingTest::SetUp();
 
   // Create the fake API schemas.
   for (const auto& api : GetAPIs()) {
     std::unique_ptr<base::DictionaryValue> api_schema =
         DictionaryValueFromString(api.spec);
     ASSERT_TRUE(api_schema);
     api_schemas_[api.name] = std::move(api_schema);
   }
 
   bindings_system_ = base::MakeUnique<APIBindingsSystem>(
       base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
       base::Bind(&RunFunctionOnGlobalAndReturnHandle),
       base::Bind(&APIBindingsSystemTest::GetAPISchema, base::Unretained(this)),
+      base::Bind(&AllowAllAPIs),
       base::Bind(&APIBindingsSystemTest::OnAPIRequest, base::Unretained(this)),
       base::Bind(&APIBindingsSystemTest::OnEventListenersChanged,
                  base::Unretained(this)),
       APILastError(base::Bind(&APIBindingsSystemTest::GetLastErrorParent,
                               base::Unretained(this)),
                    APILastError::AddConsoleError()));
 }
 
 void APIBindingsSystemTest::TearDown() {
   // Dispose all contexts now so that we call WillReleaseContext().
@@ skipping 70 matching lines @@
   v8::Local<v8::Value> argv[] = {object};
   return RunFunction(func, context, 1, argv);
 }
 
 // Tests API object initialization, calling a method on the supplied APIs, and
 // triggering the callback for the request.
 TEST_F(APIBindingsSystemTest, TestInitializationAndCallbacks) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
-  v8::Local<v8::Object> alpha_api = bindings_system()->CreateAPIInstance(
-      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), nullptr);
+  v8::Local<v8::Object> alpha_api =
+      bindings_system()->CreateAPIInstance(kAlphaAPIName, context, nullptr);
   ASSERT_FALSE(alpha_api.IsEmpty());
-  v8::Local<v8::Object> beta_api = bindings_system()->CreateAPIInstance(
-      kBetaAPIName, context, base::Bind(&AllowAllAPIs), nullptr);
+  v8::Local<v8::Object> beta_api =
+      bindings_system()->CreateAPIInstance(kBetaAPIName, context, nullptr);
   ASSERT_FALSE(beta_api.IsEmpty());
 
   {
     // Test a simple call -> response.
     const char kTestCall[] =
         "obj.functionWithCallback('foo', function() {\n"
         "  this.callbackArguments = Array.from(arguments);\n"
         "});";
     CallFunctionOnObject(context, alpha_api, kTestCall);
 
@@ skipping 109 matching lines @@
     return result;
   };
 
   auto test_hooks = base::MakeUnique<APIBindingHooksTestDelegate>();
   test_hooks->AddHandler("alpha.functionWithCallback",
                          base::Bind(hook, &did_call));
   APIBindingHooks* binding_hooks =
       bindings_system()->GetHooksForAPI(kAlphaAPIName);
   binding_hooks->SetDelegate(std::move(test_hooks));
 
-  v8::Local<v8::Object> alpha_api = bindings_system()->CreateAPIInstance(
-      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), nullptr);
+  v8::Local<v8::Object> alpha_api =
+      bindings_system()->CreateAPIInstance(kAlphaAPIName, context, nullptr);
   ASSERT_FALSE(alpha_api.IsEmpty());
 
   {
     // Test a simple call -> response.
     const char kTestCall[] =
         "obj.functionWithCallback('foo', function() {\n"
         "  this.callbackArguments = Array.from(arguments);\n"
         "});";
     CallFunctionOnObject(context, alpha_api, kTestCall);
     EXPECT_TRUE(did_call);
@@ skipping 16 matching lines @@
       "                               firstResult, secondResult) => {\n"
       "    this.methodName = name;\n"
       // TODO(devlin): Currently, we don't actually pass anything useful in for
       // the |request| object. If/when we do, we should test it.
       "    this.results = [firstResult, secondResult];\n"
       "    originalCallback(secondResult);\n"
       "  });\n"
       "})";
 
   APIBindingHooks* hooks = nullptr;
-  v8::Local<v8::Object> alpha_api = bindings_system()->CreateAPIInstance(
-      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), &hooks);
+  v8::Local<v8::Object> alpha_api =
+      bindings_system()->CreateAPIInstance(kAlphaAPIName, context, &hooks);
   ASSERT_FALSE(alpha_api.IsEmpty());
   ASSERT_TRUE(hooks);
   v8::Local<v8::Object> js_hooks = hooks->GetJSHookInterface(context);
   v8::Local<v8::Function> function = FunctionFromString(context, kHook);
   v8::Local<v8::Value> args[] = {js_hooks};
   RunFunctionOnGlobal(function, context, arraysize(args), args);
 
   {
     const char kTestCall[] =
         "obj.functionWithCallback('foo', function() {\n"
@@ skipping 21 matching lines @@
 }
 
 // Test that references to other API's types works.
 TEST_F(APIBindingsSystemTest, CrossAPIReferences) {
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   // Instantiate gamma API. Note: It's important that we haven't instantiated
   // alpha API yet, since this tests that we can lazily populate the type
   // information.
-  v8::Local<v8::Object> gamma_api = bindings_system()->CreateAPIInstance(
-      kGammaAPIName, context, base::Bind(&AllowAllAPIs), nullptr);
+  v8::Local<v8::Object> gamma_api =
+      bindings_system()->CreateAPIInstance(kGammaAPIName, context, nullptr);
   ASSERT_FALSE(gamma_api.IsEmpty());
 
   {
     // Test a simple call -> response.
     const char kTestCall[] = "obj.functionWithExternalRef({prop1: 'foo'});";
     CallFunctionOnObject(context, gamma_api, kTestCall);
     ValidateLastRequest("gamma.functionWithExternalRef", "[{'prop1':'foo'}]");
     reset_last_request();
   }
 }
@@ skipping 12 matching lines @@
         .ToChecked();
     return ret.As<v8::Value>();
   };
 
   auto test_hooks = base::MakeUnique<APIBindingHooksTestDelegate>();
   test_hooks->SetCustomEvent(base::Bind(create_custom_event));
   APIBindingHooks* binding_hooks =
       bindings_system()->GetHooksForAPI(kAlphaAPIName);
   binding_hooks->SetDelegate(std::move(test_hooks));
 
-  v8::Local<v8::Object> api = bindings_system()->CreateAPIInstance(
-      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), nullptr);
+  v8::Local<v8::Object> api =
+      bindings_system()->CreateAPIInstance(kAlphaAPIName, context, nullptr);
 
   v8::Local<v8::Value> event =
       GetPropertyFromObject(api, context, "alphaEvent");
   ASSERT_TRUE(event->IsObject());
   EXPECT_EQ(
       "\"alpha.alphaEvent\"",
       GetStringPropertyFromObject(event.As<v8::Object>(), context, "name"));
   v8::Local<v8::Value> event2 =
       GetPropertyFromObject(api, context, "alphaEvent");
   EXPECT_EQ(event, event2);
 
   v8::Local<v8::Value> other_event =
       GetPropertyFromObject(api, context, "alphaOtherEvent");
   ASSERT_TRUE(other_event->IsObject());
   EXPECT_EQ("\"alpha.alphaOtherEvent\"",
             GetStringPropertyFromObject(other_event.As<v8::Object>(), context,
                                         "name"));
   EXPECT_NE(event, other_event);
 }
 
 }  // namespace extensions