Use Local instead of Handle in src/content/*

content/renderer/pepper/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 "content/renderer/pepper/v8_var_converter.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 38 matching lines @@
 }
 
 class MockResourceConverter : public content::ResourceConverter {
  public:
   ~MockResourceConverter() override {}
   void Reset() override {}
   bool NeedsFlush() override { return false; }
   void Flush(const base::Callback<void(bool)>& callback) override {
     NOTREACHED();
   }
-  bool FromV8Value(v8::Handle<v8::Object> val,
-                   v8::Handle<v8::Context> context,
+  bool FromV8Value(v8::Local<v8::Object> val,
+                   v8::Local<v8::Context> context,
                    PP_Var* result,
                    bool* was_resource) override {
     *was_resource = false;
     return true;
   }
   bool ToV8Value(const PP_Var& var,
-                 v8::Handle<v8::Context> context,
-                 v8::Handle<v8::Value>* result) override {
+                 v8::Local<v8::Context> context,
+                 v8::Local<v8::Value>* result) override {
     return false;
   }
 };
 
 // Maps PP_Var IDs to the V8 value handle they correspond to.
-typedef base::hash_map<int64_t, v8::Handle<v8::Value> > VarHandleMap;
+typedef base::hash_map<int64_t, v8::Local<v8::Value> > VarHandleMap;
 
 bool Equals(const PP_Var& var,
-            v8::Handle<v8::Value> val,
+            v8::Local<v8::Value> val,
             VarHandleMap* visited_ids) {
   if (ppapi::VarTracker::IsVarTypeRefcounted(var.type)) {
     VarHandleMap::iterator it = visited_ids->find(var.value.as_id);
     if (it != visited_ids->end())
       return it->second == val;
     (*visited_ids)[var.value.as_id] = val;
   }
 
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   if (val->IsUndefined()) {
@@ skipping 15 matching lines @@
       return false;
     StringVar* string_var = StringVar::FromPPVar(var);
     DCHECK(string_var);
     v8::String::Utf8Value utf8(val);
     return std::string(*utf8, utf8.length()) == string_var->value();
   } else if (val->IsArray()) {
     if (var.type != PP_VARTYPE_ARRAY)
       return false;
     ArrayVar* array_var = ArrayVar::FromPPVar(var);
     DCHECK(array_var);
-    v8::Handle<v8::Array> v8_array = val.As<v8::Array>();
+    v8::Local<v8::Array> v8_array = val.As<v8::Array>();
     if (v8_array->Length() != array_var->elements().size())
       return false;
     for (uint32 i = 0; i < v8_array->Length(); ++i) {
-      v8::Handle<v8::Value> child_v8 = v8_array->Get(i);
+      v8::Local<v8::Value> child_v8 = v8_array->Get(i);
       if (!Equals(array_var->elements()[i].get(), child_v8, visited_ids))
         return false;
     }
     return true;
   } else if (val->IsObject()) {
     if (var.type == PP_VARTYPE_ARRAY_BUFFER) {
       // TODO(raymes): Implement this when we have tests for array buffers.
       NOTIMPLEMENTED();
       return false;
     } else {
-      v8::Handle<v8::Object> v8_object = val.As<v8::Object>();
+      v8::Local<v8::Object> v8_object = val.As<v8::Object>();
       if (var.type != PP_VARTYPE_DICTIONARY)
         return false;
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
       DCHECK(dict_var);
-      v8::Handle<v8::Array> property_names(v8_object->GetOwnPropertyNames());
+      v8::Local<v8::Array> property_names(v8_object->GetOwnPropertyNames());
       if (property_names->Length() != dict_var->key_value_map().size())
         return false;
       for (uint32 i = 0; i < property_names->Length(); ++i) {
-        v8::Handle<v8::Value> key(property_names->Get(i));
+        v8::Local<v8::Value> key(property_names->Get(i));
 
         if (!key->IsString() && !key->IsNumber())
           return false;
-        v8::Handle<v8::Value> child_v8 = v8_object->Get(key);
+        v8::Local<v8::Value> child_v8 = v8_object->Get(key);
 
         v8::String::Utf8Value name_utf8(key);
         ScopedPPVar release_key(ScopedPPVar::PassRef(),
                                 StringVar::StringToPPVar(std::string(
                                     *name_utf8, name_utf8.length())));
         if (!dict_var->HasKey(release_key.get()))
           return false;
         ScopedPPVar release_value(ScopedPPVar::PassRef(),
                                   dict_var->Get(release_key.get()));
         if (!Equals(release_value.get(), child_v8, visited_ids))
           return false;
       }
       return true;
     }
   }
   return false;
 }
 
-bool Equals(const PP_Var& var, v8::Handle<v8::Value> val) {
+bool Equals(const PP_Var& var, v8::Local<v8::Value> val) {
   VarHandleMap var_handle_map;
   return Equals(var, val, &var_handle_map);
 }
 
 class V8VarConverterTest : public testing::Test {
  public:
   V8VarConverterTest()
       : isolate_(v8::Isolate::GetCurrent()) {
     PP_Instance dummy = 1234;
     converter_.reset(new V8VarConverter(
         dummy,
         scoped_ptr<ResourceConverter>(new MockResourceConverter).Pass()));
   }
   ~V8VarConverterTest() override {}
 
   // testing::Test implementation.
   void SetUp() override {
     ProxyLock::Acquire();
     v8::HandleScope handle_scope(isolate_);
-    v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate_);
+    v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate_);
     context_.Reset(isolate_, v8::Context::New(isolate_, NULL, global));
   }
   void TearDown() override {
     context_.Reset();
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
 
  protected:
-  bool FromV8ValueSync(v8::Handle<v8::Value> val,
-                       v8::Handle<v8::Context> context,
+  bool FromV8ValueSync(v8::Local<v8::Value> val,
+                       v8::Local<v8::Context> context,
                        PP_Var* result) {
     V8VarConverter::VarResult conversion_result =
         converter_->FromV8Value(val,
                                 context,
                                 base::Bind(&FromV8ValueComplete));
     DCHECK(conversion_result.completed_synchronously);
     if (conversion_result.success)
       *result = conversion_result.var.Release();
 
     return conversion_result.success;
   }
 
   bool RoundTrip(const PP_Var& var, PP_Var* result) {
     v8::HandleScope handle_scope(isolate_);
     v8::Local<v8::Context> context =
         v8::Local<v8::Context>::New(isolate_, context_);
     v8::Context::Scope context_scope(context);
-    v8::Handle<v8::Value> v8_result;
+    v8::Local<v8::Value> v8_result;
     if (!converter_->ToV8Value(var, context, &v8_result))
       return false;
     if (!Equals(var, v8_result))
       return false;
     if (!FromV8ValueSync(v8_result, context, result))
       return false;
     return true;
   }
 
   // Assumes a ref for var.
@@ skipping 117 matching lines @@
   {
     scoped_refptr<DictionaryVar> dictionary(new DictionaryVar);
     ScopedPPVar release_dictionary(ScopedPPVar::PassRef(),
                                    dictionary->GetPPVar());
     scoped_refptr<ArrayVar> array(new ArrayVar);
     ScopedPPVar release_array(ScopedPPVar::PassRef(), array->GetPPVar());
 
     dictionary->SetWithStringKey("1", release_array.get());
     array->Set(0, release_dictionary.get());
 
-    v8::Handle<v8::Value> v8_result;
+    v8::Local<v8::Value> v8_result;
 
     // Array <-> dictionary cycle.
     dictionary->SetWithStringKey("1", release_array.get());
     ASSERT_FALSE(
         converter_->ToV8Value(release_dictionary.get(), context, &v8_result));
     // Break the cycle.
     // TODO(raymes): We need some better machinery for releasing vars with
     // cycles. Remove the code below once we have that.
     dictionary->DeleteWithStringKey("1");
 
     // Array with self reference.
     array->Set(0, release_array.get());
     ASSERT_FALSE(
         converter_->ToV8Value(release_array.get(), context, &v8_result));
     // Break the self reference.
     array->Set(0, PP_MakeUndefined());
   }
 
   // V8->Var conversion.
   {
-    v8::Handle<v8::Object> object = v8::Object::New(isolate_);
-    v8::Handle<v8::Array> array = v8::Array::New(isolate_);
+    v8::Local<v8::Object> object = v8::Object::New(isolate_);
+    v8::Local<v8::Array> array = v8::Array::New(isolate_);
 
     PP_Var var_result;
 
     // Array <-> dictionary cycle.
     std::string key = "1";
     object->Set(
         v8::String::NewFromUtf8(
             isolate_, key.c_str(), v8::String::kNormalString, key.length()),
         array);
     array->Set(0, object);
@@ skipping 27 matching lines @@
         "return {"
         "1: 'foo',"
         "'2': 'bar',"
         "true: 'baz',"
         "false: 'qux',"
         "null: 'quux',"
         "undefined: 'oops'"
         "};"
         "})();";
 
-    v8::Handle<v8::Script> script(
+    v8::Local<v8::Script> script(
         v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
-    v8::Handle<v8::Object> object = script->Run().As<v8::Object>();
+    v8::Local<v8::Object> object = script->Run().As<v8::Object>();
     ASSERT_FALSE(object.IsEmpty());
 
     PP_Var actual;
     ASSERT_TRUE(FromV8ValueSync(
         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(), true));
   }
 }
 
 }  // namespace content