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

content/renderer/v8_value_converter_impl.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/v8_value_converter_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 278 matching lines @@
   CHECK(!val.IsEmpty());
 
   FromV8ValueState::Level state_level(state);
   if (state->HasReachedMaxRecursionDepth())
     return NULL;
 
   if (val->IsNull())
     return base::Value::CreateNullValue();
 
   if (val->IsBoolean())
-    return new base::FundamentalValue(val->ToBoolean()->Value());
+    return new base::FundamentalValue(val->ToBoolean(isolate)->Value());
 
   if (val->IsNumber() && strategy_) {
     base::Value* out = NULL;
-    if (strategy_->FromV8Number(val->ToNumber(), &out))
+    if (strategy_->FromV8Number(val.As<v8::Number>(), &out))
       return out;
   }
 
   if (val->IsInt32())
-    return new base::FundamentalValue(val->ToInt32()->Value());
+    return new base::FundamentalValue(val->ToInt32(isolate)->Value());
 
   if (val->IsNumber()) {
-    double val_as_double = val->ToNumber()->Value();
+    double val_as_double = val.As<v8::Number>()->Value();
     if (!base::IsFinite(val_as_double))
       return NULL;
     return new base::FundamentalValue(val_as_double);
   }
 
   if (val->IsString()) {
-    v8::String::Utf8Value utf8(val->ToString());
+    v8::String::Utf8Value utf8(val);
     return new base::StringValue(std::string(*utf8, utf8.length()));
   }
 
   if (val->IsUndefined()) {
     if (strategy_) {
       base::Value* out = NULL;
       if (strategy_->FromV8Undefined(&out))
         return out;
     }
     // JSON.stringify ignores undefined.
     return NULL;
   }
 
   if (val->IsDate()) {
     if (!date_allowed_)
       // JSON.stringify would convert this to a string, but an object is more
       // consistent within this class.
-      return FromV8Object(val->ToObject(), state, isolate);
+      return FromV8Object(val->ToObject(isolate), state, isolate);
     v8::Date* date = v8::Date::Cast(*val);
     return new base::FundamentalValue(date->ValueOf() / 1000.0);
   }
 
   if (val->IsRegExp()) {
     if (!reg_exp_allowed_)
       // JSON.stringify converts to an object.
-      return FromV8Object(val->ToObject(), state, isolate);
-    return new base::StringValue(*v8::String::Utf8Value(val->ToString()));
+      return FromV8Object(val.As<v8::Object>(), state, isolate);
+    return new base::StringValue(*v8::String::Utf8Value(val));
   }
 
   // v8::Value doesn't have a ToArray() method for some reason.
   if (val->IsArray())
     return FromV8Array(val.As<v8::Array>(), state, isolate);
 
   if (val->IsFunction()) {
     if (!function_allowed_)
       // JSON.stringify refuses to convert function(){}.
       return NULL;
-    return FromV8Object(val->ToObject(), state, isolate);
+    return FromV8Object(val.As<v8::Object>(), state, isolate);
   }
 
   if (val->IsArrayBuffer() || val->IsArrayBufferView())
-    return FromV8ArrayBuffer(val->ToObject(), isolate);
+    return FromV8ArrayBuffer(val.As<v8::Object>(), isolate);
 
   if (val->IsObject())
-    return FromV8Object(val->ToObject(), state, isolate);
+    return FromV8Object(val.As<v8::Object>(), state, isolate);
 
   LOG(ERROR) << "Unexpected v8 value type encountered.";
   return NULL;
 }
 
 base::Value* V8ValueConverterImpl::FromV8Array(
     v8::Handle<v8::Array> val,
     FromV8ValueState* state,
     v8::Isolate* isolate) const {
   if (!state->UpdateAndCheckUniqueness(val))
@@ skipping 126 matching lines @@
     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";
       continue;
     }
 
-    v8::String::Utf8Value name_utf8(key->ToString());
+    v8::String::Utf8Value name_utf8(key);
 
     v8::TryCatch try_catch;
     v8::Handle<v8::Value> child_v8 = val->Get(key);
 
     if (try_catch.HasCaught()) {
       LOG(WARNING) << "Getter for property " << *name_utf8
                    << " threw an exception.";
       child_v8 = v8::Null(isolate);
     }
 
@@ skipping 27 matching lines @@
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     child.release());
   }
 
   return result.release();
 }
 
 }  // namespace content