Replace extensions::ScopedPersistent with v8::UniquePersistent.

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 245 matching lines @@
           v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
       return;
     }
     stream2.reset(new CastRtpStream(track.component(), session));
   }
   scoped_ptr<CastUdpTransport> udp_transport(
       new CastUdpTransport(session));
 
   // TODO(imcheng): Use a weak reference to ensure we don't call into an
   // invalid context when the callback is invoked.
-  create_callback_.reset(args[2].As<v8::Function>());
+  create_callback_.Reset(isolate, args[2].As<v8::Function>());
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(
           &CastStreamingNativeHandler::CallCreateCallback,
           weak_factory_.GetWeakPtr(),
           base::Passed(&stream1),
           base::Passed(&stream2),
           base::Passed(&udp_transport)));
 }
@@ skipping 19 matching lines @@
   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(create_callback_.NewHandle(isolate),
-                          3, callback_args);
-  create_callback_.reset();
+  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);
   event_args->Set(0, v8::Integer::New(isolate, stream_id));
   context()->DispatchEvent("cast.streaming.rtpStream.onStarted", event_args);
 }
@@ skipping 193 matching lines @@
 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(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>()));
+  linked_ptr<v8::UniquePersistent<v8::Function>> callback(
+      new v8::UniquePersistent<v8::Function>(args.GetIsolate(),
+                                             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));
@@ skipping 10 matching lines @@
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsFunction());
   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>()));
+  linked_ptr<v8::UniquePersistent<v8::Function>> callback(
+      new v8::UniquePersistent<v8::Function>(args.GetIsolate(),
+                                             args[1].As<v8::Function>()));
   get_stats_callbacks_.insert(std::make_pair(transport_id, callback));
 
   transport->GetStats(
       base::Bind(&CastStreamingNativeHandler::CallGetStatsCallback,
                  weak_factory_.GetWeakPtr(),
                  transport_id));
 }
 
 void CastStreamingNativeHandler::CallGetRawEventsCallback(
     int transport_id,
     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;
-  v8::Handle<v8::Value> callback_args[1];
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  callback_args[0] =
-      converter->ToV8Value(raw_events.get(), context()->v8_context());
-  context()->CallFunction(it->second->NewHandle(isolate), 1, callback_args);
+  v8::Handle<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[1];
-  callback_args[0] = converter->ToV8Value(stats.get(), context()->v8_context());
-  context()->CallFunction(it->second->NewHandle(isolate), 1, callback_args);
+  v8::Handle<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);
   if (iter != rtp_stream_map_.end())
     return iter->second.get();
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
@@ skipping 44 matching lines @@
     return false;
   }
   config->channels = 2;
   if (params->codec_name == "OPUS") {
     config->codec = media::cast::CODEC_AUDIO_OPUS;
     config->rtp_timebase = 48000;
     config->rtp_payload_type = 127;
   } else if (params->codec_name == "PCM16") {
     config->codec = media::cast::CODEC_AUDIO_PCM16;
     config->rtp_timebase = 48000;
-    config->rtp_payload_type =127;
+    config->rtp_payload_type = 127;
   } else if (params->codec_name == "AAC") {
     config->codec = media::cast::CODEC_AUDIO_AAC;
     config->rtp_timebase = 48000;
     config->rtp_payload_type = 127;
   } else if (params->codec_name == "VP8") {
     config->codec = media::cast::CODEC_VIDEO_VP8;
     config->rtp_timebase = 90000;
     config->rtp_payload_type = 96;
   } else if (params->codec_name == "H264") {
     config->codec = media::cast::CODEC_VIDEO_H264;
@@ skipping 178 matching lines @@
 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