Remove base::StringValue

components/prefs/json_pref_store_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 "components/prefs/json_pref_store.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 211 matching lines @@
 
   const char kSomeDirectory[] = "some_directory";
 
   EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual));
   base::FilePath::StringType path;
   EXPECT_TRUE(actual->GetAsString(&path));
   EXPECT_EQ(base::FilePath::StringType(FILE_PATH_LITERAL("/usr/local/")), path);
   base::FilePath some_path(FILE_PATH_LITERAL("/usr/sbin/"));
 
   pref_store->SetValue(kSomeDirectory,
-                       base::MakeUnique<StringValue>(some_path.value()),
+                       base::MakeUnique<Value>(some_path.value()),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual));
   EXPECT_TRUE(actual->GetAsString(&path));
   EXPECT_EQ(some_path.value(), path);
 
   // Test reading some other data types from sub-dictionaries.
   EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual));
   bool boolean = false;
   EXPECT_TRUE(actual->GetAsBoolean(&boolean));
   EXPECT_TRUE(boolean);
 
   pref_store->SetValue(kNewWindowsInTabs, base::MakeUnique<Value>(false),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual));
   EXPECT_TRUE(actual->GetAsBoolean(&boolean));
   EXPECT_FALSE(boolean);
 
   EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual));
   int integer = 0;
   EXPECT_TRUE(actual->GetAsInteger(&integer));
   EXPECT_EQ(20, integer);
   pref_store->SetValue(kMaxTabs, base::MakeUnique<Value>(10),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual));
   EXPECT_TRUE(actual->GetAsInteger(&integer));
   EXPECT_EQ(10, integer);
 
-  pref_store->SetValue(kLongIntPref, base::MakeUnique<StringValue>(
-                                         base::Int64ToString(214748364842LL)),
-                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  pref_store->SetValue(
+      kLongIntPref,
+      base::MakeUnique<Value>(base::Int64ToString(214748364842LL)),
+      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kLongIntPref, &actual));
   EXPECT_TRUE(actual->GetAsString(&string_value));
   int64_t value;
   base::StringToInt64(string_value, &value);
   EXPECT_EQ(214748364842LL, value);
 
   // Serialize and compare to expected output.
   pref_store->CommitPendingWrite();
   RunLoop().RunUntilIdle();
 
@@ skipping 592 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(JsonPrefStoreLossyWriteTest);
 };
 
 TEST_F(JsonPrefStoreLossyWriteTest, LossyWriteBasic) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
 
   // Set a normal pref and check that it gets scheduled to be written.
   ASSERT_FALSE(file_writer->HasPendingWrite());
