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

content/child/v8_value_converter_impl.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/child/v8_value_converter_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "third_party/WebKit/public/web/WebArrayBuffer.h"
 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
 #include "third_party/WebKit/public/web/WebArrayBufferView.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
 // Default implementation of V8ValueConverter::Strategy
 
 bool V8ValueConverter::Strategy::FromV8Object(
     v8::Local<v8::Object> value,
-    base::Value** out,
+    std::unique_ptr<base::Value>* out,
     v8::Isolate* isolate,
     const FromV8ValueCallback& callback) const {
   return false;
 }
 
 bool V8ValueConverter::Strategy::FromV8Array(
     v8::Local<v8::Array> value,
-    base::Value** out,
+    std::unique_ptr<base::Value>* out,
     v8::Isolate* isolate,
     const FromV8ValueCallback& callback) const {
   return false;
 }
 
-bool V8ValueConverter::Strategy::FromV8ArrayBuffer(v8::Local<v8::Object> value,
-                                                   base::Value** out,
-                                                   v8::Isolate* isolate) const {
+bool V8ValueConverter::Strategy::FromV8ArrayBuffer(
+    v8::Local<v8::Object> value,
+    std::unique_ptr<base::Value>* out,
+    v8::Isolate* isolate) const {
   return false;
 }
 
-bool V8ValueConverter::Strategy::FromV8Number(v8::Local<v8::Number> value,
-                                              base::Value** out) const {
+bool V8ValueConverter::Strategy::FromV8Number(
+    v8::Local<v8::Number> value,
+    std::unique_ptr<base::Value>* out) const {
   return false;
 }
 
-bool V8ValueConverter::Strategy::FromV8Undefined(base::Value** out) const {
+bool V8ValueConverter::Strategy::FromV8Undefined(
+    std::unique_ptr<base::Value>* out) const {
   return false;
 }
 
 
 namespace {
 
 // For the sake of the storage API, make this quite large.
 const int kMaxRecursionDepth = 100;
 
 }  // namespace
@@ skipping 140 matching lines @@
 }
 
 v8::Local<v8::Value> V8ValueConverterImpl::ToV8Value(
     const base::Value* value, v8::Local<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::EscapableHandleScope handle_scope(context->GetIsolate());
   return handle_scope.Escape(
       ToV8ValueImpl(context->GetIsolate(), context->Global(), value));
 }
 
-base::Value* V8ValueConverterImpl::FromV8Value(
+std::unique_ptr<base::Value> V8ValueConverterImpl::FromV8Value(
     v8::Local<v8::Value> val,
     v8::Local<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
   FromV8ValueState state(avoid_identity_hash_for_testing_);
   return FromV8ValueImpl(&state, val, context->GetIsolate());
 }
 
 v8::Local<v8::Value> V8ValueConverterImpl::ToV8ValueImpl(
     v8::Isolate* isolate,
@@ skipping 108 matching lines @@
     v8::Isolate* isolate,
     v8::Local<v8::Object> creation_context,
     const base::BinaryValue* value) const {
   blink::WebArrayBuffer buffer =
       blink::WebArrayBuffer::create(value->GetSize(), 1);
   memcpy(buffer.data(), value->GetBuffer(), value->GetSize());
   return blink::WebArrayBufferConverter::toV8Value(
       &buffer, creation_context, isolate);
 }
 
-base::Value* V8ValueConverterImpl::FromV8ValueImpl(
+std::unique_ptr<base::Value> V8ValueConverterImpl::FromV8ValueImpl(
     FromV8ValueState* state,
     v8::Local<v8::Value> val,
     v8::Isolate* isolate) const {
   CHECK(!val.IsEmpty());
 
   FromV8ValueState::Level state_level(state);
   if (state->HasReachedMaxRecursionDepth())
-    return NULL;
+    return nullptr;
 
   if (val->IsNull())
-    return base::Value::CreateNullValue().release();
+    return base::Value::CreateNullValue();
 
   if (val->IsBoolean())
-    return new base::FundamentalValue(val->ToBoolean(isolate)->Value());
+    return base::MakeUnique<base::FundamentalValue>(
+        val->ToBoolean(isolate)->Value());
 
   if (val->IsNumber() && strategy_) {
-    base::Value* out = NULL;
+    std::unique_ptr<base::Value> out;
     if (strategy_->FromV8Number(val.As<v8::Number>(), &out))
       return out;
   }
 
   if (val->IsInt32())
-    return new base::FundamentalValue(val->ToInt32(isolate)->Value());
+    return base::MakeUnique<base::FundamentalValue>(
+        val->ToInt32(isolate)->Value());
 
   if (val->IsNumber()) {
     double val_as_double = val.As<v8::Number>()->Value();
     if (!std::isfinite(val_as_double))
-      return NULL;
-    return new base::FundamentalValue(val_as_double);
+      return nullptr;
+    return base::MakeUnique<base::FundamentalValue>(val_as_double);
   }
 
   if (val->IsString()) {
     v8::String::Utf8Value utf8(val);
-    return new base::StringValue(std::string(*utf8, utf8.length()));
+    return base::MakeUnique<base::StringValue>(
+        std::string(*utf8, utf8.length()));
   }
 
   if (val->IsUndefined()) {
     if (strategy_) {
-      base::Value* out = NULL;
+      std::unique_ptr<base::Value> out;
       if (strategy_->FromV8Undefined(&out))
         return out;
     }
     // JSON.stringify ignores undefined.
-    return NULL;
+    return nullptr;
   }
 
   if (val->IsDate()) {
     if (!date_allowed_)
       // JSON.stringify would convert this to a string, but an object is more
       // consistent within this class.
       return FromV8Object(val->ToObject(isolate), state, isolate);
     v8::Date* date = v8::Date::Cast(*val);
-    return new base::FundamentalValue(date->ValueOf() / 1000.0);
+    return base::MakeUnique<base::FundamentalValue>(date->ValueOf() / 1000.0);
   }
 
   if (val->IsRegExp()) {
     if (!reg_exp_allowed_)
       // JSON.stringify converts to an object.
       return FromV8Object(val.As<v8::Object>(), state, isolate);
-    return new base::StringValue(*v8::String::Utf8Value(val));
+    return base::MakeUnique<base::StringValue>(*v8::String::Utf8Value(val));
   }
 
   // v8::Value doesn't have a ToArray() method for some reason.
   if (val->IsArray())
     return FromV8Array(val.As<v8::Array>(), state, isolate);
 
   if (val->IsFunction()) {
     if (!function_allowed_)
       // JSON.stringify refuses to convert function(){}.
-      return NULL;
+      return nullptr;
     return FromV8Object(val.As<v8::Object>(), state, isolate);
   }
 
   if (val->IsArrayBuffer() || val->IsArrayBufferView())
     return FromV8ArrayBuffer(val.As<v8::Object>(), isolate);
 
   if (val->IsObject())
     return FromV8Object(val.As<v8::Object>(), state, isolate);
 
   LOG(ERROR) << "Unexpected v8 value type encountered.";
-  return NULL;
+  return nullptr;
 }
 
-base::Value* V8ValueConverterImpl::FromV8Array(
+std::unique_ptr<base::Value> V8ValueConverterImpl::FromV8Array(
     v8::Local<v8::Array> val,
     FromV8ValueState* state,
     v8::Isolate* isolate) const {
   ScopedUniquenessGuard uniqueness_guard(state, val);
   if (!uniqueness_guard.is_valid())
-    return base::Value::CreateNullValue().release();
+    return base::Value::CreateNullValue();
 
   std::unique_ptr<v8::Context::Scope> scope;
   // If val was created in a different context than our current one, change to
   // that context, but change back after val is converted.
   if (!val->CreationContext().IsEmpty() &&
       val->CreationContext() != isolate->GetCurrentContext())
     scope.reset(new v8::Context::Scope(val->CreationContext()));
 
   if (strategy_) {
     // These base::Unretained's are safe, because Strategy::FromV8Value should
     // be synchronous, so this object can't be out of scope.
     V8ValueConverter::Strategy::FromV8ValueCallback callback =
         base::Bind(&V8ValueConverterImpl::FromV8ValueImpl,
                    base::Unretained(this),
                    base::Unretained(state));
-    base::Value* out = NULL;
+    std::unique_ptr<base::Value> out;
     if (strategy_->FromV8Array(val, &out, isolate, callback))
       return out;
   }
 
-  base::ListValue* result = new base::ListValue();
+  std::unique_ptr<base::ListValue> result(new base::ListValue());
 
   // Only fields with integer keys are carried over to the ListValue.
   for (uint32_t i = 0; i < val->Length(); ++i) {
     v8::TryCatch try_catch(isolate);
     v8::Local<v8::Value> child_v8 = val->Get(i);
     if (try_catch.HasCaught()) {
       LOG(ERROR) << "Getter for index " << i << " threw an exception.";
       child_v8 = v8::Null(isolate);
     }
 
     if (!val->HasRealIndexedProperty(i)) {
       result->Append(base::Value::CreateNullValue());
       continue;
     }
 
-    base::Value* child = FromV8ValueImpl(state, child_v8, isolate);
+    std::unique_ptr<base::Value> child =
+        FromV8ValueImpl(state, child_v8, isolate);
     if (child)
-      result->Append(child);
+      result->Append(std::move(child));
     else
       // JSON.stringify puts null in places where values don't serialize, for
       // example undefined and functions. Emulate that behavior.
       result->Append(base::Value::CreateNullValue());
   }
-  return result;
+  return std::move(result);
 }
 
-base::Value* V8ValueConverterImpl::FromV8ArrayBuffer(
+std::unique_ptr<base::Value> V8ValueConverterImpl::FromV8ArrayBuffer(
     v8::Local<v8::Object> val,
     v8::Isolate* isolate) const {
   if (strategy_) {
-    base::Value* out = NULL;
+    std::unique_ptr<base::Value> out;
     if (strategy_->FromV8ArrayBuffer(val, &out, isolate))
       return out;
   }
 
   char* data = NULL;
   size_t length = 0;
 
   std::unique_ptr<blink::WebArrayBuffer> array_buffer(
       blink::WebArrayBufferConverter::createFromV8Value(val, isolate));
   std::unique_ptr<blink::WebArrayBufferView> view;
   if (array_buffer) {
     data = reinterpret_cast<char*>(array_buffer->data());
     length = array_buffer->byteLength();
   } else {
     view.reset(blink::WebArrayBufferView::createFromV8Value(val));
     if (view) {
       data = reinterpret_cast<char*>(view->baseAddress()) + view->byteOffset();
       length = view->byteLength();
     }
   }
 
   if (data)
-    return base::BinaryValue::CreateWithCopiedBuffer(data, length);
+    return base::WrapUnique(
+        base::BinaryValue::CreateWithCopiedBuffer(data, length));
   else
-    return NULL;
+    return nullptr;
 }
 
-base::Value* V8ValueConverterImpl::FromV8Object(
+std::unique_ptr<base::Value> V8ValueConverterImpl::FromV8Object(
     v8::Local<v8::Object> val,
     FromV8ValueState* state,
     v8::Isolate* isolate) const {
   ScopedUniquenessGuard uniqueness_guard(state, val);
   if (!uniqueness_guard.is_valid())
-    return base::Value::CreateNullValue().release();
+    return base::Value::CreateNullValue();
 
   std::unique_ptr<v8::Context::Scope> scope;
   // If val was created in a different context than our current one, change to
   // that context, but change back after val is converted.
   if (!val->CreationContext().IsEmpty() &&
       val->CreationContext() != isolate->GetCurrentContext())
     scope.reset(new v8::Context::Scope(val->CreationContext()));
 
   if (strategy_) {
     // These base::Unretained's are safe, because Strategy::FromV8Value should
     // be synchronous, so this object can't be out of scope.
     V8ValueConverter::Strategy::FromV8ValueCallback callback =
         base::Bind(&V8ValueConverterImpl::FromV8ValueImpl,
                    base::Unretained(this),
                    base::Unretained(state));
-    base::Value* out = NULL;
+    std::unique_ptr<base::Value> out;
     if (strategy_->FromV8Object(val, &out, isolate, callback))
       return out;
   }
 
   // Don't consider DOM objects. This check matches isHostObject() in Blink's
   // bindings/v8/V8Binding.h used in structured cloning. It reads:
   //
   // If the object has any internal fields, then we won't be able to serialize
   // or deserialize them; conveniently, this is also a quick way to detect DOM
   // wrapper objects, because the mechanism for these relies on data stored in
   // these fields.
   //
   // NOTE: check this after |strategy_| so that callers have a chance to
   // do something else, such as convert to the node's name rather than NULL.
   //
   // ANOTHER NOTE: returning an empty dictionary here to minimise surprise.
   // See also http://crbug.com/330559.
   if (val->InternalFieldCount())
-    return new base::DictionaryValue();
+    return base::MakeUnique<base::DictionaryValue>();
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   v8::Local<v8::Array> property_names(val->GetOwnPropertyNames());
 
   for (uint32_t i = 0; i < property_names->Length(); ++i) {
     v8::Local<v8::Value> key(property_names->Get(i));
 
     // Extend this test to cover more types as necessary and if sensible.
     if (!key->IsString() &&
         !key->IsNumber()) {
       NOTREACHED() << "Key \"" << *v8::String::Utf8Value(key) << "\" "
                       "is neither a string nor a number";
       continue;
     }
 
     v8::String::Utf8Value name_utf8(key);
 
     v8::TryCatch try_catch(isolate);
     v8::Local<v8::Value> child_v8 = val->Get(key);
 
     if (try_catch.HasCaught()) {
       LOG(WARNING) << "Getter for property " << *name_utf8
                    << " threw an exception.";
       child_v8 = v8::Null(isolate);
     }
 
-    std::unique_ptr<base::Value> child(
-        FromV8ValueImpl(state, child_v8, isolate));
+    std::unique_ptr<base::Value> child =
+        FromV8ValueImpl(state, child_v8, isolate);
     if (!child)
       // JSON.stringify skips properties whose values don't serialize, for
       // example undefined and functions. Emulate that behavior.
       continue;
 
     // Strip null if asked (and since undefined is turned into null, undefined
     // too). The use case for supporting this is JSON-schema support,
     // specifically for extensions, where "optional" JSON properties may be
     // represented as null, yet due to buggy legacy code elsewhere isn't
     // treated as such (potentially causing crashes). For example, the
     // "tabs.create" function takes an object as its first argument with an
     // optional "windowId" property.
     //
     // Given just
     //
     //   tabs.create({})
     //
     // this will work as expected on code that only checks for the existence of
     // a "windowId" property (such as that legacy code). However given
     //
     //   tabs.create({windowId: null})
     //
     // there *is* a "windowId" property, but since it should be an int, code
     // on the browser which doesn't additionally check for null will fail.
     // We can avoid all bugs related to this by stripping null.
     if (strip_null_from_objects_ && child->IsType(base::Value::TYPE_NULL))
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
-                                    child.release());
+                                    std::move(child));
   }
 
-  return result.release();
+  return std::move(result);
 }
 
 }  // namespace content