[Content] Update V8ValueConverter::create to return a std::unique_ptr

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 478 matching lines @@
 void CastStreamingNativeHandler::GetSupportedParamsCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) const {
   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;
 
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+  std::unique_ptr<V8ValueConverter> converter = V8ValueConverter::Create();
   std::vector<FrameSenderConfig> configs = transport->GetSupportedConfigs();
   v8::Local<v8::Array> result =
       v8::Array::New(args.GetIsolate(), static_cast<int>(configs.size()));
   for (size_t i = 0; i < configs.size(); ++i) {
     RtpParams params;
     FromFrameSenderConfig(configs[i], &params.payload);
     std::unique_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(args.GetIsolate())->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
 
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  std::unique_ptr<base::Value> params_value(
-      converter->FromV8Value(args[1], context()->v8_context()));
+  std::unique_ptr<base::Value> params_value =
+      V8ValueConverter::Create()->FromV8Value(args[1], context()->v8_context());
   if (!params_value) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertParams)));
     return;
   }
   std::unique_ptr<RtpParams> params = RtpParams::FromValue(*params_value);
   if (!params) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidRtpParams)));
     return;
@@ skipping 73 matching lines @@
     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(args.GetIsolate())->Value();
   CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
   if (!transport)
     return;
 
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  std::unique_ptr<base::DictionaryValue> options = base::DictionaryValue::From(
-      converter->FromV8Value(args[1], context()->v8_context()));
+  std::unique_ptr<base::DictionaryValue> options =
+      base::DictionaryValue::From(V8ValueConverter::Create()->FromV8Value(
+          args[1], context()->v8_context()));
   if (!options) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
     return;
   }
   transport->SetOptions(std::move(options));
 }
 
 void CastStreamingNativeHandler::ToggleLogging(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
@@ skipping 64 matching lines @@
     int transport_id,
     std::unique_ptr<base::Value> 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;
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  v8::Local<v8::Value> callback_args[] = {
-      converter->ToV8Value(raw_events.get(), context()->v8_context())};
+  v8::Local<v8::Value> callback_args[] = {V8ValueConverter::Create()->ToV8Value(
+      raw_events.get(), context()->v8_context())};
   context()->SafeCallFunction(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,
     std::unique_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;
 
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  v8::Local<v8::Value> callback_args[] = {
-      converter->ToV8Value(stats.get(), context()->v8_context())};
+  v8::Local<v8::Value> callback_args[] = {V8ValueConverter::Create()->ToV8Value(
+      stats.get(), context()->v8_context())};
   context()->SafeCallFunction(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())
@@ skipping 13 matching lines @@
   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::Local<v8::Value>& arg,
     media::cast::FrameReceiverConfig* config) const {
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  std::unique_ptr<base::Value> params_value(
-      converter->FromV8Value(arg, context()->v8_context()));
+  std::unique_ptr<base::Value> params_value =
+      V8ValueConverter::Create()->FromV8Value(arg, context()->v8_context());
   if (!params_value) {
     isolate->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(isolate, kUnableToConvertParams)));
     return false;
   }
   std::unique_ptr<RtpReceiverParams> params =
       RtpReceiverParams::FromValue(*params_value);
   if (!params) {
     isolate->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(isolate, kInvalidRtpParams)));
@@ skipping 50 matching lines @@
         v8::String::NewFromUtf8(isolate, kInvalidAesIvMask)));
     return false;
   }
   return true;
 }
 
 bool CastStreamingNativeHandler::IPEndPointFromArg(
     v8::Isolate* isolate,
     const v8::Local<v8::Value>& arg,
     net::IPEndPoint* ip_endpoint) const {
-  std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  std::unique_ptr<base::Value> destination_value(
-      converter->FromV8Value(arg, context()->v8_context()));
+  std::unique_ptr<base::Value> destination_value =
+      V8ValueConverter::Create()->FromV8Value(arg, context()->v8_context());
   if (!destination_value) {
     isolate->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(isolate, kInvalidAesIvMask)));
     return false;
   }
   std::unique_ptr<IPEndPoint> destination =
       IPEndPoint::FromValue(*destination_value);
   if (!destination) {
     isolate->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(isolate, kInvalidDestination)));
@@ skipping 73 matching lines @@
                            audio_config.target_frame_rate));
 
   if (!params.IsValid()) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidAudioParams)));
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> options;
   if (args.Length() >= 9) {
-    std::unique_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-    std::unique_ptr<base::Value> options_value(
-        converter->FromV8Value(args[8], context()->v8_context()));
+    std::unique_ptr<base::Value> options_value =
+        V8ValueConverter::Create()->FromV8Value(args[8],
+                                                context()->v8_context());
     if (!options_value->IsType(base::Value::Type::NONE)) {
       options = base::DictionaryValue::From(std::move(options_value));
       if (!options) {
         args.GetIsolate()->ThrowException(v8::Exception::TypeError(
             v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
         return;
       }
     }
   }
 
@@ skipping 43 matching lines @@
           &web_stream)) {
     LOG(ERROR) << "Failed to add Cast audio track to media stream.";
   }
   if (!content::AddVideoTrackToMediaStream(std::move(video), true,  // is_remote
                                            &web_stream)) {
     LOG(ERROR) << "Failed to add Cast video track to media stream.";
   }
 }
 
 }  // namespace extensions