Remove base::StringValue

components/user_prefs/tracked/pref_hash_calculator_unittest.cc

 // Copyright 2013 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/user_prefs/tracked/pref_hash_calculator.h"
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TEST(PrefHashCalculatorTest, TestCurrentAlgorithm) {
-  base::StringValue string_value_1("string value 1");
-  base::StringValue string_value_2("string value 2");
+  base::Value string_value_1("string value 1");
+  base::Value string_value_2("string value 2");
   base::DictionaryValue dictionary_value_1;
   dictionary_value_1.SetInteger("int value", 1);
   dictionary_value_1.Set("nested empty map", new base::DictionaryValue);
   base::DictionaryValue dictionary_value_1_equivalent;
   dictionary_value_1_equivalent.SetInteger("int value", 1);
   base::DictionaryValue dictionary_value_2;
   dictionary_value_2.SetInteger("int value", 2);
 
   PrefHashCalculator calc1("seed1", "deviceid", "legacydeviceid");
   PrefHashCalculator calc1_dup("seed1", "deviceid", "legacydeviceid");
@@ skipping 45 matching lines @@
 // must always be able to generate data that will produce these exact hashes.
 TEST(PrefHashCalculatorTest, CatchHashChanges) {
   static const char kSeed[] = "0123456789ABCDEF0123456789ABCDEF";
   static const char kDeviceId[] = "test_device_id1";
 
   std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
   std::unique_ptr<base::Value> bool_value(new base::Value(false));
   std::unique_ptr<base::Value> int_value(new base::Value(1234567890));
   std::unique_ptr<base::Value> double_value(new base::Value(123.0987654321));
   std::unique_ptr<base::Value> string_value(
-      new base::StringValue("testing with special chars:\n<>{}:^^@#$\\/"));
+      new base::Value("testing with special chars:\n<>{}:^^@#$\\/"));
 
   // For legacy reasons, we have to support pruning of empty lists/dictionaries
   // and nested empty ists/dicts in the hash generation algorithm.
   std::unique_ptr<base::DictionaryValue> nested_empty_dict(
       new base::DictionaryValue);
   nested_empty_dict->Set("a", new base::DictionaryValue);
   nested_empty_dict->Set("b", new base::ListValue);
   std::unique_ptr<base::ListValue> nested_empty_list(new base::ListValue);
   nested_empty_list->Append(base::MakeUnique<base::DictionaryValue>());
   nested_empty_list->Append(base::MakeUnique<base::ListValue>());
   nested_empty_list->Append(nested_empty_dict->CreateDeepCopy());
 
   // A dictionary with an empty dictionary, an empty list, and nested empty
   // dictionaries/lists in it.
   std::unique_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue);
-  dict_value->Set("a", new base::StringValue("foo"));
+  dict_value->Set("a", new base::Value("foo"));
   dict_value->Set("d", new base::ListValue);
   dict_value->Set("b", new base::DictionaryValue);
-  dict_value->Set("c", new base::StringValue("baz"));
+  dict_value->Set("c", new base::Value("baz"));
   dict_value->Set("e", nested_empty_dict.release());
   dict_value->Set("f", nested_empty_list.release());
 
   std::unique_ptr<base::ListValue> list_value(new base::ListValue);
   list_value->AppendBoolean(true);
   list_value->AppendInteger(100);
   list_value->AppendDouble(1.0);
 
   ASSERT_EQ(base::Value::Type::NONE, null_value->GetType());
   ASSERT_EQ(base::Value::Type::BOOLEAN, bool_value->GetType());
@@ skipping 65 matching lines @@
             PrefHashCalculator(kSeed, kDeviceId, "legacydeviceid")
                 .Validate("pref.path", &everything, kExpectedEverythingValue));
 }
 
 TEST(PrefHashCalculatorTest, TestCompatibilityWithLegacyDeviceId) {
   static const char kSeed[] = "0123456789ABCDEF0123456789ABCDEF";
   static const char kNewDeviceId[] = "new_test_device_id1";
   static const char kLegacyDeviceId[] = "test_device_id1";
 
   // As in PrefHashCalculatorTest.CatchHashChanges.
-  const base::StringValue string_value(
-      "testing with special chars:\n<>{}:^^@#$\\/");
+  const base::Value string_value("testing with special chars:\n<>{}:^^@#$\\/");
   static const char kExpectedValue[] =
       "05ACCBD3B05C45C36CD06190F63EC577112311929D8380E26E5F13182EB68318";
 
   EXPECT_EQ(PrefHashCalculator::VALID_SECURE_LEGACY,
             PrefHashCalculator(kSeed, kNewDeviceId, kLegacyDeviceId)
                 .Validate("pref.path", &string_value, kExpectedValue));
 }