Use std::unique_ptr<base::Value> in V8ValueConverter.

content/renderer/java/gin_java_bridge_value_converter.cc

 // Copyright 2014 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/java/gin_java_bridge_value_converter.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 20 matching lines @@
 
 v8::Local<v8::Value> GinJavaBridgeValueConverter::ToV8Value(
     const base::Value* value,
     v8::Local<v8::Context> context) const {
   return converter_->ToV8Value(value, context);
 }
 
 std::unique_ptr<base::Value> GinJavaBridgeValueConverter::FromV8Value(
     v8::Local<v8::Value> value,
     v8::Local<v8::Context> context) const {
-  return base::WrapUnique(converter_->FromV8Value(value, context));
+  return converter_->FromV8Value(value, context);
 }
 
 bool GinJavaBridgeValueConverter::FromV8Object(
     v8::Local<v8::Object> value,
-    base::Value** out,
+    std::unique_ptr<base::Value>* out,
     v8::Isolate* isolate,
     const FromV8ValueCallback& callback) const {
   GinJavaBridgeObject* unwrapped;
   if (!gin::ConvertFromV8(isolate, value, &unwrapped)) {
     return false;
   }
-  *out =
-      GinJavaBridgeValue::CreateObjectIDValue(unwrapped->object_id()).release();
+  *out = GinJavaBridgeValue::CreateObjectIDValue(unwrapped->object_id());
   return true;
 }
 
 namespace {
 
 class TypedArraySerializer {
  public:
   virtual ~TypedArraySerializer() {}
   static std::unique_ptr<TypedArraySerializer> Create(
       v8::Local<v8::TypedArray> typed_array);
@@ skipping 52 matching lines @@
     return TypedArraySerializerImpl<double, double>::Create(typed_array);
   }
   NOTREACHED();
   return std::unique_ptr<TypedArraySerializer>();
 }
 
 }  // namespace
 
 bool GinJavaBridgeValueConverter::FromV8ArrayBuffer(
     v8::Local<v8::Object> value,
-    base::Value** out,
+    std::unique_ptr<base::Value>* out,
     v8::Isolate* isolate) const {
   if (!value->IsTypedArray()) {
-    *out = GinJavaBridgeValue::CreateUndefinedValue().release();
+    *out = GinJavaBridgeValue::CreateUndefinedValue();
     return true;
   }
 
   char* data = NULL;
   size_t data_length = 0;
   gin::ArrayBufferView view;
   if (ConvertFromV8(isolate, value.As<v8::ArrayBufferView>(), &view)) {
     data = reinterpret_cast<char*>(view.bytes());
     data_length = view.num_bytes();
   }
   if (!data) {
-    *out = GinJavaBridgeValue::CreateUndefinedValue().release();
+    *out = GinJavaBridgeValue::CreateUndefinedValue();
     return true;
   }
 
-  base::ListValue* result = new base::ListValue();
-  *out = result;
+  std::unique_ptr<base::ListValue> result(new base::ListValue);
   std::unique_ptr<TypedArraySerializer> serializer(
       TypedArraySerializer::Create(value.As<v8::TypedArray>()));
-  serializer->serializeTo(data, data_length, result);
+  serializer->serializeTo(data, data_length, result.get());
+  *out = std::move(result);
   return true;
 }
 
-bool GinJavaBridgeValueConverter::FromV8Number(v8::Local<v8::Number> value,
-                                               base::Value** out) const {
+bool GinJavaBridgeValueConverter::FromV8Number(
+    v8::Local<v8::Number> value,
+    std::unique_ptr<base::Value>* out) const {
   double double_value = value->Value();
   if (std::isfinite(double_value))
     return false;
-  *out = GinJavaBridgeValue::CreateNonFiniteValue(double_value).release();
+  *out = GinJavaBridgeValue::CreateNonFiniteValue(double_value);
   return true;
 }
 
-bool GinJavaBridgeValueConverter::FromV8Undefined(base::Value** out) const {
-  *out = GinJavaBridgeValue::CreateUndefinedValue().release();
+bool GinJavaBridgeValueConverter::FromV8Undefined(
+    std::unique_ptr<base::Value>* out) const {
+  *out = GinJavaBridgeValue::CreateUndefinedValue();
   return true;
 }
 
 }  // namespace content