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

content/child/v8_value_converter_impl_unittest.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 "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
 // To improve the performance of
 // V8ValueConverterImpl::UpdateAndCheckUniqueness, identity hashes of objects
@@ skipping 149 matching lines @@
       ASSERT_TRUE(raw.get());
       EXPECT_TRUE(expected_value->Equals(raw.get()));
       EXPECT_EQ(expected_type, raw->GetType());
     } else {
       EXPECT_FALSE(raw.get());
     }
 
     v8::Local<v8::Object> object(v8::Object::New(isolate_));
     object->Set(v8::String::NewFromUtf8(isolate_, "test"), val);
     std::unique_ptr<base::DictionaryValue> dictionary(
-        static_cast<base::DictionaryValue*>(
-            converter.FromV8Value(object, context)));
+        base::DictionaryValue::From(converter.FromV8Value(object, context)));
     ASSERT_TRUE(dictionary.get());
 
     if (expected_value) {
       base::Value* temp = NULL;
       ASSERT_TRUE(dictionary->Get("test", &temp));
       EXPECT_EQ(expected_type, temp->GetType());
       EXPECT_TRUE(expected_value->Equals(temp));
     } else {
       EXPECT_FALSE(dictionary->HasKey("test"));
     }
 
     v8::Local<v8::Array> array(v8::Array::New(isolate_));
     array->Set(0, val);
     std::unique_ptr<base::ListValue> list(
-        static_cast<base::ListValue*>(converter.FromV8Value(array, context)));
+        base::ListValue::From(converter.FromV8Value(array, context)));
     ASSERT_TRUE(list.get());
     if (expected_value) {
       base::Value* temp = NULL;
       ASSERT_TRUE(list->Get(0, &temp));
       EXPECT_EQ(expected_type, temp->GetType());
       EXPECT_TRUE(expected_value->Equals(temp));
     } else {
       // Arrays should preserve their length, and convert unconvertible
       // types into null.
       base::Value* temp = NULL;
@@ skipping 112 matching lines @@
       v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
   script->Run();
 
   v8::Local<v8::Object> object(v8::Object::New(isolate_));
   object->Set(v8::String::NewFromUtf8(isolate_, "bar"),
               v8::String::NewFromUtf8(isolate_, "bar"));
 
   // Converting from v8 value should replace the foo property with null.
   V8ValueConverterImpl converter;
   std::unique_ptr<base::DictionaryValue> converted(
-      static_cast<base::DictionaryValue*>(
-          converter.FromV8Value(object, context)));
+      base::DictionaryValue::From(converter.FromV8Value(object, context)));
   EXPECT_TRUE(converted.get());
   // http://code.google.com/p/v8/issues/detail?id=1342
   // EXPECT_EQ(2u, converted->size());
   // EXPECT_TRUE(IsNull(converted.get(), "foo"));
   EXPECT_EQ(1u, converted->size());
   EXPECT_EQ("bar", GetString(converted.get(), "bar"));
 
   // Converting to v8 value should not trigger the setter.
   converted->SetString("foo", "foo");
   v8::Local<v8::Object> copy =
@@ skipping 23 matching lines @@
       "})();";
 
   v8::Local<v8::Script> script(
       v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
   v8::Local<v8::Array> array = script->Run().As<v8::Array>();
   ASSERT_FALSE(array.IsEmpty());
 
   // Converting from v8 value should replace the first item with null.
   V8ValueConverterImpl converter;
   std::unique_ptr<base::ListValue> converted(
-      static_cast<base::ListValue*>(converter.FromV8Value(array, context)));
+      base::ListValue::From(converter.FromV8Value(array, context)));
   ASSERT_TRUE(converted.get());
   // http://code.google.com/p/v8/issues/detail?id=1342
   EXPECT_EQ(2u, converted->GetSize());
   EXPECT_TRUE(IsNull(converted.get(), 0));
 
   // Converting to v8 value should not be affected by the getter/setter
   // because the setters/getters are defined on the array instance, not
   // on the Array's prototype.
   converted.reset(static_cast<base::ListValue*>(
       base::test::ParseJson("[ \"foo\", \"bar\" ]").release()));
