Update tests to not use to-be-removed V8 handle operations.

chrome/test/base/v8_unit_test.cc

 // Copyright (c) 2011 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 "chrome/test/base/v8_unit_test.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
@@ skipping 27 matching lines @@
 bool testResult_ok = false;
 
 // Location of test data (currently test/data/webui).
 base::FilePath test_data_directory;
 
 // Location of generated test data (<(PROGRAM_DIR)/test_data).
 base::FilePath gen_test_data_directory;
 
 }  // namespace
 
-V8UnitTest::V8UnitTest() {
+V8UnitTest::V8UnitTest()
+    : isolate_(v8::Isolate::GetCurrent()),
+      handle_scope_(isolate_) {
   InitPathsAndLibraries();
 }
 
 V8UnitTest::~V8UnitTest() {}
 
 void V8UnitTest::AddLibrary(const base::FilePath& library_path) {
   user_libraries_.push_back(library_path);
 }
 
 bool V8UnitTest::ExecuteJavascriptLibraries() {
@@ skipping 22 matching lines @@
 }
 
 bool V8UnitTest::RunJavascriptTestF(
     const std::string& testFixture, const std::string& testName) {
   had_errors = false;
   testResult_ok = false;
   std::string test_js;
   if (!ExecuteJavascriptLibraries())
     return false;
 
-  v8::Context::Scope context_scope(context_);
-  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(isolate_, context_);
+  v8::HandleScope handle_scope(isolate_);
+  v8::Local<v8::Context> context =
+      v8::Local<v8::Context>::New(isolate_, context_);
 
   v8::Handle<v8::Value> functionProperty =
-      context_->Global()->Get(v8::String::New("runTest"));
+      context->Global()->Get(v8::String::New("runTest"));
   EXPECT_FALSE(functionProperty.IsEmpty());
   if (::testing::Test::HasNonfatalFailure())
     return false;
   EXPECT_TRUE(functionProperty->IsFunction());
   if (::testing::Test::HasNonfatalFailure())
     return false;
   v8::Handle<v8::Function> function =
       v8::Handle<v8::Function>::Cast(functionProperty);
 
   v8::Local<v8::Array> params = v8::Array::New();
   params->Set(0, v8::String::New(testFixture.data(), testFixture.size()));
   params->Set(1, v8::String::New(testName.data(), testName.size()));
   v8::Handle<v8::Value> args[] = {
     v8::Boolean::New(false),
     v8::String::New("RUN_TEST_F"),
     params
   };
 
   v8::TryCatch try_catch;
-  v8::Handle<v8::Value> result = function->Call(context_->Global(), 3, args);
+  v8::Handle<v8::Value> result = function->Call(context->Global(), 3, args);
   // The test fails if an exception was thrown.
   EXPECT_FALSE(result.IsEmpty());
   if (::testing::Test::HasNonfatalFailure())
     return false;
 
   // Ok if ran successfully, passed tests, and didn't have console errors.
   return result->BooleanValue() && testResult_ok && !had_errors;
 }
 
 void V8UnitTest::InitPathsAndLibraries() {
@@ skipping 41 matching lines @@
 
   // Set up console object for console.log(), etc.
   v8::Handle<v8::ObjectTemplate> console = v8::ObjectTemplate::New();
   global->Set(v8::String::New("console"), console);
   console->Set(logString, logFunction);
   console->Set(v8::String::New("info"), logFunction);
   console->Set(v8::String::New("warn"), logFunction);
   console->Set(v8::String::New("error"),
                v8::FunctionTemplate::New(&V8UnitTest::Error));
 
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  // TODO(marja): Use v8::Persistent::Reset here.
-  context_ = v8::Persistent<v8::Context>(
-      isolate, v8::Context::New(isolate, NULL, global));
+  context_.Reset(isolate_, v8::Context::New(isolate_, NULL, global));
 }
 
 void V8UnitTest::SetGlobalStringVar(const std::string& var_name,
                                     const std::string& value) {
-  v8::Context::Scope context_scope(context_);
-  context_->Global()->Set(v8::String::New(var_name.c_str(), var_name.length()),
-                          v8::String::New(value.c_str(), value.length()));
+  v8::Context::Scope context_scope(isolate_, context_);
+  v8::Local<v8::Context>::New(isolate_, context_)->Global()
+      ->Set(v8::String::New(var_name.c_str(), var_name.length()),
+            v8::String::New(value.c_str(), value.length()));
 }
 
 void V8UnitTest::ExecuteScriptInContext(const base::StringPiece& script_source,
                                         const base::StringPiece& script_name) {
-  v8::Context::Scope context_scope(context_);
-  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(isolate_, context_);
+  v8::HandleScope handle_scope(isolate_);
   v8::Handle<v8::String> source = v8::String::New(script_source.data(),
                                                   script_source.size());
   v8::Handle<v8::String> name = v8::String::New(script_name.data(),
                                                 script_name.size());
 
   v8::TryCatch try_catch;
   v8::Handle<v8::Script> script = v8::Script::Compile(source, name);
   // Ensure the script compiled without errors.
   if (script.IsEmpty())
     FAIL() << ExceptionToString(try_catch);
@@ skipping 17 matching lines @@
     int colnum = message->GetStartColumn();
     str.append(base::StringPrintf(
         "%s:%i:%i %s\n", *filename, linenum, colnum, *exception));
     v8::String::Utf8Value sourceline(message->GetSourceLine());
     str.append(base::StringPrintf("%s\n", *sourceline));
   }
   return str;
 }
 
 void V8UnitTest::TestFunction(const std::string& function_name) {
-  v8::Context::Scope context_scope(context_);
-  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(isolate_, context_);
+  v8::HandleScope handle_scope(isolate_);
+  v8::Local<v8::Context> context =
+      v8::Local<v8::Context>::New(isolate_, context_);
 
   v8::Handle<v8::Value> functionProperty =
-      context_->Global()->Get(v8::String::New(function_name.c_str()));
+      context->Global()->Get(v8::String::New(function_name.c_str()));
   ASSERT_FALSE(functionProperty.IsEmpty());
   ASSERT_TRUE(functionProperty->IsFunction());
   v8::Handle<v8::Function> function =
       v8::Handle<v8::Function>::Cast(functionProperty);
 
   v8::TryCatch try_catch;
-  v8::Handle<v8::Value> result = function->Call(context_->Global(), 0, NULL);
+  v8::Handle<v8::Value> result = function->Call(context->Global(), 0, NULL);
   // The test fails if an exception was thrown.
   if (result.IsEmpty())
     FAIL() << ExceptionToString(try_catch);
 }
 
 // static
 v8::Handle<v8::Value> V8UnitTest::Log(const v8::Arguments& args) {
   LOG(INFO) << LogArgs2String(args);
   return v8::Undefined();
 }
@@ skipping 23 matching lines @@
   EXPECT_EQ(2U, testResult->Length());
   if (::testing::Test::HasNonfatalFailure())
     return v8::Undefined();
   testResult_ok = testResult->Get(0)->BooleanValue();
   if (!testResult_ok) {
     v8::String::Utf8Value message(testResult->Get(1));
     LOG(ERROR) << *message;
   }
   return v8::Undefined();
 }