Introduce base::Value::BlobStorage typedef

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 10 matching lines @@
 namespace base {
 
 TEST(ValuesTest, TestNothrow) {
   static_assert(std::is_nothrow_move_constructible<Value>::value,
                 "IsNothrowMoveConstructible");
   static_assert(std::is_nothrow_default_constructible<Value>::value,
                 "IsNothrowDefaultConstructible");
   static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
                 "IsNothrowMoveConstructibleFromString");
   static_assert(
-      std::is_nothrow_constructible<Value, std::vector<char>&&>::value,
+      std::is_nothrow_constructible<Value, Value::BlobStorage&&>::value,
       "IsNothrowMoveConstructibleFromBlob");
   static_assert(std::is_nothrow_move_assignable<Value>::value,
                 "IsNothrowMoveAssignable");
 }
 
 // Group of tests for the value constructors.
 TEST(ValuesTest, ConstructBool) {
   Value true_value(true);
   EXPECT_EQ(Value::Type::BOOLEAN, true_value.type());
   EXPECT_TRUE(true_value.GetBool());
@@ skipping 51 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) {
-  Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
+  Value value(Value::BlobStorage({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());
+  EXPECT_EQ(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}),
+            value.GetBlob());
 }
 
 TEST(ValuesTest, ConstructDict) {
   DictionaryValue value;
   EXPECT_EQ(Value::Type::DICTIONARY, value.type());
 }
 
 TEST(ValuesTest, ConstructList) {
   ListValue value;
   EXPECT_EQ(Value::Type::LIST, value.type());
@@ skipping 57 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) {
-  Value value(std::vector<char>({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
+  Value value(Value::BlobStorage({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 @@
   EXPECT_EQ("foobar", moved_value.GetString());
 
   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};
+  const Value::BlobStorage buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
   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 = Value(buffer);
   EXPECT_EQ(Value::Type::BINARY, blank.type());
   EXPECT_EQ(buffer, blank.GetBlob());
@@ skipping 129 matching lines @@
   ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
 }
 
 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);
+  Value::BlobStorage buffer(15);
   char* original_buffer = buffer.data();
   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 = Value::CreateWithCopiedBuffer(stack_buffer, 42);
@@ skipping 203 matching lines @@
   std::unique_ptr<Value> scoped_double(new Value(3.14));
   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, '!');
+  Value::BlobStorage original_buffer(42, '!');
   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));
@@ skipping 223 matching lines @@
   Value string1("1");
   Value string2("2");
   EXPECT_FALSE(string1 == string2);
   EXPECT_NE(string1, string2);
   EXPECT_LT(string1, string2);
   EXPECT_FALSE(string1 > string2);
   EXPECT_LE(string1, string2);
   EXPECT_FALSE(string1 >= string2);
 
   // Test Binary Values.
-  Value binary1(std::vector<char>{0x01});
-  Value binary2(std::vector<char>{0x02});
+  Value binary1(Value::BlobStorage{0x01});
+  Value binary2(Value::BlobStorage{0x02});
   EXPECT_FALSE(binary1 == binary2);
   EXPECT_NE(binary1, binary2);
   EXPECT_LT(binary1, binary2);
   EXPECT_FALSE(binary1 > binary2);
   EXPECT_LE(binary1, binary2);
   EXPECT_FALSE(binary1 >= binary2);
 
   // Test Empty List Values.
   ListValue null_list1;
   ListValue null_list2;
@@ skipping 67 matching lines @@
   std::unique_ptr<Value> scoped_double(new Value(3.14));
   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, '!');
+  Value::BlobStorage original_buffer(42, '!');
   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));
@@ skipping 497 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