@@ skipping 47 matching lines @@
       "return {};"
       "})();";
 
   v8::Local<v8::Script> script(
       v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
   v8::Local<v8::Object> object = script->Run().As<v8::Object>();
   ASSERT_FALSE(object.IsEmpty());
 
   V8ValueConverterImpl converter;
   std::unique_ptr<base::DictionaryValue> result(
-      static_cast<base::DictionaryValue*>(
-          converter.FromV8Value(object, context)));
+      base::DictionaryValue::From(converter.FromV8Value(object, context)));
   ASSERT_TRUE(result.get());
   EXPECT_EQ(0u, result->size());
 }
 
 TEST_F(V8ValueConverterImplTest, ObjectPrototypeSetter) {
   std::unique_ptr<base::Value> original =
       base::test::ParseJson("{ \"foo\": \"good value\" }");
 
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
@@ skipping 145 matching lines @@
 
   v8::Local<v8::Script> script(
       v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
   v8::Local<v8::Object> object = script->Run().As<v8::Object>();
   ASSERT_FALSE(object.IsEmpty());
 
   V8ValueConverterImpl converter;
   converter.SetStripNullFromObjects(true);
 
   std::unique_ptr<base::DictionaryValue> result(
-      static_cast<base::DictionaryValue*>(
-          converter.FromV8Value(object, context)));
+      base::DictionaryValue::From(converter.FromV8Value(object, context)));
   ASSERT_TRUE(result.get());
   EXPECT_EQ(0u, result->size());
 }
 
 TEST_F(V8ValueConverterImplTest, RecursiveObjects) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
 
   V8ValueConverterImpl converter;
 
   v8::Local<v8::Object> object = v8::Object::New(isolate_).As<v8::Object>();
   ASSERT_FALSE(object.IsEmpty());
   object->Set(v8::String::NewFromUtf8(isolate_, "foo"),
               v8::String::NewFromUtf8(isolate_, "bar"));
   object->Set(v8::String::NewFromUtf8(isolate_, "obj"), object);
 
   std::unique_ptr<base::DictionaryValue> object_result(
-      static_cast<base::DictionaryValue*>(
-          converter.FromV8Value(object, context)));
+      base::DictionaryValue::From(converter.FromV8Value(object, context)));
   ASSERT_TRUE(object_result.get());
   EXPECT_EQ(2u, object_result->size());
   EXPECT_TRUE(IsNull(object_result.get(), "obj"));
 
   v8::Local<v8::Array> array = v8::Array::New(isolate_).As<v8::Array>();
   ASSERT_FALSE(array.IsEmpty());
   array->Set(0, v8::String::NewFromUtf8(isolate_, "1"));
   array->Set(1, array);
 
   std::unique_ptr<base::ListValue> list_result(
-      static_cast<base::ListValue*>(converter.FromV8Value(array, context)));
+      base::ListValue::From(converter.FromV8Value(array, context)));
   ASSERT_TRUE(list_result.get());
   EXPECT_EQ(2u, list_result->GetSize());
   EXPECT_TRUE(IsNull(list_result.get(), 1));
 }
 
 TEST_F(V8ValueConverterImplTest, WeirdProperties) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
@@ skipping 46 matching lines @@
       "return a;"
       "})();";
 
   v8::Local<v8::Script> script(
       v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
   v8::Local<v8::Array> array = script->Run().As<v8::Array>();
   ASSERT_FALSE(array.IsEmpty());
 
   V8ValueConverterImpl converter;
   std::unique_ptr<base::ListValue> result(
-      static_cast<base::ListValue*>(converter.FromV8Value(array, context)));
+      base::ListValue::From(converter.FromV8Value(array, context)));
   ASSERT_TRUE(result.get());
   EXPECT_EQ(2u, result->GetSize());
 }
 
 TEST_F(V8ValueConverterImplTest, UndefinedValueBehavior) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
   v8::MicrotasksScope microtasks(
@@ skipping 143 matching lines @@
         "var obj = {one: objA, two: objA};"
         "return obj;"
         "})();";
     v8::Local<v8::Script> script(
         v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
     v8::Local<v8::Object> object = script->Run().As<v8::Object>();
     ASSERT_FALSE(object.IsEmpty());
 
     // The actual result.
     std::unique_ptr<base::DictionaryValue> result(
-        static_cast<base::DictionaryValue*>(
-            converter.FromV8Value(object, context)));
+        base::DictionaryValue::From(converter.FromV8Value(object, context)));
     ASSERT_TRUE(result.get());
     EXPECT_EQ(2u, result->size());
 
     {
       base::DictionaryValue* one_dict = nullptr;
       const char* key1 = "one";
       ASSERT_TRUE(result->GetDictionary(key1, &one_dict));
       EXPECT_EQ("another same value", GetString(one_dict, "key"));
     }
     {
@@ skipping 11 matching lines @@
         "var arr = [objA, objA];"
         "return arr;"
         "})();";
     v8::Local<v8::Script> script(
         v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
     v8::Local<v8::Array> array = script->Run().As<v8::Array>();
     ASSERT_FALSE(array.IsEmpty());
 
     // The actual result.
     std::unique_ptr<base::ListValue> list_result(
-        static_cast<base::ListValue*>(converter.FromV8Value(array, context)));
+        base::ListValue::From(converter.FromV8Value(array, context)));
     ASSERT_TRUE(list_result.get());
     ASSERT_EQ(2u, list_result->GetSize());
     for (size_t i = 0; i < list_result->GetSize(); ++i) {
       ASSERT_FALSE(IsNull(list_result.get(), i));
       base::DictionaryValue* dict_value = nullptr;
       ASSERT_TRUE(list_result->GetDictionary(0u, &dict_value));
       EXPECT_EQ("same value", GetString(dict_value, "key"));
     }
   }
 }
