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

extensions/renderer/safe_builtins.cc

 // Copyright 2014 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 "extensions/renderer/safe_builtins.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "extensions/renderer/script_context.h"
@@ skipping 120 matching lines @@
               v8::Local<v8::Context> context) {
   CHECK(!value.IsEmpty() && value->IsObject()) << name;
   context->Global()->SetHiddenValue(MakeKey(name, context->GetIsolate()),
                                     value);
 }
 
 v8::Local<v8::Object> Load(const char* name, v8::Handle<v8::Context> context) {
   v8::Local<v8::Value> value =
       context->Global()->GetHiddenValue(MakeKey(name, context->GetIsolate()));
   CHECK(!value.IsEmpty() && value->IsObject()) << name;
-  return value->ToObject();
+  return v8::Local<v8::Object>::Cast(value);
 }
 
 class ExtensionImpl : public v8::Extension {
  public:
   ExtensionImpl() : v8::Extension(kClassName, kScript) {}
 
  private:
   v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
       v8::Isolate* isolate,
       v8::Handle<v8::String> name) override {
     if (name->Equals(v8::String::NewFromUtf8(isolate, "Apply")))
       return v8::FunctionTemplate::New(isolate, Apply);
     if (name->Equals(v8::String::NewFromUtf8(isolate, "Save")))
       return v8::FunctionTemplate::New(isolate, Save);
     NOTREACHED() << *v8::String::Utf8Value(name);
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static void Apply(const v8::FunctionCallbackInfo<v8::Value>& info) {
     CHECK(info.Length() == 5 && info[0]->IsFunction() &&  // function
           // info[1] could be an object or a string
           info[2]->IsObject() &&  // args
           info[3]->IsInt32() &&   // first_arg_index
           info[4]->IsInt32());    // args_length
     v8::Local<v8::Function> function = info[0].As<v8::Function>();
     v8::Local<v8::Object> recv;
     if (info[1]->IsObject()) {
-      recv = info[1]->ToObject();
+      recv = v8::Local<v8::Object>::Cast(info[1]);
     } else if (info[1]->IsString()) {
-      recv = v8::StringObject::New(info[1]->ToString())->ToObject();
+      recv = v8::StringObject::New(v8::Local<v8::String>::Cast(info[1]))
+                 ->ToObject(info.GetIsolate());
     } else {
       info.GetIsolate()->ThrowException(
           v8::Exception::TypeError(v8::String::NewFromUtf8(
               info.GetIsolate(),
               "The first argument is the receiver and must be an object")));
       return;
     }
-    v8::Local<v8::Object> args = info[2]->ToObject();
-    int first_arg_index = static_cast<int>(info[3]->ToInt32()->Value());
-    int args_length = static_cast<int>(info[4]->ToInt32()->Value());
+    v8::Local<v8::Object> args = v8::Local<v8::Object>::Cast(info[2]);
+    int first_arg_index = info[3]->ToInt32(info.GetIsolate())->Value();
+    int args_length = info[4]->ToInt32(info.GetIsolate())->Value();
 
     int argc = args_length - first_arg_index;
     scoped_ptr<v8::Local<v8::Value> []> argv(new v8::Local<v8::Value>[argc]);
     for (int i = 0; i < argc; ++i) {
       CHECK(args->Has(i + first_arg_index));
       argv[i] = args->Get(i + first_arg_index);
     }
 
     v8::Local<v8::Value> return_value = function->Call(recv, argc, argv.get());
     if (!return_value.IsEmpty())
@@ skipping 39 matching lines @@
 
 v8::Local<v8::Object> SafeBuiltins::GetString() const {
   return Load("String", context_->v8_context());
 }
 
 v8::Local<v8::Object> SafeBuiltins::GetError() const {
   return Load("Error", context_->v8_context());
 }
 
 }  //  namespace extensions