Remove base::StringValue

components/sync_preferences/pref_service_syncable_unittest.cc

 // Copyright 2014 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/sync_preferences/pref_service_syncable.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 255 matching lines @@
   prefs_.SetString(kStringPrefName, kExampleUrl0);
   {
     ListPrefUpdate update(GetPrefs(), kListPrefName);
     base::ListValue* url_list = update.Get();
     url_list->AppendString(kExampleUrl0);
     url_list->AppendString(kExampleUrl1);
   }
 
   syncer::SyncDataList in;
   syncer::SyncChangeList out;
-  AddToRemoteDataList(kStringPrefName, base::StringValue(kExampleUrl1), &in);
+  AddToRemoteDataList(kStringPrefName, base::Value(kExampleUrl1), &in);
   base::ListValue urls_to_restore;
   urls_to_restore.AppendString(kExampleUrl1);
   urls_to_restore.AppendString(kExampleUrl2);
   AddToRemoteDataList(kListPrefName, urls_to_restore, &in);
   AddToRemoteDataList(kDefaultCharsetPrefName,
-                      base::StringValue(kNonDefaultCharsetValue), &in);
+                      base::Value(kNonDefaultCharsetValue), &in);
   InitWithSyncDataTakeOutput(in, &out);
 
   ASSERT_FALSE(FindValue(kStringPrefName, out).get());
   ASSERT_FALSE(FindValue(kDefaultCharsetPrefName, out).get());
 
   EXPECT_EQ(kExampleUrl1, prefs_.GetString(kStringPrefName));
 
   std::unique_ptr<base::ListValue> expected_urls(new base::ListValue);
   expected_urls->AppendString(kExampleUrl1);
   expected_urls->AppendString(kExampleUrl2);
@@ skipping 16 matching lines @@
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedPreferenceWithDefaultValue) {
   const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName);
   EXPECT_TRUE(pref->IsDefaultValue());
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
-  base::StringValue expected(kExampleUrl0);
+  base::Value expected(kExampleUrl0);
   GetPrefs()->Set(kStringPrefName, expected);
 
   std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(expected.Equals(actual.get()));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedPreferenceWithValue) {
   GetPrefs()->SetString(kStringPrefName, kExampleUrl0);
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
-  base::StringValue expected(kExampleUrl1);
+  base::Value expected(kExampleUrl1);
   GetPrefs()->Set(kStringPrefName, expected);
 
   std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(expected.Equals(actual.get()));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeActionUpdate) {
   GetPrefs()->SetString(kStringPrefName, kExampleUrl0);
   InitWithNoSyncData();
 
-  base::StringValue expected(kExampleUrl1);
+  base::Value expected(kExampleUrl1);
   syncer::SyncChangeList list;
   list.push_back(MakeRemoteChange(1, kStringPrefName, expected,
                                   SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
   const base::Value& actual = GetPreferenceValue(kStringPrefName);
   EXPECT_TRUE(expected.Equals(&actual));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeActionAdd) {
   InitWithNoSyncData();
 
-  base::StringValue expected(kExampleUrl0);
+  base::Value expected(kExampleUrl0);
   syncer::SyncChangeList list;
   list.push_back(
       MakeRemoteChange(1, kStringPrefName, expected, SyncChange::ACTION_ADD));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
   const base::Value& actual = GetPreferenceValue(kStringPrefName);
   EXPECT_TRUE(expected.Equals(&actual));
   EXPECT_EQ(
       1U, pref_sync_service_->registered_preferences().count(kStringPrefName));
 }
 
 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeUnknownPreference) {
   InitWithNoSyncData();
   syncer::SyncChangeList list;
-  base::StringValue expected(kExampleUrl0);
+  base::Value expected(kExampleUrl0);
   list.push_back(MakeRemoteChange(1, "unknown preference", expected,
                                   SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
   // Nothing interesting happens on the client when it gets an update
   // of an unknown preference.  We just should not crash.
 }
 
 TEST_F(PrefServiceSyncableTest, ManagedPreferences) {
   // Make the homepage preference managed.
-  base::StringValue managed_value("http://example.com");
+  base::Value managed_value("http://example.com");
   prefs_.SetManagedPref(kStringPrefName, managed_value.DeepCopy());
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
   // Changing the homepage preference should not sync anything.
-  base::StringValue user_value("http://chromium..com");
+  base::Value user_value("http://chromium..com");
   prefs_.SetUserPref(kStringPrefName, user_value.DeepCopy());
   EXPECT_TRUE(out.empty());
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
-  base::StringValue sync_value("http://crbug.com");
+  base::Value sync_value("http://crbug.com");
   syncer::SyncChangeList list;
   list.push_back(MakeRemoteChange(1, kStringPrefName, sync_value,
                                   SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
   EXPECT_TRUE(managed_value.Equals(prefs_.GetManagedPref(kStringPrefName)));
   EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(kStringPrefName)));
 }
 
 // List preferences have special handling at association time due to our ability
@@ skipping 36 matching lines @@
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
   EXPECT_TRUE(managed_value.Equals(prefs_.GetManagedPref(kListPrefName)));
   EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(kListPrefName)));
 }
 
 TEST_F(PrefServiceSyncableTest, DynamicManagedPreferences) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
