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

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 295 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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
   EXPECT_EQ(
       0u,
       binding_object->GetOwnPropertyNames(context).ToLocalChecked()->Length());
 }
 
 TEST_F(APIBindingUnittest, Test) {
   // TODO(devlin): Move this test to an api_signature_unittest file? It really
   // only tests parsing.
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   ExpectPass(binding_object, "obj.oneString('foo');", "['foo']", false);
   ExpectPass(binding_object, "obj.oneString('');", "['']", false);
   ExpectFailure(binding_object, "obj.oneString(1);", kError);
   ExpectFailure(binding_object, "obj.oneString();", kError);
   ExpectFailure(binding_object, "obj.oneString({});", kError);
   ExpectFailure(binding_object, "obj.oneString('foo', 'bar');", kError);
 
   ExpectPass(binding_object, "obj.stringAndInt('foo', 42);", "['foo',42]",
              false);
@@ skipping 73 matching lines @@
       "  '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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   EXPECT_EQ(
       "{\"\":\"\",\"OTHER\":\"other\"}",
       GetStringPropertyFromObject(binding_object, context, "enumWithEmpty"));
 }
 
 TEST_F(APIBindingUnittest, TypeRefsTest) {
   const char kTypes[] =
       "[{"
       "  'id': 'refObj',"
@@ skipping 26 matching lines @@
   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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo'})",
              "[{'prop1':'foo'}]", false);
   ExpectPass(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 2})",
              "[{'prop1':'foo','prop2':2}]", false);
   ExpectFailure(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
                 kError);
   ExpectPass(binding_object, "obj.takesRefEnum('alpha')", "['alpha']", false);
   ExpectPass(binding_object, "obj.takesRefEnum('beta')", "['beta']", false);
   ExpectPass(binding_object, "obj.takesRefEnum(obj.refEnum.BETA)", "['beta']",
@@ skipping 28 matching lines @@
   auto is_available = [](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;
   };
 
   v8::Local<v8::Object> binding_object =
-      binding()->CreateInstance(context, isolate(), base::Bind(is_available));
+      binding()->CreateInstance(context, base::Bind(is_available));
 
   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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   // 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 17 matching lines @@
       "      '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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
   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 31 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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
   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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   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, isolate(), base::Bind(&AllowAllAPIs));
-  v8::Local<v8::Object> binding_object_b = binding()->CreateInstance(
-      context_b, isolate(), base::Bind(&AllowAllAPIs));
+  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));
 
   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 20 matching lines @@
   };
   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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   // 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 20 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   // 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);", kError);
   v8::Local<v8::Value> property =
       GetPropertyFromObject(context->Global(), context, "requestArguments");
   ASSERT_FALSE(property.IsEmpty());
   EXPECT_TRUE(property->IsUndefined());
 
   // Try calling the oneString() method with valid arguments. The hook should
@@ skipping 31 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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   // 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);", kError);
   EXPECT_EQ("[false]", GetStringPropertyFromObject(
                            context->Global(), context, "requestArguments"));
 
   ExpectPass(binding_object, "obj.oneString(true);", "['hooked']", false);
   EXPECT_EQ("[true]", GetStringPropertyFromObject(
@@ skipping 37 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   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 21 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   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 40 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   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 29 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   {
     // 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 35 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   // Try calling the method with an invalid signature. Since it's invalid, we
   // should never enter the hook.
   ExpectFailure(binding_object, "obj.oneString(false);", kError);
   EXPECT_EQ("undefined", GetStringPropertyFromObject(
                              context->Global(), context, "requestArguments"));
 
   // Call the method with a valid signature. The hook should be entered and
   // manipulate the arguments.
   ExpectPass(binding_object, "obj.oneString('ping');", "['pong']", false);
@@ skipping 27 matching lines @@
         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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   // 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, isolate(), base::Bind(&AllowAllAPIs));
+      binding()->CreateInstance(context, base::Bind(&AllowAllAPIs));
 
   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();
 
   blink::WebScopedUserGesture user_gesture(nullptr);
   RunFunction(function, context, arraysize(argv), argv);
   ASSERT_TRUE(last_request());
   EXPECT_TRUE(last_request()->has_user_gesture);
 
   reset_last_request();
 }
 
 }  // namespace extensions