Remove base::BinaryValue

base/values_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 "base/values.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
@@ skipping 82 matching lines @@
 }
 
 TEST(ValuesTest, ConstructStringFromStringPiece) {
   StringPiece str = "foobar";
   Value value(str);
   EXPECT_EQ(Value::Type::STRING, value.type());
   EXPECT_EQ("foobar", value.GetString());
 }
 
 TEST(ValuesTest, ConstructBinary) {
-  BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
+  Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
   EXPECT_EQ(Value::Type::BINARY, value.type());
   EXPECT_EQ(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}), value.GetBlob());
 }
 
 TEST(ValuesTest, ConstructDict) {
   DictionaryValue value;
   EXPECT_EQ(Value::Type::DICTIONARY, value.type());
 }
 
 TEST(ValuesTest, ConstructList) {
@@ skipping 59 matching lines @@
   EXPECT_EQ(value.GetString(), copied_value.GetString());
 
   Value blank;
 
   blank = value;
   EXPECT_EQ(value.type(), blank.type());
   EXPECT_EQ(value.GetString(), blank.GetString());
 }
 
 TEST(ValuesTest, CopyBinary) {
-  BinaryValue value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
-  BinaryValue copied_value(value);
+  Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
+  Value copied_value(value);
   EXPECT_EQ(value.type(), copied_value.type());
   EXPECT_EQ(value.GetBlob(), copied_value.GetBlob());
 
   Value blank;
 
   blank = value;
   EXPECT_EQ(value.type(), blank.type());
   EXPECT_EQ(value.GetBlob(), blank.GetBlob());
 }
 
