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

webkit/plugins/ppapi/v8_var_converter_unittest.cc

 // Copyright (c) 2012 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 "webkit/plugins/ppapi/v8_var_converter.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 115 matching lines @@
 }
 
 bool Equals(const PP_Var& var,
             v8::Handle<v8::Value> val) {
   VarHandleMap var_handle_map;
   return Equals(var, val, &var_handle_map);
 }
 
 class V8VarConverterTest : public testing::Test {
  public:
-  V8VarConverterTest() {}
+  V8VarConverterTest()
+      : isolate_(v8::Isolate::GetCurrent()) {}
   ~V8VarConverterTest() {}
 
   // testing::Test implementation.
   virtual void SetUp() {
     ProxyLock::Acquire();
-    v8::HandleScope handle_scope;
+    v8::HandleScope handle_scope(isolate_);
     v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
-    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));
   }
   virtual void TearDown() {
-    context_.Dispose(context_->GetIsolate());
+    context_.Dispose();
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
 
  protected:
   bool RoundTrip(const PP_Var& var, PP_Var* result) {
     V8VarConverter converter;
-    v8::Context::Scope context_scope(context_);
-    v8::HandleScope handle_scope;
+    v8::HandleScope handle_scope(isolate_);
+    v8::Context::Scope context_scope(isolate_, context_);
+    v8::Local<v8::Context> context =
+        v8::Local<v8::Context>::New(isolate_, context_);
     v8::Handle<v8::Value> v8_result;
-    if (!converter.ToV8Value(var, context_, &v8_result))
+    if (!converter.ToV8Value(var, context, &v8_result))
       return false;
     if (!Equals(var, v8_result))
       return false;
-    if (!converter.FromV8Value(v8_result, context_, result))
+    if (!converter.FromV8Value(v8_result, context, result))
       return false;
     return true;
   }
 
   // Assumes a ref for var.
   bool RoundTripAndCompare(const PP_Var& var) {
     ScopedPPVar expected(ScopedPPVar::PassRef(), var);
     PP_Var actual_var;
     if (!RoundTrip(expected.get(), &actual_var))
       return false;
     ScopedPPVar actual(ScopedPPVar::PassRef(), actual_var);
     return TestEqual(expected.get(), actual.get());
   }
 
+  v8::Isolate* isolate_;
+
   // Context for the JavaScript in the test.
   v8::Persistent<v8::Context> context_;
 
  private:
   TestGlobals globals_;
 };
 
 }  // namespace
 
 TEST_F(V8VarConverterTest, SimpleRoundTripTest) {
@@ skipping 108 matching lines @@
   {
     // Test keys with '.'.
     scoped_refptr<DictionaryVar> dictionary(new DictionaryVar);
     dictionary->SetWithStringKey(".", PP_MakeUndefined());
     dictionary->SetWithStringKey("x.y", PP_MakeUndefined());
     EXPECT_TRUE(RoundTripAndCompare(dictionary->GetPPVar()));
   }
 
   {
     // Test non-string key types. They should be cast to strings.
-    v8::Context::Scope context_scope(context_);
-    v8::HandleScope handle_scope;
+    v8::HandleScope handle_scope(isolate_);
+    v8::Context::Scope context_scope(isolate_, context_);
 
     const char* source = "(function() {"
         "return {"
           "1: 'foo',"
           "'2': 'bar',"
           "true: 'baz',"
           "false: 'qux',"
           "null: 'quux',"
           "undefined: 'oops'"
         "};"
         "})();";
 
     v8::Handle<v8::Script> script(v8::Script::New(v8::String::New(source)));
     v8::Handle<v8::Object> object = script->Run().As<v8::Object>();
     ASSERT_FALSE(object.IsEmpty());
 
     V8VarConverter converter;
     PP_Var actual;
-    ASSERT_TRUE(converter.FromV8Value(object, context_, &actual));
+    ASSERT_TRUE(converter.FromV8Value(
+        object, v8::Local<v8::Context>::New(isolate_, context_), &actual));
     ScopedPPVar release_actual(ScopedPPVar::PassRef(), actual);
 
     scoped_refptr<DictionaryVar> expected(new DictionaryVar);
     ScopedPPVar foo(ScopedPPVar::PassRef(), StringVar::StringToPPVar("foo"));
     expected->SetWithStringKey("1", foo.get());
     ScopedPPVar bar(ScopedPPVar::PassRef(), StringVar::StringToPPVar("bar"));
     expected->SetWithStringKey("2", bar.get());
     ScopedPPVar baz(ScopedPPVar::PassRef(), StringVar::StringToPPVar("baz"));
     expected->SetWithStringKey("true", baz.get());
     ScopedPPVar qux(ScopedPPVar::PassRef(), StringVar::StringToPPVar("qux"));
     expected->SetWithStringKey("false", qux.get());
     ScopedPPVar quux(ScopedPPVar::PassRef(), StringVar::StringToPPVar("quux"));
     expected->SetWithStringKey("null", quux.get());
     ScopedPPVar oops(ScopedPPVar::PassRef(), StringVar::StringToPPVar("oops"));
     expected->SetWithStringKey("undefined", oops.get());
     ScopedPPVar release_expected(
         ScopedPPVar::PassRef(), expected->GetPPVar());
 
     ASSERT_TRUE(TestEqual(release_expected.get(), release_actual.get()));
   }
 }
 
 }  // namespace ppapi
 }  // namespace webkit