Inline base::BinaryValue into base::Value

tools/json_schema_compiler/test/error_generation_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 "tools/json_schema_compiler/test/error_generation.h"
 
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/json_schema_compiler/test/test_util.h"
 
 using namespace test::api::error_generation;
 using base::FundamentalValue;
 using json_schema_compiler::test_util::Dictionary;
 using json_schema_compiler::test_util::List;
 
 template <typename T>
@@ skipping 14 matching lines @@
 
 // GenerateTypePopulate errors
 
 TEST(JsonSchemaCompilerErrorTest, RequiredPropertyPopulate) {
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("string", new base::StringValue("bling"));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
-    std::unique_ptr<base::BinaryValue> value(new base::BinaryValue());
+    auto value = base::MakeUnique<base::Value>(base::Value::Type::BINARY);
     EXPECT_TRUE(EqualsUtf16("expected dictionary, got binary",
         GetPopulateError<TestType>(*value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, UnexpectedTypePopulation) {
   {
     std::unique_ptr<base::ListValue> value(new base::ListValue());
     EXPECT_TRUE(EqualsUtf16("",
         GetPopulateError<ChoiceType::Integers>(*value)));
   }
   {
-    std::unique_ptr<base::BinaryValue> value(new base::BinaryValue());
+    auto value = base::MakeUnique<base::Value>(base::Value::Type::BINARY);
     EXPECT_TRUE(EqualsUtf16("expected integers or integer, got binary",
         GetPopulateError<ChoiceType::Integers>(*value)));
   }
 }
 
 // GenerateTypePopulateProperty errors
 
 TEST(JsonSchemaCompilerErrorTest, TypeIsRequired) {
   {
     std::unique_ptr<base::DictionaryValue> value =
@@ skipping 105 matching lines @@
         List(new FundamentalValue(5), new FundamentalValue(false));
     EXPECT_TRUE(EqualsUtf16(
         "expected integer, got boolean; unable to populate array 'integers'",
         GetPopulateError<ChoiceType::Integers>(*params_value)));
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, BinaryTypeExpected) {
   {
     std::unique_ptr<base::DictionaryValue> value =
-        Dictionary("data", new base::BinaryValue());
+        Dictionary("data", new base::Value(base::Value::Type::BINARY));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<BinaryData>(*value)));
   }
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("data", new FundamentalValue(1.1));
     EXPECT_TRUE(EqualsUtf16("'data': expected binary, got double",
         GetPopulateError<BinaryData>(*value)));
   }
 }
 
@@ skipping 45 matching lines @@
     EXPECT_TRUE(OptionalTestType::Populate(*value, &out, &error));
     EXPECT_TRUE(EqualsUtf16("'string': expected string, got integer",
         error));
     EXPECT_EQ(NULL, out.string.get());
   }
 }
 
 TEST(JsonSchemaCompilerErrorTest, OptionalBinaryTypeFailure) {
   {
     std::unique_ptr<base::DictionaryValue> value =
-        Dictionary("data", new base::BinaryValue());
+        Dictionary("data", new base::Value(base::Value::Type::BINARY));
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<OptionalBinaryData>(*value)));
   }
   {
     // There's a bug with silent failures if the key doesn't exist.
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("data", new base::FundamentalValue(1));
 
     OptionalBinaryData out;
     base::string16 error;
     EXPECT_TRUE(OptionalBinaryData::Populate(*value, &out, &error));
@@ skipping 68 matching lines @@
     EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
   }
   {
     std::unique_ptr<base::DictionaryValue> value =
         Dictionary("string", new base::StringValue("yes"), "ohno",
                    new base::StringValue("many values"));
     EXPECT_TRUE(EqualsUtf16("found unexpected key 'ohno'",
         GetPopulateError<TestType>(*value)));
   }
 }