Migrate startup URLs pref.

chrome/browser/prefs/pref_model_associator.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 "chrome/browser/prefs/pref_model_associator.h"
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
@@ skipping 60 matching lines @@
 void PrefModelAssociator::InitPrefAndAssociate(
     const syncer::SyncData& sync_pref,
     const std::string& pref_name,
     syncer::SyncChangeList* sync_changes) {
   const Value* user_pref_value = pref_service_->GetUserPrefValue(
       pref_name.c_str());
   VLOG(1) << "Associating preference " << pref_name;
 
   if (sync_pref.IsValid()) {
     const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref);
-    DCHECK_EQ(pref_name, preference.name());
+    DCHECK(pref_name == preference.name() ||
+           (pref_name == prefs::kURLsToRestoreOnStartup &&
+            preference.name() == prefs::kURLsToRestoreOnStartupOld));
 
     base::JSONReader reader;
     scoped_ptr<Value> sync_value(reader.ReadToValue(preference.value()));
     if (!sync_value.get()) {
       LOG(ERROR) << "Failed to deserialize preference value: "
                  << reader.GetErrorMessage();
       return;
     }
 
     if (user_pref_value) {
@@ skipping 20 matching lines @@
       if (!sync_value->Equals(new_value.get())) {
         syncer::SyncData sync_data;
         if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) {
           LOG(ERROR) << "Failed to update preference.";
           return;
         }
         sync_changes->push_back(
             syncer::SyncChange(FROM_HERE,
                                syncer::SyncChange::ACTION_UPDATE,
                                sync_data));
+        // This preference has been migrated from an old version that must be
+        // kept in sync on older versions of Chrome.
+        if (pref_name == prefs::kURLsToRestoreOnStartup) {
+          syncer::SyncData sync_data;

[Nicolas Zea, 2013/10/04 19:37:36]

nit: CreatePrefSyncData will overwrite a SyncData object anyways, so no need to
instantiate a new one.

+          if (!CreatePrefSyncData(prefs::kURLsToRestoreOnStartupOld,
+                                  *new_value,
+                                  &sync_data)) {
+            LOG(ERROR) << "Failed to update preference.";
+            return;
+          }
+          sync_changes->push_back(
+              syncer::SyncChange(FROM_HERE,
+                                 syncer::SyncChange::ACTION_UPDATE,
+                                 sync_data));
+        }
       }
     } else if (!sync_value->IsType(Value::TYPE_NULL)) {
       // Only a server value exists. Just set the local user value.
       pref_service_->Set(pref_name.c_str(), *sync_value);
     } else {
       LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
     }
   } else if (user_pref_value) {
     // The server does not know about this preference and should be added
     // to the syncer's database.
@@ skipping 40 matching lines @@
 
   // Go through and check for all preferences we care about that sync already
   // knows about.
   for (syncer::SyncDataList::const_iterator sync_iter =
            initial_sync_data.begin();
        sync_iter != initial_sync_data.end();
        ++sync_iter) {
     DCHECK_EQ(type_, sync_iter->GetDataType());
 
     const sync_pb::PreferenceSpecifics& preference = GetSpecifics(*sync_iter);
-    const std::string& sync_pref_name = preference.name();
+    std::string sync_pref_name = preference.name();
 
     if (remaining_preferences.count(sync_pref_name) == 0) {
-      // We're not syncing this preference locally, ignore the sync data.
-      // TODO(zea): Eventually we want to be able to have the syncable service
-      // reconstruct all sync data for it's datatype (therefore having
-      // GetAllSyncData be a complete representation). We should store this data
-      // somewhere, even if we don't use it.
-      continue;
+      if (sync_pref_name == prefs::kURLsToRestoreOnStartupOld) {
+        // This old pref name is not syncable locally anymore but we accept
+        // changes from other Chrome installs of previous versions and migrate
+        // them to the new name. Note that we will be merging any differences
+        // between the new and old values and sync'ing them back.
+        sync_pref_name = prefs::kURLsToRestoreOnStartup;
+      } else {
+        // We're not syncing this preference locally, ignore the sync data.
+        // TODO(zea): Eventually we want to be able to have the syncable service
+        // reconstruct all sync data for its datatype (therefore having
+        // GetAllSyncData be a complete representation). We should store this
+        // data somewhere, even if we don't use it.
+        continue;
+      }
+    } else {
+      remaining_preferences.erase(sync_pref_name);
     }
-
-    remaining_preferences.erase(sync_pref_name);
     InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes);
   }
 
   // Go through and build sync data for any remaining preferences.
   for (std::set<std::string>::iterator pref_name_iter =
           remaining_preferences.begin();
        pref_name_iter != remaining_preferences.end();
        ++pref_name_iter) {
     InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
@@ skipping 14 matching lines @@
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
   pref_service_->OnIsSyncingChanged();
 }
 
 scoped_ptr<Value> PrefModelAssociator::MergePreference(
     const std::string& name,
     const Value& local_value,
     const Value& server_value) {
-  if (name == prefs::kURLsToRestoreOnStartup) {
+  if (name == prefs::kURLsToRestoreOnStartup ||
+      name == prefs::kURLsToRestoreOnStartupOld) {
     return scoped_ptr<Value>(MergeListValues(local_value, server_value)).Pass();
   }
 
   if (name == prefs::kContentSettingsPatternPairs) {
     return scoped_ptr<Value>(
         MergeDictionaryValues(local_value, server_value)).Pass();
   }
 
   // If this is not a specially handled preference, server wins.
   return scoped_ptr<Value>(server_value.DeepCopy()).Pass();
@@ skipping 142 matching lines @@
     // TODO(zea): consider taking some further action such as erasing the bad
     // data.
     if (!value.get())
       continue;
 
     // It is possible that we may receive a change to a preference we do not
     // want to sync. For example if the user is syncing a Mac client and a
     // Windows client, the Windows client does not support
     // kConfirmToQuitEnabled. Ignore updates from these preferences.
     const char* pref_name = name.c_str();
-    if (!IsPrefRegistered(pref_name))
+    // We migrated this preference name, so do as if the name had not changed.
+    if (name == prefs::kURLsToRestoreOnStartupOld)
+      pref_name = prefs::kURLsToRestoreOnStartup;
+    else if (!IsPrefRegistered(pref_name))
       continue;
 
     const PrefService::Preference* pref =
         pref_service_->FindPreference(pref_name);
     DCHECK(pref);
 
     // This will only modify the user controlled value store, which takes
     // priority over the default value but is ignored if the preference is
     // policy controlled.
     pref_service_->Set(pref_name, *value);
 
     NotifySyncedPrefObservers(name, true /*from_sync*/);

[robertshield, 2013/10/07 16:42:57]

@Nicolas: it looks like this uses the old "name" rather than the potentially
updated "pref_name". Same on line 436 below. Is this right?

[Nicolas Zea, 2013/10/07 17:08:07]

I missed this, but as it happens it's okay to leave. NotifySyncedPrefObservers
is only important for local listeners to the preference, and all local listeners
should be listening to the new preference. |synced_preferences_| is only used
when listening to local pref changes, which for the old pref doesn't matter.

 
     // Keep track of any newly synced preferences.
     if (iter->change_type() == syncer::SyncChange::ACTION_ADD) {
       synced_preferences_.insert(name);
     }
   }
   return syncer::SyncError();
 }
 
 Value* PrefModelAssociator::ReadPreferenceSpecifics(
@@ skipping 87 matching lines @@
     // We are already syncing this preference, just update it's sync node.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
       return;
     }
     changes.push_back(
         syncer::SyncChange(FROM_HERE,
                            syncer::SyncChange::ACTION_UPDATE,
                            sync_data));
+    // This preference has been migrated from an old version that must be kept
+    // in sync on older versions of Chrome.
+    if (name == prefs::kURLsToRestoreOnStartup) {
+      syncer::SyncData sync_data;
+      if (!CreatePrefSyncData(prefs::kURLsToRestoreOnStartupOld,
+                              *preference->GetValue(),
+                              &sync_data)) {
+        LOG(ERROR) << "Failed to update preference.";
+        return;
+      }
+
+      changes.push_back(
+          syncer::SyncChange(FROM_HERE,
+                             syncer::SyncChange::ACTION_UPDATE,
+                             sync_data));
+    }
   }
 
   syncer::SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) {
   DCHECK(pref_service_ == NULL);
   pref_service_ = pref_service;
 }
 
 void PrefModelAssociator::NotifySyncedPrefObservers(const std::string& path,
                                                     bool from_sync) const {
   SyncedPrefObserverMap::const_iterator observer_iter =
       synced_pref_observers_.find(path);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second;
   FOR_EACH_OBSERVER(SyncedPrefObserver, *observers,
                     OnSyncedPrefChanged(path, from_sync));
 }