Remove raw DictionaryValue::Set in //components

components/policy/core/common/schema_unittest.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 "components/policy/core/common/schema.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/values.h"
 #include "components/policy/core/common/schema_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
 #define TestSchemaValidation(a, b, c, d) \
     TestSchemaValidationHelper(          \
         base::StringPrintf("%s:%i", __FILE__, __LINE__), a, b, c, d)
@@ skipping 587 matching lines @@
 
   // Wrong type, expected integer.
   bundle.SetBoolean("Integer", true);
   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 
   // Wrong type, expected list of strings.
   {
     bundle.Clear();
     base::ListValue list;
     list.AppendInteger(1);
-    bundle.Set("Array", list.DeepCopy());
+    bundle.Set("Array", base::MakeUnique<base::Value>(list));
     TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
   }
 
   // Wrong type in a sub-object.
   {
     bundle.Clear();
     base::DictionaryValue dict;
     dict.SetString("one", "one");
-    bundle.Set("Object", dict.DeepCopy());
+    bundle.Set("Object", base::MakeUnique<base::Value>(dict));
     TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
   }
 
   // Unknown name.
   bundle.Clear();
   bundle.SetBoolean("Unknown", true);
   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 
   // All of these will be valid.
   bundle.Clear();
   bundle.SetBoolean("Boolean", true);
   bundle.SetInteger("Integer", 123);
   bundle.Set("Null", base::MakeUnique<base::Value>());
-  bundle.Set("Number", new base::Value(3.14));
+  bundle.SetDouble("Number", 3.14);
   bundle.SetString("String", "omg");
 
   {
     base::ListValue list;
     list.AppendString("a string");
     list.AppendString("another string");
-    bundle.Set("Array", list.DeepCopy());
+    bundle.Set("Array", base::MakeUnique<base::Value>(list));
   }
 
   {
     base::DictionaryValue dict;
     dict.SetString("one", "string");
     dict.SetInteger("two", 2);
     base::ListValue list;
-    list.Append(dict.CreateDeepCopy());
-    list.Append(dict.CreateDeepCopy());
-    bundle.Set("ArrayOfObjects", list.DeepCopy());
+    list.GetList().push_back(dict);
+    list.GetList().push_back(dict);
+    bundle.Set("ArrayOfObjects", base::MakeUnique<base::Value>(list));
   }
 
   {
     base::ListValue list;
     list.AppendString("a string");
     list.AppendString("another string");
     base::ListValue listlist;
-    listlist.Append(list.CreateDeepCopy());
-    listlist.Append(list.CreateDeepCopy());
-    bundle.Set("ArrayOfArray", listlist.DeepCopy());
+    listlist.GetList().push_back(list);
+    listlist.GetList().push_back(list);
+    bundle.Set("ArrayOfArray", base::MakeUnique<base::Value>(listlist));
   }
 
   {
     base::DictionaryValue dict;
     dict.SetBoolean("one", true);
     dict.SetInteger("two", 2);
     dict.SetString("additionally", "a string");
     dict.SetString("and also", "another string");
-    bundle.Set("Object", dict.DeepCopy());
+    bundle.Set("Object", base::MakeUnique<base::Value>(dict));
   }
 
   bundle.SetInteger("IntegerWithEnums", 1);
   bundle.SetInteger("IntegerWithEnumsGaps", 20);
   bundle.SetString("StringWithEnums", "two");
   bundle.SetInteger("IntegerWithRange", 3);
 
   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, true);
 
   bundle.SetInteger("IntegerWithEnums", 0);
@@ skipping 104 matching lines @@
     TestSchemaValidationWithPath(subschema, root, "items[0].two");
     root.Remove(root.GetSize() - 1, NULL);
   }
 
   // Tests on ObjectOfArray.
   {
     Schema subschema = schema.GetProperty("ObjectOfArray");
     ASSERT_TRUE(subschema.valid());
     base::DictionaryValue root;
 
-    base::ListValue* list_value = new base::ListValue();
-    root.Set("List", list_value);  // Pass ownership to root.
+    base::ListValue* list_value =
+        root.SetList("List", base::MakeUnique<base::ListValue>());
 
     // Test that there are not errors here.
     list_value->AppendInteger(12345);
     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 
     // Invalid list item.
     list_value->AppendString("blabla");
     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, false);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
     TestSchemaValidationWithPath(subschema, root, "List.items[1]");
   }
 
   // Tests on ArrayOfObjectOfArray.
   {
     Schema subschema = schema.GetProperty("ArrayOfObjectOfArray");
     ASSERT_TRUE(subschema.valid());
     base::ListValue root;
 
-    base::ListValue* list_value = new base::ListValue();
-    std::unique_ptr<base::DictionaryValue> dict_value(
-        new base::DictionaryValue());
-    dict_value->Set("List", list_value);  // Pass ownership to dict_value.
+    auto dict_value = base::MakeUnique<base::DictionaryValue>();
+    base::ListValue* list_value =
+        dict_value->SetList("List", base::MakeUnique<base::ListValue>());
     root.Append(std::move(dict_value));
 
     // Test that there are not errors here.
     list_value->AppendString("blabla");
     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 
@@ skipping 328 matching lines @@
 
   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
       "{"
       "  \"type\": \"integer\","
       "  \"minimum\": 10,"
       "  \"maximum\": 20"
       "}")));
 }
 
 }  // namespace policy