-  pref_store->SetValue("normal", base::MakeUnique<base::StringValue>("normal"),
+  pref_store->SetValue("normal", base::MakeUnique<base::Value>("normal"),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   ASSERT_TRUE(file_writer->HasPendingWrite());
   file_writer->DoScheduledWrite();
   ASSERT_EQ("{\"normal\":\"normal\"}", GetTestFileContents());
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Set a lossy pref and check that it is not scheduled to be written.
   // SetValue/RemoveValue.
-  pref_store->SetValue("lossy", base::MakeUnique<base::StringValue>("lossy"),
+  pref_store->SetValue("lossy", base::MakeUnique<base::Value>("lossy"),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
   pref_store->RemoveValue("lossy", WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // SetValueSilently/RemoveValueSilently.
-  pref_store->SetValueSilently("lossy",
-                               base::MakeUnique<base::StringValue>("lossy"),
+  pref_store->SetValueSilently("lossy", base::MakeUnique<base::Value>("lossy"),
                                WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
   pref_store->RemoveValueSilently("lossy",
                                   WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // ReportValueChanged.
-  pref_store->SetValue("lossy", base::MakeUnique<base::StringValue>("lossy"),
+  pref_store->SetValue("lossy", base::MakeUnique<base::Value>("lossy"),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
   pref_store->ReportValueChanged("lossy",
                                  WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Call CommitPendingWrite and check that the lossy pref and the normal pref
   // are there with the last values set above.
   pref_store->CommitPendingWrite();
   ASSERT_FALSE(file_writer->HasPendingWrite());
   ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}",
             GetTestFileContents());
 }
 
 TEST_F(JsonPrefStoreLossyWriteTest, LossyWriteMixedLossyFirst) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
 
   // Set a lossy pref and check that it is not scheduled to be written.
   ASSERT_FALSE(file_writer->HasPendingWrite());
-  pref_store->SetValue("lossy", base::MakeUnique<base::StringValue>("lossy"),
+  pref_store->SetValue("lossy", base::MakeUnique<base::Value>("lossy"),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Set a normal pref and check that it is scheduled to be written.
-  pref_store->SetValue("normal", base::MakeUnique<base::StringValue>("normal"),
+  pref_store->SetValue("normal", base::MakeUnique<base::Value>("normal"),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call DoScheduledWrite and check both prefs get written.
   file_writer->DoScheduledWrite();
   ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}",
             GetTestFileContents());
   ASSERT_FALSE(file_writer->HasPendingWrite());
 }
 
 TEST_F(JsonPrefStoreLossyWriteTest, LossyWriteMixedLossySecond) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
 
   // Set a normal pref and check that it is scheduled to be written.
   ASSERT_FALSE(file_writer->HasPendingWrite());
-  pref_store->SetValue("normal", base::MakeUnique<base::StringValue>("normal"),
+  pref_store->SetValue("normal", base::MakeUnique<base::Value>("normal"),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Set a lossy pref and check that the write is still scheduled.
-  pref_store->SetValue("lossy", base::MakeUnique<base::StringValue>("lossy"),
+  pref_store->SetValue("lossy", base::MakeUnique<base::Value>("lossy"),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call DoScheduledWrite and check both prefs get written.
   file_writer->DoScheduledWrite();
   ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}",
             GetTestFileContents());
   ASSERT_FALSE(file_writer->HasPendingWrite());
 }
 
 TEST_F(JsonPrefStoreLossyWriteTest, ScheduleLossyWrite) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
 
   // Set a lossy pref and check that it is not scheduled to be written.
-  pref_store->SetValue("lossy", base::MakeUnique<base::StringValue>("lossy"),
+  pref_store->SetValue("lossy", base::MakeUnique<base::Value>("lossy"),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Schedule pending lossy writes and check that it is scheduled.
   pref_store->SchedulePendingLossyWrites();
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call CommitPendingWrite and check that the lossy pref is there with the
   // last value set above.
   pref_store->CommitPendingWrite();
@@ skipping 143 matching lines @@
 
   std::unique_ptr<InterceptingPrefFilter> intercepting_pref_filter(
       new InterceptingPrefFilter(write_callback_observer_.GetCallbackPair()));
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, message_loop_.task_runner(),
                         std::move(intercepting_pref_filter));
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store.get());
 
   EXPECT_EQ(NOT_CALLED,
             write_callback_observer_.GetAndResetPostWriteObservationState());
-  pref_store->SetValue("normal", base::MakeUnique<base::StringValue>("normal"),
+  pref_store->SetValue("normal", base::MakeUnique<base::Value>("normal"),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   file_writer->DoScheduledWrite();
 
   // The observer should not be invoked right away.
   EXPECT_FALSE(write_callback_observer_.GetAndResetPreWriteObservationState());
   EXPECT_EQ(NOT_CALLED,
             write_callback_observer_.GetAndResetPostWriteObservationState());
 
   RunLoop().RunUntilIdle();
 
@@ skipping 105 matching lines @@
     file_writer->WriteNow(MakeUnique<std::string>("foo"));
   }
   RunLoop().RunUntilIdle();
   EXPECT_FALSE(successful_write_reply_observer_.GetAndResetObservationState());
   EXPECT_TRUE(write_callback_observer_.GetAndResetPreWriteObservationState());
   EXPECT_EQ(CALLED_WITH_SUCCESS,
             write_callback_observer_.GetAndResetPostWriteObservationState());
 }
 
 }  // namespace base