remove some calls to to-be-deprecated v8::Value::To* functions

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 65 matching lines @@
 bool Equals(const PP_Var& var,
             v8::Handle<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()) {
     return var.type == PP_VARTYPE_UNDEFINED;
   } else if (val->IsNull()) {
     return var.type == PP_VARTYPE_NULL;
   } else if (val->IsBoolean() || val->IsBooleanObject()) {
     return var.type == PP_VARTYPE_BOOL &&
-           PP_FromBool(val->ToBoolean()->Value()) == var.value.as_bool;
+           PP_FromBool(val->ToBoolean(isolate)->Value()) == var.value.as_bool;
   } else if (val->IsInt32()) {
     return var.type == PP_VARTYPE_INT32 &&
-           val->ToInt32()->Value() == var.value.as_int;
+           val->ToInt32(isolate)->Value() == var.value.as_int;
   } else if (val->IsNumber() || val->IsNumberObject()) {
     return var.type == PP_VARTYPE_DOUBLE &&
-           fabs(val->ToNumber()->Value() - var.value.as_double) <= 1.0e-4;
+           fabs(val->ToNumber(isolate)->Value() - var.value.as_double) <=
+               1.0e-4;
   } else if (val->IsString() || val->IsStringObject()) {
     if (var.type != PP_VARTYPE_STRING)
       return false;
     StringVar* string_var = StringVar::FromPPVar(var);
     DCHECK(string_var);
-    v8::String::Utf8Value utf8(val->ToString());
+    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>();
     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);
       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->ToObject();
+      v8::Handle<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());
       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));
 
         if (!key->IsString() && !key->IsNumber())
           return false;
         v8::Handle<v8::Value> child_v8 = v8_object->Get(key);
 
-        v8::String::Utf8Value name_utf8(key->ToString());
+        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;
       }
@@ skipping 283 matching lines @@
     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