@@ skipping 36 matching lines @@
   base::DictionaryValue empty;
   EXPECT_TRUE(base::Value::Equals(&empty, current)) << *current;
 }
 
 class V8ValueConverterOverridingStrategyForTesting
     : public V8ValueConverter::Strategy {
  public:
   V8ValueConverterOverridingStrategyForTesting()
       : reference_value_(NewReferenceValue()) {}
   bool FromV8Object(v8::Local<v8::Object> value,
-                    base::Value** out,
+                    std::unique_ptr<base::Value>* out,
                     v8::Isolate* isolate,
                     const FromV8ValueCallback& callback) const override {
     *out = NewReferenceValue();
     return true;
   }
   bool FromV8Array(v8::Local<v8::Array> value,
-                   base::Value** out,
+                   std::unique_ptr<base::Value>* out,
                    v8::Isolate* isolate,
                    const FromV8ValueCallback& callback) const override {
     *out = NewReferenceValue();
     return true;
   }
   bool FromV8ArrayBuffer(v8::Local<v8::Object> value,
-                         base::Value** out,
+                         std::unique_ptr<base::Value>* out,
                          v8::Isolate* isolate) const override {
     *out = NewReferenceValue();
     return true;
   }
   bool FromV8Number(v8::Local<v8::Number> value,
-                    base::Value** out) const override {
+                    std::unique_ptr<base::Value>* out) const override {
     *out = NewReferenceValue();
     return true;
   }
-  bool FromV8Undefined(base::Value** out) const override {
+  bool FromV8Undefined(std::unique_ptr<base::Value>* out) const override {
     *out = NewReferenceValue();
     return true;
   }
   base::Value* reference_value() const { return reference_value_.get(); }
 
  private:
-  static base::Value* NewReferenceValue() {
-    return new base::StringValue("strategy");
+  static std::unique_ptr<base::Value> NewReferenceValue() {
+    return base::MakeUnique<base::StringValue>("strategy");
   }
   std::unique_ptr<base::Value> reference_value_;
 };
 
 TEST_F(V8ValueConverterImplTest, StrategyOverrides) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
 
@@ skipping 42 matching lines @@
       converter.FromV8Value(undefined, context));
   ASSERT_TRUE(undefined_value);
   EXPECT_TRUE(
       base::Value::Equals(strategy.reference_value(), undefined_value.get()));
 }
 
 class V8ValueConverterBypassStrategyForTesting
     : public V8ValueConverter::Strategy {
  public:
   bool FromV8Object(v8::Local<v8::Object> value,
-                    base::Value** out,
+                    std::unique_ptr<base::Value>* out,
                     v8::Isolate* isolate,
                     const FromV8ValueCallback& callback) const override {
     return false;
   }
   bool FromV8Array(v8::Local<v8::Array> value,
-                   base::Value** out,
+                   std::unique_ptr<base::Value>* out,
                    v8::Isolate* isolate,
                    const FromV8ValueCallback& callback) const override {
     return false;
   }
   bool FromV8ArrayBuffer(v8::Local<v8::Object> value,
-                         base::Value** out,
+                         std::unique_ptr<base::Value>* out,
                          v8::Isolate* isolate) const override {
     return false;
   }
   bool FromV8Number(v8::Local<v8::Number> value,
-                    base::Value** out) const override {
+                    std::unique_ptr<base::Value>* out) const override {
     return false;
   }
-  bool FromV8Undefined(base::Value** out) const override { return false; }
+  bool FromV8Undefined(std::unique_ptr<base::Value>* out) const override {
+    return false;
+  }
 };
 
 // Verify that having a strategy that fallbacks to default behaviour
 // actually preserves it.
 TEST_F(V8ValueConverterImplTest, StrategyBypass) {
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
       v8::Local<v8::Context>::New(isolate_, context_);
   v8::Context::Scope context_scope(context);
 
@@ skipping 31 matching lines @@
   EXPECT_TRUE(
       base::Value::Equals(reference_number_value.get(), number_value.get()));
 
   v8::Local<v8::Primitive> undefined(v8::Undefined(isolate_));
   std::unique_ptr<base::Value> undefined_value(
       converter.FromV8Value(undefined, context));
   EXPECT_FALSE(undefined_value);
 }
 
 }  // namespace content