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

chrome/renderer/extensions/cast_streaming_native_handler.cc

 // Copyright 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 "chrome/renderer/extensions/cast_streaming_native_handler.h"
 
 #include <functional>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 309 matching lines @@
       v8::String::NewFromUtf8(
           isolate, message.data(), v8::String::kNormalString, message.size()));
   context()->DispatchEvent("cast.streaming.rtpStream.onError", event_args);
 }
 
 void CastStreamingNativeHandler::DestroyCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   if (!GetRtpStreamOrThrow(transport_id))
     return;
   rtp_stream_map_.erase(transport_id);
 }
 
 void CastStreamingNativeHandler::GetSupportedParamsCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   std::vector<CastRtpParams> cast_params = transport->GetSupportedParams();
   v8::Handle<v8::Array> result =
       v8::Array::New(args.GetIsolate(),
                      static_cast<int>(cast_params.size()));
   for (size_t i = 0; i < cast_params.size(); ++i) {
     RtpParams params;
     FromCastRtpParams(cast_params[i], &params);
     scoped_ptr<base::DictionaryValue> params_value = params.ToValue();
     result->Set(
         static_cast<int>(i),
         converter->ToV8Value(params_value.get(), context()->v8_context()));
   }
   args.GetReturnValue().Set(result);
 }
 
 void CastStreamingNativeHandler::StartCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsObject());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   scoped_ptr<base::Value> params_value(
       converter->FromV8Value(args[1], context()->v8_context()));
   if (!params_value) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertParams)));
@@ skipping 24 matching lines @@
                  weak_factory_.GetWeakPtr(),
                  transport_id);
   transport->Start(cast_params, start_callback, stop_callback, error_callback);
 }
 
 void CastStreamingNativeHandler::StopCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
   transport->Stop();
 }
 
 void CastStreamingNativeHandler::DestroyCastUdpTransport(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   if (!GetUdpTransportOrThrow(transport_id))
     return;
   udp_transport_map_.erase(transport_id);
 }
 
 void CastStreamingNativeHandler::SetDestinationCastUdpTransport(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsObject());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
   if (!transport)
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   scoped_ptr<base::Value> destination_value(
       converter->FromV8Value(args[1], context()->v8_context()));
   if (!destination_value) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
@@ skipping 14 matching lines @@
   }
   transport->SetDestination(net::IPEndPoint(ip, destination->port));
 }
 
 void CastStreamingNativeHandler::SetOptionsCastUdpTransport(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsObject());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
   if (!transport)
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   base::Value* options_value =
       converter->FromV8Value(args[1], context()->v8_context());
   base::DictionaryValue* options;
   if (!options_value || !options_value->GetAsDictionary(&options)) {
     delete options_value;
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
     return;
   }
   transport->SetOptions(make_scoped_ptr(options));
 }
 
 void CastStreamingNativeHandler::ToggleLogging(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsBoolean());
 
-  const int stream_id = args[0]->ToInt32()->Value();
+  const int stream_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastRtpStream* stream = GetRtpStreamOrThrow(stream_id);
   if (!stream)
     return;
 
-  const bool enable = args[1]->ToBoolean()->Value();
+  const bool enable = args[1]->ToBoolean(args.GetIsolate())->Value();
   stream->ToggleLogging(enable);
 }
 
 void CastStreamingNativeHandler::GetRawEvents(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(3, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsNull() || args[1]->IsString());
   CHECK(args[2]->IsFunction());
 
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   // TODO(imcheng): Use a weak reference to ensure we don't call into an
   // invalid context when the callback is invoked.
   linked_ptr<ScopedPersistent<v8::Function> > callback(
       new ScopedPersistent<v8::Function>(args[2].As<v8::Function>()));
   std::string extra_data;
   if (!args[1]->IsNull()) {
     extra_data = *v8::String::Utf8Value(args[1]);
   }
 
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
 
   get_raw_events_callbacks_.insert(std::make_pair(transport_id, callback));
 
   transport->GetRawEvents(
       base::Bind(&CastStreamingNativeHandler::CallGetRawEventsCallback,
                  weak_factory_.GetWeakPtr(),
                  transport_id),
       extra_data);
 }
 
 void CastStreamingNativeHandler::GetStats(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsFunction());
-  const int transport_id = args[0]->ToInt32()->Value();
+  const int transport_id = args[0]->ToInt32(args.GetIsolate())->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
 
   // TODO(imcheng): Use a weak reference to ensure we don't call into an
   // invalid context when the callback is invoked.
   linked_ptr<ScopedPersistent<v8::Function> > callback(
       new ScopedPersistent<v8::Function>(args[1].As<v8::Function>()));
   get_stats_callbacks_.insert(std::make_pair(transport_id, callback));
 
@@ skipping 58 matching lines @@
       transport_id);
   if (iter != udp_transport_map_.end())
     return iter->second.get();
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
   isolate->ThrowException(v8::Exception::RangeError(
       v8::String::NewFromUtf8(isolate, kUdpTransportNotFound)));
   return NULL;
 }
 
 }  // namespace extensions