Remove base::Value::CreateNullValue

mojo/common/common_custom_types_unittest.cc

 // Copyright 2016 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/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_math.h"
 #include "base/run_loop.h"
@@ skipping 256 matching lines @@
 
 TEST_F(CommonCustomTypesTest, Value) {
   TestValuePtr ptr;
   TestValueImpl impl(MakeRequest(&ptr));
 
   std::unique_ptr<base::Value> output;
 
   ASSERT_TRUE(ptr->BounceValue(nullptr, &output));
   EXPECT_FALSE(output);
 
-  std::unique_ptr<base::Value> input = base::Value::CreateNullValue();
+  auto input = base::MakeUnique<base::Value>();
   ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
   EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
 
   input = base::MakeUnique<base::Value>(123);
   ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
   EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
 
   input = base::MakeUnique<base::Value>(1.23);
   ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
   EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
@@ skipping 11 matching lines @@
   EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
 
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetBoolean("bool", false);
   dict->SetInteger("int", 2);
   dict->SetString("string", "some string");
   dict->SetBoolean("nested.bool", true);
   dict->SetInteger("nested.int", 9);
   dict->Set("some_binary",
             base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
-  dict->Set("null_value", base::Value::CreateNullValue());
+  dict->Set("null_value", base::MakeUnique<base::Value>());
   dict->SetIntegerWithoutPathExpansion("non_nested.int", 10);
   {
     std::unique_ptr<base::ListValue> dict_list(new base::ListValue());
     dict_list->AppendString("string");
     dict_list->AppendBoolean(true);
     dict->Set("list", std::move(dict_list));
   }
 
   std::unique_ptr<base::DictionaryValue> dict_output;
   ASSERT_TRUE(ptr->BounceDictionaryValue(dict->CreateDeepCopy(), &dict_output));
   EXPECT_TRUE(base::Value::Equals(dict.get(), dict_output.get()));
 
   input = std::move(dict);
   ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
   EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
 
   auto list = base::MakeUnique<base::ListValue>();
   list->AppendString("string");
   list->AppendDouble(42.1);
   list->AppendBoolean(true);
   list->Append(base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
-  list->Append(base::Value::CreateNullValue());
+  list->Append(base::MakeUnique<base::Value>());
   {
     std::unique_ptr<base::DictionaryValue> list_dict(
         new base::DictionaryValue());
     list_dict->SetString("string", "str");
     list->Append(std::move(list_dict));
   }
   std::unique_ptr<base::ListValue> list_output;
   ASSERT_TRUE(ptr->BounceListValue(list->CreateDeepCopy(), &list_output));
   EXPECT_TRUE(base::Value::Equals(list.get(), list_output.get()));
 
@@ skipping 82 matching lines @@
   for (size_t i = 0; i < arraysize(kTestDirections); i++) {
     base::i18n::TextDirection direction_out;
     ASSERT_TRUE(ptr->BounceTextDirection(kTestDirections[i], &direction_out));
     EXPECT_EQ(kTestDirections[i], direction_out);
   }
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo