Move TestingPrefService to use unique_ptr<Value>

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 363 matching lines @@
   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::Value managed_value("http://example.com");
-  prefs_.SetManagedPref(kStringPrefName, managed_value.DeepCopy());
+  prefs_.SetManagedPref(kStringPrefName, managed_value.CreateDeepCopy());
 
   syncer::SyncChangeList out;
   InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out);
   out.clear();
 
   // Changing the homepage preference should not sync anything.
   base::Value user_value("http://chromium..com");
-  prefs_.SetUserPref(kStringPrefName, user_value.DeepCopy());
+  prefs_.SetUserPref(kStringPrefName, user_value.CreateDeepCopy());
   EXPECT_TRUE(out.empty());
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   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
 // to merge the local and sync value. Make sure the merge logic doesn't merge
 // managed preferences.
 TEST_F(PrefServiceSyncableTest, ManagedListPreferences) {
   // Make the list of urls to restore on startup managed.
   base::ListValue managed_value;
   managed_value.AppendString(kExampleUrl0);
   managed_value.AppendString(kExampleUrl1);
-  prefs_.SetManagedPref(kListPrefName, managed_value.DeepCopy());
+  prefs_.SetManagedPref(kListPrefName, managed_value.CreateDeepCopy());
 
   // Set a cloud version.
   syncer::SyncDataList in;
   syncer::SyncChangeList out;
   base::ListValue urls_to_restore;
   urls_to_restore.AppendString(kExampleUrl1);
   urls_to_restore.AppendString(kExampleUrl2);
   AddToRemoteDataList(kListPrefName, urls_to_restore, &in);
 
   // Start sync and verify the synced value didn't get merged.
   InitWithSyncDataTakeOutput(in, &out);
   EXPECT_FALSE(FindValue(kListPrefName, out).get());
   out.clear();
 
   // Changing the user's urls to restore on startup pref should not sync
   // anything.
   base::ListValue user_value;
   user_value.AppendString("http://chromium.org");
-  prefs_.SetUserPref(kListPrefName, user_value.DeepCopy());
+  prefs_.SetUserPref(kListPrefName, user_value.CreateDeepCopy());
   EXPECT_FALSE(FindValue(kListPrefName, out).get());
 
   // An incoming sync transaction should change the user value, not the managed
   // value.
   base::ListValue sync_value;
   sync_value.AppendString("http://crbug.com");
   syncer::SyncChangeList list;
   list.push_back(MakeRemoteChange(1, kListPrefName, sync_value,
                                   SyncChange::ACTION_UPDATE));
   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::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::Value managed_value("http://example.com/managed");
   GetTestingPrefService()->SetManagedPref(kStringPrefName,
-                                          managed_value.DeepCopy());
+                                          managed_value.CreateDeepCopy());
 
   // 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::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::Value managed_value("http://example.com/managed");
   GetTestingPrefService()->SetManagedPref(kStringPrefName,
-                                          managed_value.DeepCopy());
+                                          managed_value.CreateDeepCopy());
 
   // Change the sync value.
   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)));
@@ skipping 12 matching lines @@
   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::Value managed_value("http://example.com/managed");
   GetTestingPrefService()->SetManagedPref(kStringPrefName,
-                                          managed_value.DeepCopy());
+                                          managed_value.CreateDeepCopy());
   // 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.
   EXPECT_TRUE(pref->IsDefaultValue());
   // There should still be no synced value.
@@ skipping 22 matching lines @@
       base::Bind(&Increment, &num_callbacks));
   EXPECT_EQ(0, num_callbacks);
 
   InitWithNoSyncData();
   EXPECT_EQ(1, num_callbacks);
 }
 
 }  // namespace
 
 }  // namespace sync_preferences