Convert //tools to use std::unique_ptr

tools/json_schema_compiler/test/crossref_unittest.cc

Index: tools/json_schema_compiler/test/crossref_unittest.cc
diff --git a/tools/json_schema_compiler/test/crossref_unittest.cc b/tools/json_schema_compiler/test/crossref_unittest.cc
index cc2067513878dea5575388b9a9d46f11e9788030..706fddb2308ba80cee63a048552e8a022ebeb3c8 100644
--- a/tools/json_schema_compiler/test/crossref_unittest.cc
+++ b/tools/json_schema_compiler/test/crossref_unittest.cc
@@ -2,22 +2,25 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "tools/json_schema_compiler/test/simple_api.h"
 #include "tools/json_schema_compiler/test/crossref.h"
 
+#include <memory>
+
+#include "base/memory/ptr_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "tools/json_schema_compiler/test/simple_api.h"
 
 using namespace test::api;
 
 namespace {
 
-scoped_ptr<base::DictionaryValue> CreateTestTypeValue() {
+std::unique_ptr<base::DictionaryValue> CreateTestTypeValue() {
   base::DictionaryValue* value(new base::DictionaryValue());

[Devlin, 2016/04/07 04:15:59]

here too

[dcheng, 2016/04/07 04:24:03]

Done.

   value->Set("number", new base::FundamentalValue(1.1));
   value->Set("integer", new base::FundamentalValue(4));
   value->Set("string", new base::StringValue("bling"));
   value->Set("boolean", new base::FundamentalValue(true));
-  return scoped_ptr<base::DictionaryValue>(value);
+  return base::WrapUnique(value);
 }
 
 }  // namespace
@@ -40,15 +43,16 @@ TEST(JsonSchemaCompilerCrossrefTest, CrossrefTypePopulateAndToValue) {
   EXPECT_EQ(simple_api::TEST_ENUM_NONE, crossref_type.test_enum_optional_extra);
 
   // Test ToValue of the compiled type --> value.
-  scoped_ptr<base::DictionaryValue> crossref_value = crossref_type.ToValue();
+  std::unique_ptr<base::DictionaryValue> crossref_value =
+      crossref_type.ToValue();
   ASSERT_TRUE(crossref_value);
   EXPECT_TRUE(crossref_orig.Equals(crossref_value.get()));
 }
 
 TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
+  std::unique_ptr<base::ListValue> params_value(new base::ListValue());
   params_value->Append(CreateTestTypeValue().release());
-  scoped_ptr<crossref::TestTypeOptionalParam::Params> params(
+  std::unique_ptr<crossref::TestTypeOptionalParam::Params> params(
       crossref::TestTypeOptionalParam::Params::Create(*params_value));
   EXPECT_TRUE(params.get());
   EXPECT_TRUE(params->test_type.get());
@@ -57,21 +61,22 @@ TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamCreate) {
 }
 
 TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamFail) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  scoped_ptr<base::DictionaryValue> test_type_value = CreateTestTypeValue();
+  std::unique_ptr<base::ListValue> params_value(new base::ListValue());
+  std::unique_ptr<base::DictionaryValue> test_type_value =
+      CreateTestTypeValue();
   test_type_value->RemoveWithoutPathExpansion("number", NULL);
   params_value->Append(test_type_value.release());
-  scoped_ptr<crossref::TestTypeOptionalParam::Params> params(
+  std::unique_ptr<crossref::TestTypeOptionalParam::Params> params(
       crossref::TestTypeOptionalParam::Params::Create(*params_value));
   EXPECT_FALSE(params.get());
 }
 
 TEST(JsonSchemaCompilerCrossrefTest, GetTestType) {
-  scoped_ptr<base::DictionaryValue> value = CreateTestTypeValue();
-  scoped_ptr<simple_api::TestType> test_type(new simple_api::TestType());
+  std::unique_ptr<base::DictionaryValue> value = CreateTestTypeValue();
+  std::unique_ptr<simple_api::TestType> test_type(new simple_api::TestType());
   EXPECT_TRUE(simple_api::TestType::Populate(*value, test_type.get()));
 
-  scoped_ptr<base::ListValue> results =
+  std::unique_ptr<base::ListValue> results =
       crossref::GetTestType::Results::Create(*test_type);
   base::DictionaryValue* result_dict = NULL;
   results->GetDictionary(0, &result_dict);
@@ -80,13 +85,13 @@ TEST(JsonSchemaCompilerCrossrefTest, GetTestType) {
 
 TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) {
   {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
+    std::unique_ptr<base::ListValue> params_value(new base::ListValue());
+    std::unique_ptr<base::DictionaryValue> param_object_value(
         new base::DictionaryValue());
     param_object_value->Set("testType", CreateTestTypeValue().release());
     param_object_value->Set("boolean", new base::FundamentalValue(true));
     params_value->Append(param_object_value.release());
-    scoped_ptr<crossref::TestTypeInObject::Params> params(
+    std::unique_ptr<crossref::TestTypeInObject::Params> params(
         crossref::TestTypeInObject::Params::Create(*params_value));
     EXPECT_TRUE(params.get());
     EXPECT_TRUE(params->param_object.test_type.get());
@@ -95,35 +100,35 @@ TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) {
         params->param_object.test_type->ToValue().get()));
   }
   {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
+    std::unique_ptr<base::ListValue> params_value(new base::ListValue());
+    std::unique_ptr<base::DictionaryValue> param_object_value(
         new base::DictionaryValue());
     param_object_value->Set("boolean", new base::FundamentalValue(true));
     params_value->Append(param_object_value.release());
-    scoped_ptr<crossref::TestTypeInObject::Params> params(
+    std::unique_ptr<crossref::TestTypeInObject::Params> params(
         crossref::TestTypeInObject::Params::Create(*params_value));
     EXPECT_TRUE(params.get());
     EXPECT_FALSE(params->param_object.test_type.get());
     EXPECT_TRUE(params->param_object.boolean);
   }
   {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
+    std::unique_ptr<base::ListValue> params_value(new base::ListValue());
+    std::unique_ptr<base::DictionaryValue> param_object_value(
         new base::DictionaryValue());
     param_object_value->Set("testType", new base::StringValue("invalid"));
     param_object_value->Set("boolean", new base::FundamentalValue(true));
     params_value->Append(param_object_value.release());
-    scoped_ptr<crossref::TestTypeInObject::Params> params(
+    std::unique_ptr<crossref::TestTypeInObject::Params> params(
         crossref::TestTypeInObject::Params::Create(*params_value));
     EXPECT_FALSE(params.get());
   }
   {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
+    std::unique_ptr<base::ListValue> params_value(new base::ListValue());
+    std::unique_ptr<base::DictionaryValue> param_object_value(
         new base::DictionaryValue());
     param_object_value->Set("testType", CreateTestTypeValue().release());
     params_value->Append(param_object_value.release());
-    scoped_ptr<crossref::TestTypeInObject::Params> params(
+    std::unique_ptr<crossref::TestTypeInObject::Params> params(
         crossref::TestTypeInObject::Params::Create(*params_value));
     EXPECT_FALSE(params.get());
   }