Added a version of the v8::HandleScope constructor with an Isolate and use that consistently.

test/cctest/test-func-name-inference.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 34 matching lines @@
 using ::v8::internal::SmartArrayPointer;
 using ::v8::internal::SharedFunctionInfo;
 using ::v8::internal::String;
 
 
 static v8::Persistent<v8::Context> env;
 
 
 static void InitializeVM() {
   if (env.IsEmpty()) {
-    v8::HandleScope scope;
     env = v8::Context::New();
   }
-  v8::HandleScope scope;
   env->Enter();
 }
 
 
 static void CheckFunctionName(v8::Handle<v8::Script> script,
                               const char* func_pos_src,
                               const char* ref_inferred_name) {
   // Get script source.
   Handle<Object> obj = v8::Utils::OpenHandle(*script);
   Handle<SharedFunctionInfo> shared_function;
@@ skipping 35 matching lines @@
 }
 
 
 static v8::Handle<v8::Script> Compile(const char* src) {
   return v8::Script::Compile(v8::String::New(src));
 }
 
 
 TEST(GlobalProperty) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "fun1 = function() { return 1; }\n"
       "fun2 = function() { return 2; }\n");
   CheckFunctionName(script, "return 1", "fun1");
   CheckFunctionName(script, "return 2", "fun2");
 }
 
 
 TEST(GlobalVar) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "var fun1 = function() { return 1; }\n"
       "var fun2 = function() { return 2; }\n");
   CheckFunctionName(script, "return 1", "fun1");
   CheckFunctionName(script, "return 2", "fun2");
 }
 
 
 TEST(LocalVar) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function outer() {\n"
       "  var fun1 = function() { return 1; }\n"
       "  var fun2 = function() { return 2; }\n"
       "}");
   CheckFunctionName(script, "return 1", "fun1");
   CheckFunctionName(script, "return 2", "fun2");
 }
 
 
 TEST(InConstructor) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function MyClass() {\n"
       "  this.method1 = function() { return 1; }\n"
       "  this.method2 = function() { return 2; }\n"
       "}");
   CheckFunctionName(script, "return 1", "MyClass.method1");
   CheckFunctionName(script, "return 2", "MyClass.method2");
 }
 
 
 TEST(Factory) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function createMyObj() {\n"
       "  var obj = {};\n"
       "  obj.method1 = function() { return 1; }\n"
       "  obj.method2 = function() { return 2; }\n"
       "  return obj;\n"
       "}");
   CheckFunctionName(script, "return 1", "obj.method1");
   CheckFunctionName(script, "return 2", "obj.method2");
 }
 
 
 TEST(Static) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function MyClass() {}\n"
       "MyClass.static1 = function() { return 1; }\n"
       "MyClass.static2 = function() { return 2; }\n"
       "MyClass.MyInnerClass = {}\n"
       "MyClass.MyInnerClass.static3 = function() { return 3; }\n"
       "MyClass.MyInnerClass.static4 = function() { return 4; }");
   CheckFunctionName(script, "return 1", "MyClass.static1");
   CheckFunctionName(script, "return 2", "MyClass.static2");
   CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.static3");
   CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.static4");
 }
 
 
 TEST(Prototype) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function MyClass() {}\n"
       "MyClass.prototype.method1 = function() { return 1; }\n"
       "MyClass.prototype.method2 = function() { return 2; }\n"
       "MyClass.MyInnerClass = function() {}\n"
       "MyClass.MyInnerClass.prototype.method3 = function() { return 3; }\n"
       "MyClass.MyInnerClass.prototype.method4 = function() { return 4; }");
   CheckFunctionName(script, "return 1", "MyClass.method1");
   CheckFunctionName(script, "return 2", "MyClass.method2");
   CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.method3");
   CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.method4");
 }
 
 
 TEST(ObjectLiteral) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function MyClass() {}\n"
       "MyClass.prototype = {\n"
       "  method1: function() { return 1; },\n"
       "  method2: function() { return 2; } }");
   CheckFunctionName(script, "return 1", "MyClass.method1");
   CheckFunctionName(script, "return 2", "MyClass.method2");
 }
 
 
 TEST(AsParameter) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function f1(a) { return a(); }\n"
       "function f2(a, b) { return a() + b(); }\n"
       "var result1 = f1(function() { return 1; })\n"
       "var result2 = f2(function() { return 2; }, function() { return 3; })");
   // Can't infer names here.
   CheckFunctionName(script, "return 1", "");
   CheckFunctionName(script, "return 2", "");
   CheckFunctionName(script, "return 3", "");
 }
 
 
 TEST(MultipleFuncsConditional) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "fun1 = 0 ?\n"
       "    function() { return 1; } :\n"
       "    function() { return 2; }");
   CheckFunctionName(script, "return 1", "fun1");
   CheckFunctionName(script, "return 2", "fun1");
 }
 
 
 TEST(MultipleFuncsInLiteral) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function MyClass() {}\n"
       "MyClass.prototype = {\n"
       "  method1: 0 ? function() { return 1; } :\n"
       "               function() { return 2; } }");
   CheckFunctionName(script, "return 1", "MyClass.method1");
   CheckFunctionName(script, "return 2", "MyClass.method1");
 }
 
 
 // See http://code.google.com/p/v8/issues/detail?id=380
 TEST(Issue380) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function a() {\n"
       "var result = function(p,a,c,k,e,d)"
       "{return p}(\"if blah blah\",62,1976,\'a|b\'.split(\'|\'),0,{})\n"
       "}");
   CheckFunctionName(script, "return p", "");
 }
 
 
 TEST(MultipleAssignments) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "var fun1 = fun2 = function () { return 1; }\n"
       "var bar1 = bar2 = bar3 = function () { return 2; }\n"
       "foo1 = foo2 = function () { return 3; }\n"
       "baz1 = baz2 = baz3 = function () { return 4; }");
   CheckFunctionName(script, "return 1", "fun2");
   CheckFunctionName(script, "return 2", "bar3");
   CheckFunctionName(script, "return 3", "foo2");
   CheckFunctionName(script, "return 4", "baz3");
 }
 
 
 TEST(AsConstructorParameter) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function Foo() {}\n"
       "var foo = new Foo(function() { return 1; })\n"
       "var bar = new Foo(function() { return 2; }, function() { return 3; })");
   CheckFunctionName(script, "return 1", "");
   CheckFunctionName(script, "return 2", "");
   CheckFunctionName(script, "return 3", "");
 }
 
 
 TEST(FactoryHashmap) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function createMyObj() {\n"
       "  var obj = {};\n"
       "  obj[\"method1\"] = function() { return 1; }\n"
       "  obj[\"method2\"] = function() { return 2; }\n"
       "  return obj;\n"
       "}");
   CheckFunctionName(script, "return 1", "obj.method1");
   CheckFunctionName(script, "return 2", "obj.method2");
 }
 
 
 TEST(FactoryHashmapVariable) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function createMyObj() {\n"
       "  var obj = {};\n"
       "  var methodName = \"method1\";\n"
       "  obj[methodName] = function() { return 1; }\n"
       "  methodName = \"method2\";\n"
       "  obj[methodName] = function() { return 2; }\n"
       "  return obj;\n"
       "}");
   // Can't infer function names statically.
   CheckFunctionName(script, "return 1", "obj.(anonymous function)");
   CheckFunctionName(script, "return 2", "obj.(anonymous function)");
 }
 
 
 TEST(FactoryHashmapConditional) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "function createMyObj() {\n"
       "  var obj = {};\n"
       "  obj[0 ? \"method1\" : \"method2\"] = function() { return 1; }\n"
       "  return obj;\n"
       "}");
   // Can't infer the function name statically.
   CheckFunctionName(script, "return 1", "obj.(anonymous function)");
 }
 
 
 TEST(GlobalAssignmentAndCall) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "var Foo = function() {\n"
       "  return 1;\n"
       "}();\n"
       "var Baz = Bar = function() {\n"
       "  return 2;\n"
       "}");
   // The inferred name is empty, because this is an assignment of a result.
   CheckFunctionName(script, "return 1", "");
   // See MultipleAssignments test.
   CheckFunctionName(script, "return 2", "Bar");
 }
 
 
 TEST(AssignmentAndCall) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "(function Enclosing() {\n"
       "  var Foo;\n"
       "  Foo = function() {\n"
       "    return 1;\n"
       "  }();\n"
       "  var Baz = Bar = function() {\n"
       "    return 2;\n"
       "  }\n"
       "})();");
   // The inferred name is empty, because this is an assignment of a result.
   CheckFunctionName(script, "return 1", "");
   // See MultipleAssignments test.
   // TODO(2276): Lazy compiling the enclosing outer closure would yield
   // in "Enclosing.Bar" being the inferred name here.
   CheckFunctionName(script, "return 2", "Bar");
 }
 
 
 TEST(MethodAssignmentInAnonymousFunctionCall) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "(function () {\n"
       "    var EventSource = function () { };\n"
       "    EventSource.prototype.addListener = function () {\n"
       "        return 2012;\n"
       "    };\n"
       "    this.PublicEventSource = EventSource;\n"
       "})();");
   CheckFunctionName(script, "return 2012", "EventSource.addListener");
 }
 
 
 TEST(ReturnAnonymousFunction) {
   InitializeVM();
-  v8::HandleScope scope;
+  v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::Script> script = Compile(
       "(function() {\n"
       "  function wrapCode() {\n"
       "    return function () {\n"
       "      return 2012;\n"
       "    };\n"
       "  };\n"
       "  var foo = 10;\n"
       "  function f() {\n"
       "    return wrapCode();\n"
       "  }\n"
       "  this.ref = f;\n"
       "})()");
   script->Run();
   CheckFunctionName(script, "return 2012", "");
 }