[Extensions Bindings] Remove Isolate arg from APIBinding::CreateInstance

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 187 matching lines @@
   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, isolate(), base::Bind(&AllowAllAPIs), nullptr);
+      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), nullptr);
   ASSERT_FALSE(alpha_api.IsEmpty());
   v8::Local<v8::Object> beta_api = bindings_system()->CreateAPIInstance(
-      kBetaAPIName, context, isolate(), base::Bind(&AllowAllAPIs), nullptr);
+      kBetaAPIName, context, base::Bind(&AllowAllAPIs), 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 105 matching lines @@
   };
 
   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, isolate(), base::Bind(&AllowAllAPIs), nullptr);
+      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), 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 17 matching lines @@
       "    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, isolate(), base::Bind(&AllowAllAPIs), &hooks);
+      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), &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 22 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, isolate(), base::Bind(&AllowAllAPIs), nullptr);
+      kGammaAPIName, context, base::Bind(&AllowAllAPIs), 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 13 matching lines @@
     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, isolate(), base::Bind(&AllowAllAPIs), nullptr);
+      kAlphaAPIName, context, base::Bind(&AllowAllAPIs), 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