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

content/renderer/gpu/gpu_benchmarking_extension.cc

 // Copyright (c) 2012 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 "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 293 matching lines @@
 };
 
 void OnMicroBenchmarkCompleted(CallbackAndContext* callback_and_context,
                                std::unique_ptr<base::Value> result) {
   v8::Isolate* isolate = callback_and_context->isolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Context> context = callback_and_context->GetContext();
   v8::Context::Scope context_scope(context);
   WebLocalFrame* frame = WebLocalFrame::FrameForContext(context);
   if (frame) {
-    std::unique_ptr<V8ValueConverter> converter =
-        base::WrapUnique(V8ValueConverter::create());
-    v8::Local<v8::Value> value = converter->ToV8Value(result.get(), context);
+    v8::Local<v8::Value> value =
+        V8ValueConverter::Create()->ToV8Value(result.get(), context);
     v8::Local<v8::Value> argv[] = { value };
 
     frame->CallFunctionEvenIfScriptDisabled(callback_and_context->GetCallback(),
                                             v8::Object::New(isolate), 1, argv);
   }
 }
 
 void OnSyntheticGestureCompleted(CallbackAndContext* callback_and_context) {
   v8::Isolate* isolate = callback_and_context->isolate();
   v8::HandleScope scope(isolate);
@@ skipping 691 matching lines @@
     return false;
 
   v8::Local<v8::Function> callback;
 
   v8::Local<v8::Object> obj;
   if (!args->GetNext(&obj)) {
     args->ThrowError();
     return false;
   }
 
-  std::unique_ptr<V8ValueConverter> converter =
-      base::WrapUnique(V8ValueConverter::create());
   v8::Local<v8::Context> v8_context =
       context.web_frame()->MainWorldScriptContext();
-  std::unique_ptr<base::Value> value = converter->FromV8Value(obj, v8_context);
+  std::unique_ptr<base::Value> value =
+      V8ValueConverter::Create()->FromV8Value(obj, v8_context);
 
   // Get all the pointer actions from the user input and wrap them into a
   // SyntheticPointerActionListParams object.
   ActionsParser actions_parser(value.get());
   if (!actions_parser.ParsePointerActionSequence())
     return false;
 
   std::unique_ptr<SyntheticPointerActionListParams> gesture_params =
       actions_parser.gesture_params();
 
@@ skipping 31 matching lines @@
 
   if (!GetArg(args, &name) || !GetArg(args, &callback) ||
       !GetOptionalArg(args, &arguments)) {
     return 0;
   }
 
   scoped_refptr<CallbackAndContext> callback_and_context =
       new CallbackAndContext(args->isolate(), callback,
                              context.web_frame()->MainWorldScriptContext());
 
-  std::unique_ptr<V8ValueConverter> converter =
-      base::WrapUnique(V8ValueConverter::create());
   v8::Local<v8::Context> v8_context = callback_and_context->GetContext();
   std::unique_ptr<base::Value> value =
-      converter->FromV8Value(arguments, v8_context);
+      V8ValueConverter::Create()->FromV8Value(arguments, v8_context);
 
   return context.compositor()->ScheduleMicroBenchmark(
       name, std::move(value),
       base::Bind(&OnMicroBenchmarkCompleted,
                  base::RetainedRef(callback_and_context)));
 }
 
 bool GpuBenchmarking::SendMessageToMicroBenchmark(
     int id,
     v8::Local<v8::Object> message) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return false;
 
-  std::unique_ptr<V8ValueConverter> converter =
-      base::WrapUnique(V8ValueConverter::create());
   v8::Local<v8::Context> v8_context =
       context.web_frame()->MainWorldScriptContext();
   std::unique_ptr<base::Value> value =
-      converter->FromV8Value(message, v8_context);
+      V8ValueConverter::Create()->FromV8Value(message, v8_context);
 
   return context.compositor()->SendMessageToMicroBenchmark(id,
                                                            std::move(value));
 }
 
 bool GpuBenchmarking::HasGpuChannel() {
   gpu::GpuChannelHost* gpu_channel =
       RenderThreadImpl::current()->GetGpuChannel();
   return !!gpu_channel;
 }
@@ skipping 16 matching lines @@
           &gpu_driver_bug_workarounds))) {
     return;
   }
 
   v8::Local<v8::Value> result;
   if (gin::TryConvertToV8(args->isolate(), gpu_driver_bug_workarounds, &result))
     args->Return(result);
 }
 
 }  // namespace content