@@ skipping 98 matching lines @@
 
   Value blank;
 
   blank = Value("foobar");
   EXPECT_EQ(Value::Type::STRING, blank.type());
   EXPECT_EQ("foobar", blank.GetString());
 }
 
 TEST(ValuesTest, MoveBinary) {
   const std::vector<char> buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
-  BinaryValue value(buffer);
-  BinaryValue moved_value(std::move(value));
+  Value value(buffer);
+  Value moved_value(std::move(value));
   EXPECT_EQ(Value::Type::BINARY, moved_value.type());
   EXPECT_EQ(buffer, moved_value.GetBlob());
 
   Value blank;
 
-  blank = BinaryValue(buffer);
+  blank = Value(buffer);
   EXPECT_EQ(Value::Type::BINARY, blank.type());
   EXPECT_EQ(buffer, blank.GetBlob());
 }
 
 TEST(ValuesTest, MoveDictionary) {
   // TODO(crbug.com/646113): Clean this up once DictionaryValue switched to
   // value semantics.
   int move;
   DictionaryValue value;
   value.SetInteger("Int", 123);
@@ skipping 123 matching lines @@
 
 TEST(ValuesTest, BinaryValue) {
   // Default constructor creates a BinaryValue with a buffer of size 0.
   auto binary = MakeUnique<Value>(Value::Type::BINARY);
   ASSERT_TRUE(binary.get());
   ASSERT_EQ(0U, binary->GetSize());
 
   // Test the common case of a non-empty buffer
   std::vector<char> buffer(15);
   char* original_buffer = buffer.data();
-  binary.reset(new BinaryValue(std::move(buffer)));
+  binary.reset(new Value(std::move(buffer)));
   ASSERT_TRUE(binary.get());
   ASSERT_TRUE(binary->GetBuffer());
   ASSERT_EQ(original_buffer, binary->GetBuffer());
   ASSERT_EQ(15U, binary->GetSize());
 
   char stack_buffer[42];
   memset(stack_buffer, '!', 42);
-  binary = BinaryValue::CreateWithCopiedBuffer(stack_buffer, 42);
+  binary = Value::CreateWithCopiedBuffer(stack_buffer, 42);
   ASSERT_TRUE(binary.get());
   ASSERT_TRUE(binary->GetBuffer());
   ASSERT_NE(stack_buffer, binary->GetBuffer());
   ASSERT_EQ(42U, binary->GetSize());
   ASSERT_EQ(0, memcmp(stack_buffer, binary->GetBuffer(), binary->GetSize()));
 
   // Test overloaded GetAsBinary.
   Value* narrow_value = binary.get();
-  const BinaryValue* narrow_binary = NULL;
+  const Value* narrow_binary = NULL;
   ASSERT_TRUE(narrow_value->GetAsBinary(&narrow_binary));
   EXPECT_EQ(binary.get(), narrow_binary);
 }
 
 TEST(ValuesTest, StringValue) {
   // Test overloaded StringValue constructor.
   std::unique_ptr<Value> narrow_value(new Value("narrow"));
   ASSERT_TRUE(narrow_value.get());
   ASSERT_TRUE(narrow_value->IsType(Value::Type::STRING));
   std::unique_ptr<Value> utf16_value(new Value(ASCIIToUTF16("utf16")));
@@ skipping 185 matching lines @@
   Value* original_double = scoped_double.get();
   original_dict.Set("double", std::move(scoped_double));
   std::unique_ptr<Value> scoped_string(new Value("hello"));
   Value* original_string = scoped_string.get();
   original_dict.Set("string", std::move(scoped_string));
   std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16")));
   Value* original_string16 = scoped_string16.get();
   original_dict.Set("string16", std::move(scoped_string16));
 
   std::vector<char> original_buffer(42, '!');
-  std::unique_ptr<BinaryValue> scoped_binary(
-      new BinaryValue(std::move(original_buffer)));
-  BinaryValue* original_binary = scoped_binary.get();
+  std::unique_ptr<Value> scoped_binary(new Value(std::move(original_buffer)));
+  Value* original_binary = scoped_binary.get();
   original_dict.Set("binary", std::move(scoped_binary));
 
   std::unique_ptr<ListValue> scoped_list(new ListValue());
   Value* original_list = scoped_list.get();
   std::unique_ptr<Value> scoped_list_element_0(new Value(0));
   Value* original_list_element_0 = scoped_list_element_0.get();
   scoped_list->Append(std::move(scoped_list_element_0));
   std::unique_ptr<Value> scoped_list_element_1(new Value(1));
   Value* original_list_element_1 = scoped_list_element_1.get();
   scoped_list->Append(std::move(scoped_list_element_1));
@@ skipping 311 matching lines @@
   Value* original_double = scoped_double.get();
   original_dict.Set("double", std::move(scoped_double));
   std::unique_ptr<Value> scoped_string(new Value("hello"));
   Value* original_string = scoped_string.get();
   original_dict.Set("string", std::move(scoped_string));
   std::unique_ptr<Value> scoped_string16(new Value(ASCIIToUTF16("hello16")));
   Value* original_string16 = scoped_string16.get();
   original_dict.Set("string16", std::move(scoped_string16));
 
   std::vector<char> original_buffer(42, '!');
-  std::unique_ptr<BinaryValue> scoped_binary(
-      new BinaryValue(std::move(original_buffer)));
+  std::unique_ptr<Value> scoped_binary(new Value(std::move(original_buffer)));
   Value* original_binary = scoped_binary.get();
   original_dict.Set("binary", std::move(scoped_binary));
 
   std::unique_ptr<ListValue> scoped_list(new ListValue());
   Value* original_list = scoped_list.get();
   std::unique_ptr<Value> scoped_list_element_0(new Value(0));
   scoped_list->Append(std::move(scoped_list_element_0));
   std::unique_ptr<Value> scoped_list_element_1(new Value(1));
   scoped_list->Append(std::move(scoped_list_element_1));
   original_dict.Set("list", std::move(scoped_list));
@@ skipping 214 matching lines @@
 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
 // and still return true/false based on success.
 TEST(ValuesTest, GetWithNullOutValue) {
   DictionaryValue main_dict;
   ListValue main_list;
 
   Value bool_value(false);
   Value int_value(1234);
   Value double_value(12.34567);
   Value string_value("foo");
-  BinaryValue binary_value(Value::Type::BINARY);
+  Value binary_value(Value::Type::BINARY);
   DictionaryValue dict_value;
   ListValue list_value;
 
   main_dict.Set("bool", MakeUnique<Value>(bool_value));
   main_dict.Set("int", MakeUnique<Value>(int_value));
   main_dict.Set("double", MakeUnique<Value>(double_value));
   main_dict.Set("string", MakeUnique<Value>(string_value));
   main_dict.Set("binary", MakeUnique<Value>(binary_value));
   main_dict.Set("dict", MakeUnique<Value>(dict_value));
   main_dict.Set("list", MakeUnique<Value>(list_value));
@@ skipping 261 matching lines @@
   EXPECT_FALSE(main_list.GetList(7, NULL));
 }
 
 TEST(ValuesTest, SelfSwap) {
   base::Value test(1);
   std::swap(test, test);
   EXPECT_TRUE(test.GetInt() == 1);
 }
 
 }  // namespace base