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

content/renderer/pepper/v8_var_converter.cc

 // Copyright (c) 2013 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 <map>
 #include <stack>
 #include <string>
 
@@ skipping 226 matching lines @@
     // 3) If the object is an array, return an ArrayVar.
     // 4) If the object can be converted to a resource, return the ResourceVar.
     // 5) Otherwise return a DictionaryVar.
     scoped_ptr<blink::WebArrayBuffer> web_array_buffer(
         blink::WebArrayBufferConverter::createFromV8Value(val, isolate));
     if (web_array_buffer.get()) {
       scoped_refptr<HostArrayBufferVar> buffer_var(
           new HostArrayBufferVar(*web_array_buffer));
       *result = buffer_var->GetPPVar();
     } else if (object_vars_allowed == V8VarConverter::kAllowObjectVars) {
-      v8::Handle<v8::Object> object = val->ToObject();
+      v8::Handle<v8::Object> object = val.As<v8::Object>();
       *result = content::HostGlobals::Get()->
           host_var_tracker()->V8ObjectVarForV8Object(instance, object);
     } else if (val->IsArray()) {
       *result = (new ArrayVar())->GetPPVar();
     } else {
       bool was_resource;
-      if (!resource_converter->FromV8Value(
-              val->ToObject(), context, result, &was_resource))
+      if (!resource_converter->FromV8Value(val.As<v8::Object>(), context,
+                                           result, &was_resource))
         return false;
       if (!was_resource) {
         *result = (new DictionaryVar())->GetPPVar();
       }
     }
   } else {
     // Silently ignore the case where we can't convert to a Var as we may
     // be trying to convert a type that doesn't have a corresponding
     // PP_Var type.
     return true;
   }
 
   *did_create = true;
   if (val->IsObject() || val->IsString()) {
     visited_handles->insert(
-        make_pair(HashedHandle(val->ToObject()),
+        make_pair(HashedHandle(val->ToObject(isolate)),
                   ScopedPPVar(ScopedPPVar::PassRef(), *result)));
   }
   return true;
 }
 
 bool CanHaveChildren(PP_Var var) {
   return var.type == PP_VARTYPE_ARRAY || var.type == PP_VARTYPE_DICTIONARY;
 }
 
 }  // namespace
@@ skipping 102 matching lines @@
         }
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       parent_ids.insert(current_var.value.as_id);
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
         return false;
       }
       DCHECK(current_v8->IsObject());
-      v8::Handle<v8::Object> v8_object = current_v8->ToObject();
+      v8::Handle<v8::Object> v8_object = current_v8.As<v8::Object>();
 
       for (DictionaryVar::KeyValueMap::const_iterator iter =
                dict_var->key_value_map().begin();
            iter != dict_var->key_value_map().end();
            ++iter) {
         const std::string& key = iter->first;
         const PP_Var& child_var = iter->second.get();
         v8::Handle<v8::Value> child_v8;
         if (!GetOrCreateV8Value(context,
                                 child_var,
@@ skipping 68 matching lines @@
   *result_var = PP_MakeUndefined();
   bool is_root = true;
 
   while (!stack.empty()) {
     v8::Handle<v8::Value> current_v8 = stack.top().val;
     PP_Var current_var;
 
     if (stack.top().sentinel) {
       stack.pop();
       if (current_v8->IsObject())
-        parent_handles.erase(HashedHandle(current_v8->ToObject()));
+        parent_handles.erase(HashedHandle(current_v8.As<v8::Object>()));
       continue;
     } else {
       stack.top().sentinel = true;
     }
 
     bool did_create = false;
     if (!GetOrCreateVar(current_v8,
                         context,
                         instance_,
                         object_vars_allowed_,
@@ skipping 43 matching lines @@
                             resource_converter_.get())) {
           return false;
         }
         if (did_create && child_v8->IsObject())
           stack.push(child_v8);
 
         array_var->Set(i, child_var);
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       DCHECK(current_v8->IsObject());
-      v8::Handle<v8::Object> v8_object = current_v8->ToObject();
+      v8::Handle<v8::Object> v8_object = current_v8.As<v8::Object>();
       parent_handles.insert(HashedHandle(v8_object));
 
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
         return false;
       }
 
       v8::Handle<v8::Array> property_names(v8_object->GetOwnPropertyNames());
       for (uint32 i = 0; i < property_names->Length(); ++i) {
         v8::Handle<v8::Value> key(property_names->Get(i));
 
         // Extend this test to cover more types as necessary and if sensible.
         if (!key->IsString() && !key->IsNumber()) {
           NOTREACHED() << "Key \"" << *v8::String::Utf8Value(key)
                        << "\" "
                           "is neither a string nor a number";
           return false;
         }
 
+        v8::Handle<v8::String> key_string =
+            key->ToString(context->GetIsolate());
         // Skip all callbacks: crbug.com/139933
-        if (v8_object->HasRealNamedCallbackProperty(key->ToString()))
+        if (v8_object->HasRealNamedCallbackProperty(key_string))
           continue;
 
-        v8::String::Utf8Value name_utf8(key->ToString());
+        v8::String::Utf8Value name_utf8(key_string);
 
         v8::TryCatch try_catch;
         v8::Handle<v8::Value> child_v8 = v8_object->Get(key);
         if (try_catch.HasCaught())
           return false;
 
         PP_Var child_var;
         if (!GetOrCreateVar(child_v8,
                             context,
                             instance_,
@@ skipping 12 matching lines @@
             std::string(*name_utf8, name_utf8.length()), child_var);
         DCHECK(success);
       }
     }
   }
   *result_var = root;
   return true;
 }
 
 }  // namespace content