Use v8::Local inplace of v8::Handle in src/chrome/*

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 259 matching lines @@
 }
 
 void CastStreamingNativeHandler::CallCreateCallback(
     scoped_ptr<CastRtpStream> stream1,
     scoped_ptr<CastRtpStream> stream2,
     scoped_ptr<CastUdpTransport> udp_transport) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
 
-  v8::Handle<v8::Value> callback_args[3];
+  v8::Local<v8::Value> callback_args[3];
   callback_args[0] = v8::Null(isolate);
   callback_args[1] = v8::Null(isolate);
 
   if (stream1) {
     const int stream1_id = last_transport_id_++;
     callback_args[0] = v8::Integer::New(isolate, stream1_id);
     rtp_stream_map_[stream1_id] =
         linked_ptr<CastRtpStream>(stream1.release());
   }
   if (stream2) {
     const int stream2_id = last_transport_id_++;
     callback_args[1] = v8::Integer::New(isolate, stream2_id);
     rtp_stream_map_[stream2_id] =
         linked_ptr<CastRtpStream>(stream2.release());
   }
   const int udp_id = last_transport_id_++;
   udp_transport_map_[udp_id] =
       linked_ptr<CastUdpTransport>(udp_transport.release());
   callback_args[2] = v8::Integer::New(isolate, udp_id);
   context()->CallFunction(
       v8::Local<v8::Function>::New(isolate, create_callback_), 3,
       callback_args);
   create_callback_.Reset();
 }
 
 void CastStreamingNativeHandler::CallStartCallback(int stream_id) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
-  v8::Handle<v8::Array> event_args = v8::Array::New(isolate, 1);
+  v8::Local<v8::Array> event_args = v8::Array::New(isolate, 1);
   event_args->Set(0, v8::Integer::New(isolate, stream_id));
   context()->DispatchEvent("cast.streaming.rtpStream.onStarted", event_args);
 }
 
 void CastStreamingNativeHandler::CallStopCallback(int stream_id) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
-  v8::Handle<v8::Array> event_args = v8::Array::New(isolate, 1);
+  v8::Local<v8::Array> event_args = v8::Array::New(isolate, 1);
   event_args->Set(0, v8::Integer::New(isolate, stream_id));
   context()->DispatchEvent("cast.streaming.rtpStream.onStopped", event_args);
 }
 
 void CastStreamingNativeHandler::CallErrorCallback(int stream_id,
                                                    const std::string& message) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
-  v8::Handle<v8::Array> event_args = v8::Array::New(isolate, 2);
+  v8::Local<v8::Array> event_args = v8::Array::New(isolate, 2);
   event_args->Set(0, v8::Integer::New(isolate, stream_id));
   event_args->Set(
       1,
       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) {
@@ skipping 11 matching lines @@
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
   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::Local<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()));
   }
@@ skipping 189 matching lines @@
     scoped_ptr<base::BinaryValue> raw_events) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
 
   RtpStreamCallbackMap::iterator it =
       get_raw_events_callbacks_.find(transport_id);
   if (it == get_raw_events_callbacks_.end())
     return;
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  v8::Handle<v8::Value> callback_args[] = {
+  v8::Local<v8::Value> callback_args[] = {
       converter->ToV8Value(raw_events.get(), context()->v8_context())};
   context()->CallFunction(v8::Local<v8::Function>::New(isolate, *it->second),
                           arraysize(callback_args), callback_args);
   get_raw_events_callbacks_.erase(it);
 }
 
 void CastStreamingNativeHandler::CallGetStatsCallback(
     int transport_id,
     scoped_ptr<base::DictionaryValue> stats) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
 
   RtpStreamCallbackMap::iterator it = get_stats_callbacks_.find(transport_id);
   if (it == get_stats_callbacks_.end())
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  v8::Handle<v8::Value> callback_args[] = {
+  v8::Local<v8::Value> callback_args[] = {
       converter->ToV8Value(stats.get(), context()->v8_context())};
   context()->CallFunction(v8::Local<v8::Function>::New(isolate, *it->second),
                           arraysize(callback_args), callback_args);
   get_stats_callbacks_.erase(it);
 }
 
 CastRtpStream* CastStreamingNativeHandler::GetRtpStreamOrThrow(
     int transport_id) const {
   RtpStreamMap::const_iterator iter = rtp_stream_map_.find(
       transport_id);
@@ skipping 12 matching lines @@
   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;
 }
 
 bool CastStreamingNativeHandler::FrameReceiverConfigFromArg(
     v8::Isolate* isolate,
-    const v8::Handle<v8::Value>& arg,
+    const v8::Local<v8::Value>& arg,
     media::cast::FrameReceiverConfig* config) {
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   scoped_ptr<base::Value> params_value(
       converter->FromV8Value(arg, context()->v8_context()));
   if (!params_value) {
     isolate->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(isolate, kUnableToConvertParams)));
     return false;
   }
@@ skipping 53 matching lines @@
       !HexDecode(*params->aes_iv_mask, &config->aes_iv_mask)) {
     isolate->ThrowException(v8::Exception::Error(
         v8::String::NewFromUtf8(isolate, kInvalidAesIvMask)));
     return false;
   }
   return true;
 }
 
 bool CastStreamingNativeHandler::IPEndPointFromArg(
     v8::Isolate* isolate,
-    const v8::Handle<v8::Value>& arg,
+    const v8::Local<v8::Value>& arg,
     net::IPEndPoint* ip_endpoint) {
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   scoped_ptr<base::Value> destination_value(
       converter->FromV8Value(arg, context()->v8_context()));
   if (!destination_value) {
     isolate->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(isolate, kInvalidAesIvMask)));
     return false;
   }
   scoped_ptr<IPEndPoint> destination =
@@ skipping 98 matching lines @@
       }
     }
   }
 
   if (!options) {
     options = new base::DictionaryValue();
   }
 
   v8::CopyablePersistentTraits<v8::Function>::CopyablePersistent error_callback;
   error_callback.Reset(args.GetIsolate(),
-                       v8::Handle<v8::Function>(args[7].As<v8::Function>()));
+                       v8::Local<v8::Function>(args[7].As<v8::Function>()));
 
   session->Start(
       audio_config,
       video_config,
       local_endpoint,
       remote_endpoint,
       make_scoped_ptr(options),
       capture_format,
       base::Bind(&CastStreamingNativeHandler::AddTracksToMediaStream,
                  weak_factory_.GetWeakPtr(),
                  url,
                  params),
       base::Bind(&CastStreamingNativeHandler::CallReceiverErrorCallback,
                  weak_factory_.GetWeakPtr(),
                  error_callback));
 }
 
 void CastStreamingNativeHandler::CallReceiverErrorCallback(
     v8::CopyablePersistentTraits<v8::Function>::CopyablePersistent function,
     const std::string& error_message) {
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
-  v8::Handle<v8::Value> arg = v8::String::NewFromUtf8(isolate,
+  v8::Local<v8::Value> arg = v8::String::NewFromUtf8(isolate,
                                                       error_message.data(),
                                                       v8::String::kNormalString,
                                                       error_message.size());
   context()->CallFunction(
       v8::Local<v8::Function>::New(isolate, function), 1, &arg);
 }
 
 
 void CastStreamingNativeHandler::AddTracksToMediaStream(
     const std::string& url,
     const media::AudioParameters& params,
     scoped_refptr<media::AudioCapturerSource> audio,
     scoped_ptr<media::VideoCapturerSource> video) {
   content::AddAudioTrackToMediaStream(audio, params, true, true, url);
   content::AddVideoTrackToMediaStream(video.Pass(), true, true, url);
 }
 
 }  // namespace extensions