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

extensions/renderer/module_system.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/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
@@ skipping 84 matching lines @@
 std::string ModuleSystem::ExceptionHandler::CreateExceptionString(
     const v8::TryCatch& try_catch) {
   v8::Handle<v8::Message> message(try_catch.Message());
   if (message.IsEmpty()) {
     return "try_catch has no message";
   }
 
   std::string resource_name = "<unknown resource>";
   if (!message->GetScriptOrigin().ResourceName().IsEmpty()) {
     v8::String::Utf8Value resource_name_v8(
-        message->GetScriptOrigin().ResourceName()->ToString());
+        message->GetScriptOrigin().ResourceName());
     resource_name.assign(*resource_name_v8, resource_name_v8.length());
   }
 
   std::string error_message = "<no error message>";
   if (!message->Get().IsEmpty()) {
     v8::String::Utf8Value error_message_v8(message->Get());
     error_message.assign(*error_message_v8, error_message_v8.length());
   }
 
   return base::StringPrintf("%s:%d: %s",
@@ skipping 78 matching lines @@
 }
 
 v8::Handle<v8::Value> ModuleSystem::Require(const std::string& module_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   return handle_scope.Escape(RequireForJsInner(
       v8::String::NewFromUtf8(GetIsolate(), module_name.c_str())));
 }
 
 void ModuleSystem::RequireForJs(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Handle<v8::String> module_name = args[0]->ToString();
+  v8::Handle<v8::String> module_name = args[0]->ToString(args.GetIsolate());
   args.GetReturnValue().Set(RequireForJsInner(module_name));
 }
 
 v8::Local<v8::Value> ModuleSystem::RequireForJsInner(
     v8::Handle<v8::String> module_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   v8::Handle<v8::Object> global(context()->v8_context()->Global());
 
@@ skipping 132 matching lines @@
     // ModuleSystem has been deleted.
     // TODO(kalman): See comment in header file.
     Warn(info.GetIsolate(),
          "Module system has been deleted, does extension view exist?");
     return;
   }
 
   ModuleSystem* module_system = static_cast<ModuleSystem*>(
       v8::Handle<v8::External>::Cast(module_system_value)->Value());
 
-  std::string name =
-      *v8::String::Utf8Value(
-          parameters->Get(v8::String::NewFromUtf8(info.GetIsolate(),
-                                                  kModuleName))->ToString());
+  std::string name = *v8::String::Utf8Value(parameters->Get(
+      v8::String::NewFromUtf8(info.GetIsolate(), kModuleName)));
 
   // Switch to our v8 context because we need functions created while running
   // the require()d module to belong to our context, not the current one.
   v8::Context::Scope context_scope(context);
   NativesEnabledScope natives_enabled_scope(module_system);
 
   v8::TryCatch try_catch;
   v8::Handle<v8::Value> module_value = (module_system->*require_function)(name);
   if (try_catch.HasCaught()) {
     module_system->HandleException(try_catch);
     return;
   }
   if (module_value.IsEmpty() || !module_value->IsObject()) {
     // require_function will have already logged this, we don't need to.
     return;
   }
 
   v8::Handle<v8::Object> module = v8::Handle<v8::Object>::Cast(module_value);
   v8::Handle<v8::String> field =
       parameters->Get(v8::String::NewFromUtf8(info.GetIsolate(), kModuleField))
-          ->ToString();
+          ->ToString(info.GetIsolate());
 
   if (!module->Has(field)) {
     std::string field_str = *v8::String::Utf8Value(field);
     Fatal(module_system->context_,
           "Lazy require of " + name + "." + field_str + " did not set the " +
               field_str + " field");
     return;
   }
 
   v8::Local<v8::Value> new_field = module->Get(field);
@@ skipping 92 matching lines @@
   v8::EscapableHandleScope handle_scope(GetIsolate());
   if (!source_map_->Contains(module_name))
     return v8::Undefined(GetIsolate());
   return handle_scope.Escape(
       v8::Local<v8::Value>(source_map_->GetSource(GetIsolate(), module_name)));
 }
 
 void ModuleSystem::RequireNative(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
-  std::string native_name = *v8::String::Utf8Value(args[0]->ToString());
+  std::string native_name = *v8::String::Utf8Value(args[0]);
   args.GetReturnValue().Set(RequireNativeFromString(native_name));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireNativeFromString(
     const std::string& native_name) {
   if (natives_enabled_ == 0) {
     // HACK: if in test throw exception so that we can test the natives-disabled
     // logic; however, under normal circumstances, this is programmer error so
     // we could crash.
     if (exception_handler_) {
@@ skipping 14 matching lines @@
     Fatal(context_,
           "Couldn't find native for requireNative(" + native_name + ")");
     return v8::Undefined(GetIsolate());
   }
   return i->second->NewInstance();
 }
 
 void ModuleSystem::RequireAsync(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
-  std::string module_name = *v8::String::Utf8Value(args[0]->ToString());
+  std::string module_name = *v8::String::Utf8Value(args[0]);
   v8::Handle<v8::Promise::Resolver> resolver(
       v8::Promise::Resolver::New(GetIsolate()));
   args.GetReturnValue().Set(resolver->GetPromise());
   scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > persistent_resolver(
       new v8::UniquePersistent<v8::Promise::Resolver>(GetIsolate(), resolver));
   gin::ModuleRegistry* module_registry =
       gin::ModuleRegistry::From(context_->v8_context());
   if (!module_registry) {
     Warn(GetIsolate(), "Extension view no longer exists");
     resolver->Reject(v8::Exception::Error(v8::String::NewFromUtf8(
@@ skipping 132 matching lines @@
     v8::Handle<v8::Value> value) {
   if (!is_valid())
     return;
   v8::HandleScope handle_scope(GetIsolate());
   v8::Handle<v8::Promise::Resolver> resolver_local(
       v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));
   resolver_local->Resolve(value);
 }
 
 }  // namespace extensions