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 30 matching lines @@
     sync_pb::EntitySpecifics* specifics) {
   if (type == syncer::PRIORITY_PREFERENCES) {
     DCHECK(!specifics->has_preference());
     return specifics->mutable_priority_preference()->mutable_preference();
   } else {
     DCHECK(!specifics->has_priority_preference());
     return specifics->mutable_preference();
   }
 }
 
+// List of migrated preference name pairs. If a preference is migrated
+// (meaning renamed) adding the old and new preference names here will ensure
+// that the sync engine knows how to deal with the synced values coming in
+// with the old name. Preference migration itself doesn't happen here. It may
+// happen in session_startup_pref.cc.
+const struct MigratedPreferences {
+  const char* const old_name;
+  const char* const new_name;
+} kMigratedPreferences[] = {
+  { prefs::kURLsToRestoreOnStartupOld, prefs::kURLsToRestoreOnStartup },
+};
+
+std::string GetOldMigratedPreferenceName(const char* preference_name) {
+  for (size_t i = 0; i < arraysize(kMigratedPreferences); ++i) {
+    if (!strcmp(kMigratedPreferences[i].new_name, preference_name))
+      return kMigratedPreferences[i].old_name;
+  }
+  return std::string();
+}
+
+std::string GetNewMigratedPreferenceName(const char* old_preference_name) {
+  for (size_t i = 0; i < arraysize(kMigratedPreferences); ++i) {
+    if (!strcmp(kMigratedPreferences[i].old_name, old_preference_name))
+      return kMigratedPreferences[i].new_name;
+  }
+  return std::string();
+}
+
+bool IsMigratedPreference(const char* preference_name) {
+  return !GetOldMigratedPreferenceName(preference_name).empty();
+}
+
+bool IsOldMigratedPreference(const char* old_preference_name) {
+  return !GetNewMigratedPreferenceName(old_preference_name).empty();
+}
+
 }  // namespace
 
 PrefModelAssociator::PrefModelAssociator(syncer::ModelType type)
     : models_associated_(false),
       processing_syncer_changes_(false),
       pref_service_(NULL),
       type_(type) {
   DCHECK(CalledOnValidThread());
   DCHECK(type_ == PREFERENCES || type_ == PRIORITY_PREFERENCES);
 }
@@ skipping 10 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() ||
+           (IsMigratedPreference(pref_name.c_str()) &&
+            preference.name() ==
+                GetOldMigratedPreferenceName(pref_name.c_str())));
     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) {
       // We have both server and local values. Merge them.
@@ skipping 19 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 (IsMigratedPreference(pref_name.c_str())) {
+          if (!CreatePrefSyncData(
+                  GetOldMigratedPreferenceName(pref_name.c_str()),
+                  *new_value,
+                  &sync_data)) {
+            LOG(ERROR) << "Failed to update preference.";
+            return;
+          }
+          sync_changes->push_back(
+              syncer::SyncChange(FROM_HERE,
+                                 syncer::SyncChange::ACTION_UPDATE,

[Nicolas Zea, 2013/10/09 17:40:52]

It occurs to me this isn't always correct (and this is likely the reason the
tests are failing). We should only UPDATE if the old pref exists, else we should
ADD.

It's a bit tricky to know if a synced version of a preference exists at this
point, because we're still iterating over the set of synced preferences during
the MergeDataAndStartSyncing call. It might be better to wait to push these
changes until the end of MergeDataAndStartSyncing, when you know whether a
synced version of the old pref exists or not.

[robertshield, 2013/10/10 00:40:18]

Done.

+                                 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 (IsOldMigratedPreference(sync_pref_name.c_str())) {
+        // 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 = GetNewMigratedPreferenceName(sync_pref_name.c_str());
+      } 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) {
+  // This function special cases preferences individually, so don't attempt
+  // to merge for all migrated values.
+  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();
+    std::string new_name;
+    // We migrated this preference name, so do as if the name had not changed.
+    if (IsOldMigratedPreference(pref_name)) {
+      new_name = GetNewMigratedPreferenceName(pref_name);
+      pref_name = new_name.c_str();
+    }
+
     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.
@@ skipping 100 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 (IsMigratedPreference(name.c_str())) {
+      if (!CreatePrefSyncData(GetOldMigratedPreferenceName(name.c_str()),
+                              *preference->GetValue(),
+                              &sync_data)) {
+        LOG(ERROR) << "Failed to update preference.";
+        return;
+      }
+
+      changes.push_back(
+          syncer::SyncChange(FROM_HERE,
+                             syncer::SyncChange::ACTION_UPDATE,

[Nicolas Zea, 2013/10/09 17:40:52]

here too. We can check synced_preferences_.count(old_name) to see if it exists
or not

[robertshield, 2013/10/10 00:40:18]

Done.

+                             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));
 }