Remove base::Value::CreateNullValue

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 565 matching lines @@
     DictionaryValue dict;
     dict.Set(key, MakeUnique<Value>());
     EXPECT_TRUE(dict.HasKey(key));
     EXPECT_TRUE(dict.Remove(key, NULL));
     EXPECT_FALSE(dict.HasKey(key));
   }
 }
 
 TEST(ValuesTest, DictionaryWithoutPathExpansion) {
   DictionaryValue dict;
-  dict.Set("this.is.expanded", Value::CreateNullValue());
-  dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
+  dict.Set("this.is.expanded", MakeUnique<Value>());
+  dict.SetWithoutPathExpansion("this.isnt.expanded", MakeUnique<Value>());
 
   EXPECT_FALSE(dict.HasKey("this.is.expanded"));
   EXPECT_TRUE(dict.HasKey("this"));
   Value* value1;
   EXPECT_TRUE(dict.Get("this", &value1));
   DictionaryValue* value2;
   ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
   EXPECT_EQ(value1, value2);
   EXPECT_EQ(1U, value2->size());
 
   EXPECT_TRUE(dict.HasKey("this.isnt.expanded"));
   Value* value3;
   EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
   Value* value4;
   ASSERT_TRUE(dict.GetWithoutPathExpansion("this.isnt.expanded", &value4));
   EXPECT_EQ(Value::Type::NONE, value4->GetType());
 }
 
 // Tests the deprecated version of SetWithoutPathExpansion.
 // TODO(estade): remove.
 TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) {
   DictionaryValue dict;
-  dict.Set("this.is.expanded", Value::CreateNullValue());
-  dict.SetWithoutPathExpansion("this.isnt.expanded", Value::CreateNullValue());
+  dict.Set("this.is.expanded", MakeUnique<Value>());
+  dict.SetWithoutPathExpansion("this.isnt.expanded", MakeUnique<Value>());
 
   EXPECT_FALSE(dict.HasKey("this.is.expanded"));
   EXPECT_TRUE(dict.HasKey("this"));
   Value* value1;
   EXPECT_TRUE(dict.Get("this", &value1));
   DictionaryValue* value2;
   ASSERT_TRUE(dict.GetDictionaryWithoutPathExpansion("this", &value2));
   EXPECT_EQ(value1, value2);
   EXPECT_EQ(1U, value2->size());
 
@@ skipping 25 matching lines @@
 
   removed_item.reset();
   EXPECT_TRUE(dict.RemovePath("a.long.key.path", &removed_item));
   ASSERT_TRUE(removed_item);
   EXPECT_TRUE(removed_item->IsType(base::Value::Type::BOOLEAN));
   EXPECT_TRUE(dict.empty());
 }
 
 TEST(ValuesTest, DeepCopy) {
   DictionaryValue original_dict;
-  std::unique_ptr<Value> scoped_null = Value::CreateNullValue();
+  auto scoped_null = MakeUnique<Value>();
   Value* original_null = scoped_null.get();
   original_dict.Set("null", std::move(scoped_null));
   std::unique_ptr<Value> scoped_bool(new Value(true));
   Value* original_bool = scoped_bool.get();
   original_dict.Set("bool", std::move(scoped_bool));
   std::unique_ptr<Value> scoped_int(new Value(42));
   Value* original_int = scoped_int.get();
   original_dict.Set("int", std::move(scoped_int));
   std::unique_ptr<Value> scoped_double(new Value(3.14));
   Value* original_double = scoped_double.get();
@@ skipping 127 matching lines @@
   ASSERT_TRUE(copy_value);
   ASSERT_NE(copy_value, original_nested_dictionary);
   ASSERT_TRUE(copy_value->IsType(Value::Type::DICTIONARY));
   DictionaryValue* copy_nested_dictionary = NULL;
   ASSERT_TRUE(copy_value->GetAsDictionary(&copy_nested_dictionary));
   ASSERT_TRUE(copy_nested_dictionary);
   EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
 }
 
 TEST(ValuesTest, Equals) {
-  std::unique_ptr<Value> null1(Value::CreateNullValue());
-  std::unique_ptr<Value> null2(Value::CreateNullValue());
+  auto null1 = MakeUnique<Value>();
+  auto null2 = MakeUnique<Value>();
   EXPECT_NE(null1.get(), null2.get());
   EXPECT_EQ(*null1, *null2);
 
   Value boolean(false);
   EXPECT_NE(*null1, boolean);
 
   DictionaryValue dv;
   dv.SetBoolean("a", false);
   dv.SetInteger("b", 2);
   dv.SetDouble("c", 2.5);
   dv.SetString("d1", "string");
   dv.SetString("d2", ASCIIToUTF16("http://google.com"));
-  dv.Set("e", Value::CreateNullValue());
+  dv.Set("e", MakeUnique<Value>());
 
   auto copy = MakeUnique<DictionaryValue>(dv);
   EXPECT_EQ(dv, *copy);
 
   std::unique_ptr<ListValue> list(new ListValue);
   ListValue* original_list = list.get();
-  list->Append(Value::CreateNullValue());
+  list->Append(MakeUnique<Value>());
   list->Append(WrapUnique(new DictionaryValue));
   auto list_copy = MakeUnique<Value>(*list);
 
   dv.Set("f", std::move(list));
   EXPECT_NE(dv, *copy);
   copy->Set("f", std::move(list_copy));
   EXPECT_EQ(dv, *copy);
 
   original_list->Append(MakeUnique<Value>(true));
   EXPECT_NE(dv, *copy);
 
   // Check if Equals detects differences in only the keys.
   copy = MakeUnique<DictionaryValue>(dv);
   EXPECT_EQ(dv, *copy);
   copy->Remove("a", NULL);
   copy->SetBoolean("aa", false);
   EXPECT_NE(dv, *copy);
 }
 
 TEST(ValuesTest, StaticEquals) {
-  std::unique_ptr<Value> null1(Value::CreateNullValue());
-  std::unique_ptr<Value> null2(Value::CreateNullValue());
+  auto null1 = MakeUnique<Value>();
+  auto null2 = MakeUnique<Value>();
   EXPECT_TRUE(Value::Equals(null1.get(), null2.get()));
   EXPECT_TRUE(Value::Equals(NULL, NULL));
 
   std::unique_ptr<Value> i42(new Value(42));
   std::unique_ptr<Value> j42(new Value(42));
   std::unique_ptr<Value> i17(new Value(17));
   EXPECT_TRUE(Value::Equals(i42.get(), i42.get()));
   EXPECT_TRUE(Value::Equals(j42.get(), i42.get()));
   EXPECT_TRUE(Value::Equals(i42.get(), j42.get()));
   EXPECT_FALSE(Value::Equals(i42.get(), i17.get()));
   EXPECT_FALSE(Value::Equals(i42.get(), NULL));
   EXPECT_FALSE(Value::Equals(NULL, i42.get()));
 
-  // NULL and Value::CreateNullValue() are intentionally different: We need
+  // NULL and MakeUnique<Value>() are intentionally different: We need
   // support for NULL as a return value for "undefined" without caring for
   // ownership of the pointer.
   EXPECT_FALSE(Value::Equals(null1.get(), NULL));
   EXPECT_FALSE(Value::Equals(NULL, null1.get()));
 }
 
 TEST(ValuesTest, Comparisons) {
   // Test None Values.
   Value null1;
   Value null2;
@@ skipping 108 matching lines @@
       EXPECT_LT(values[i], values[j]);
       EXPECT_FALSE(values[i] > values[j]);
       EXPECT_LE(values[i], values[j]);
       EXPECT_FALSE(values[i] >= values[j]);
     }
   }
 }
 
 TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
   DictionaryValue original_dict;
-  std::unique_ptr<Value> scoped_null(Value::CreateNullValue());
+  auto scoped_null = MakeUnique<Value>();
   Value* original_null = scoped_null.get();
   original_dict.Set("null", std::move(scoped_null));
   std::unique_ptr<Value> scoped_bool(new Value(true));
   Value* original_bool = scoped_bool.get();
   original_dict.Set("bool", std::move(scoped_bool));
   std::unique_ptr<Value> scoped_int(new Value(42));
   Value* original_int = scoped_int.get();
   original_dict.Set("int", std::move(scoped_int));
   std::unique_ptr<Value> scoped_double(new Value(3.14));
   Value* original_double = scoped_double.get();
@@ skipping 518 matching lines @@
 }
 
 TEST(ValuesTest, SelfSwap) {
   base::Value test(1);
   using namespace std;
   swap(test, test);
   EXPECT_TRUE(test.GetInt() == 1);
 }
 
 }  // namespace base