Rewrite simple uses of base::ListValue::Append() taking a raw pointer var.

tools/json_schema_compiler/test/idl_schemas_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 <memory>
 #include <utility>
 
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/json_schema_compiler/test/idl_basics.h"
 #include "tools/json_schema_compiler/test/idl_object_types.h"
 
 using test::api::idl_basics::MyType1;
 using test::api::idl_object_types::BarType;
 using test::api::idl_object_types::FooType;
@@ skipping 23 matching lines @@
 
   // Test Function2, which takes an integer parameter.
   base::ListValue list;
   list.AppendInteger(5);
   std::unique_ptr<Function2::Params> f2_params =
       Function2::Params::Create(list);
   EXPECT_EQ(5, f2_params->x);
 
   // Test Function3, which takes a MyType1 parameter.
   list.Clear();
-  base::DictionaryValue* tmp = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> tmp(new base::DictionaryValue());
   tmp->SetInteger("x", 17);
   tmp->SetString("y", "hello");
   tmp->SetString("z", "zstring");
   tmp->SetString("a", "astring");
   tmp->SetString("b", "bstring");
   tmp->SetString("c", "cstring");
-  list.Append(tmp);
+  list.Append(std::move(tmp));
   std::unique_ptr<Function3::Params> f3_params =
       Function3::Params::Create(list);
   EXPECT_EQ(17, f3_params->arg.x);
   EXPECT_EQ("hello", f3_params->arg.y);
 
   // Test functions that take a callback function as a parameter, with varying
   // callback signatures.
   std::unique_ptr<base::ListValue> f4_results = Function4::Results::Create();
   base::ListValue expected;
   EXPECT_TRUE(f4_results->Equals(&expected));
@@ skipping 35 matching lines @@
   f8_params = Function8::Params::Create(list);
   EXPECT_EQ(8, f8_params->arg1);
   EXPECT_EQ("foo", *(f8_params->arg2));
 
   // Test a function with an optional argument of custom type.
   list.Clear();
   std::unique_ptr<Function9::Params> f9_params =
       Function9::Params::Create(list);
   EXPECT_EQ(NULL, f9_params->arg.get());
   list.Clear();
-  base::DictionaryValue* tmp = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> tmp(new base::DictionaryValue());
   tmp->SetInteger("x", 17);
   tmp->SetString("y", "hello");
   tmp->SetString("z", "zstring");
   tmp->SetString("a", "astring");
   tmp->SetString("b", "bstring");
   tmp->SetString("c", "cstring");
-  list.Append(tmp);
+  list.Append(std::move(tmp));
   f9_params = Function9::Params::Create(list);
   ASSERT_TRUE(f9_params->arg.get() != NULL);
   MyType1* t1 = f9_params->arg.get();
   EXPECT_EQ(17, t1->x);
   EXPECT_EQ("hello", t1->y);
 }
 
 TEST(IdlCompiler, ArrayTypes) {
   // Tests of a function that takes an integer and an array of integers. First
   // use an empty array.
   base::ListValue list;
   list.AppendInteger(33);
   list.Append(new base::ListValue);
   std::unique_ptr<Function10::Params> f10_params =
       Function10::Params::Create(list);
   ASSERT_TRUE(f10_params != NULL);
   EXPECT_EQ(33, f10_params->x);
   EXPECT_TRUE(f10_params->y.empty());
 
   // Same function, but this time with 2 values in the array.
   list.Clear();
   list.AppendInteger(33);
-  base::ListValue* sublist = new base::ListValue;
+  std::unique_ptr<base::ListValue> sublist(new base::ListValue);
   sublist->AppendInteger(34);
   sublist->AppendInteger(35);
-  list.Append(sublist);
+  list.Append(std::move(sublist));
   f10_params = Function10::Params::Create(list);
   ASSERT_TRUE(f10_params != NULL);
   EXPECT_EQ(33, f10_params->x);
   ASSERT_EQ(2u, f10_params->y.size());
   EXPECT_EQ(34, f10_params->y[0]);
   EXPECT_EQ(35, f10_params->y[1]);
 
   // Now test a function which takes an array of a defined type.
   list.Clear();
   MyType1 a;
   MyType1 b;
   a.x = 5;
   b.x = 6;
   a.y = std::string("foo");
   b.y = std::string("bar");
-  base::ListValue* sublist2 = new base::ListValue;
+  std::unique_ptr<base::ListValue> sublist2(new base::ListValue);
   sublist2->Append(a.ToValue());
   sublist2->Append(b.ToValue());
-  list.Append(sublist2);
+  list.Append(std::move(sublist2));
   std::unique_ptr<Function11::Params> f11_params =
       Function11::Params::Create(list);
   ASSERT_TRUE(f11_params != NULL);
   ASSERT_EQ(2u, f11_params->arg.size());
   EXPECT_EQ(5, f11_params->arg[0].x);
   EXPECT_EQ("foo", f11_params->arg[0].y);
   EXPECT_EQ(6, f11_params->arg[1].x);
   EXPECT_EQ("bar", f11_params->arg[1].y);
 }
 
@@ skipping 25 matching lines @@
                                                       &icon));
   base::ListValue list;
   list.Append(std::move(icon_props));
   std::unique_ptr<ObjectFunction1::Params> params =
       ObjectFunction1::Params::Create(list);
   ASSERT_TRUE(params.get() != NULL);
   std::string tmp;
   EXPECT_TRUE(params->icon.additional_properties.GetString("hello", &tmp));
   EXPECT_EQ("world", tmp);
 }