-  base::StringValue initial_value("http://example.com/initial");
+  base::Value initial_value("http://example.com/initial");
   GetPrefs()->Set(kStringPrefName, initial_value);
   std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out));
   ASSERT_TRUE(actual.get());
   EXPECT_TRUE(initial_value.Equals(actual.get()));
 
   // Switch kHomePage to managed and set a different value.
-  base::StringValue managed_value("http://example.com/managed");
+  base::Value managed_value("http://example.com/managed");
   GetTestingPrefService()->SetManagedPref(kStringPrefName,
                                           managed_value.DeepCopy());
 
   // The pref value should be the one dictated by policy.
   EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kStringPrefName)));
 
   // Switch kHomePage back to unmanaged.
   GetTestingPrefService()->RemoveManagedPref(kStringPrefName);
 
   // The original value should be picked up.
   EXPECT_TRUE(initial_value.Equals(&GetPreferenceValue(kStringPrefName)));
 }
 
 TEST_F(PrefServiceSyncableTest, DynamicManagedPreferencesWithSyncChange) {
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
-  base::StringValue initial_value("http://example.com/initial");
+  base::Value initial_value("http://example.com/initial");
   GetPrefs()->Set(kStringPrefName, initial_value);
   std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out));
   EXPECT_TRUE(initial_value.Equals(actual.get()));
 
   // Switch kHomePage to managed and set a different value.
-  base::StringValue managed_value("http://example.com/managed");
+  base::Value managed_value("http://example.com/managed");
   GetTestingPrefService()->SetManagedPref(kStringPrefName,
                                           managed_value.DeepCopy());
 
   // Change the sync value.
-  base::StringValue sync_value("http://example.com/sync");
+  base::Value sync_value("http://example.com/sync");
   syncer::SyncChangeList list;
   list.push_back(MakeRemoteChange(1, kStringPrefName, sync_value,
                                   SyncChange::ACTION_UPDATE));
   pref_sync_service_->ProcessSyncChanges(FROM_HERE, list);
 
   // The pref value should still be the one dictated by policy.
   EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kStringPrefName)));
 
   // Switch kHomePage back to unmanaged.
   GetTestingPrefService()->RemoveManagedPref(kStringPrefName);
 
   // Sync value should be picked up.
   EXPECT_TRUE(sync_value.Equals(&GetPreferenceValue(kStringPrefName)));
 }
 
 TEST_F(PrefServiceSyncableTest, DynamicManagedDefaultPreferences) {
   const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName);
   EXPECT_TRUE(pref->IsDefaultValue());
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
 
   EXPECT_TRUE(IsSynced(kStringPrefName));
   EXPECT_TRUE(pref->IsDefaultValue());
   EXPECT_FALSE(FindValue(kStringPrefName, out).get());
   out.clear();
 
   // Switch kHomePage to managed and set a different value.
-  base::StringValue managed_value("http://example.com/managed");
+  base::Value managed_value("http://example.com/managed");
   GetTestingPrefService()->SetManagedPref(kStringPrefName,
                                           managed_value.DeepCopy());
   // The pref value should be the one dictated by policy.
   EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kStringPrefName)));
   EXPECT_FALSE(pref->IsDefaultValue());
   // There should be no synced value.
   EXPECT_FALSE(FindValue(kStringPrefName, out).get());
   // Switch kHomePage back to unmanaged.
   GetTestingPrefService()->RemoveManagedPref(kStringPrefName);
   // The original value should be picked up.
@@ skipping 24 matching lines @@
       base::Bind(&Increment, &num_callbacks));
   EXPECT_EQ(0, num_callbacks);
 
   InitWithNoSyncData();
   EXPECT_EQ(1, num_callbacks);
 }
 
 }  // namespace
 
 }  // namespace sync_preferences