Remove year+ old migration support of "session.urls_to_restore_on_startup".

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 31 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();
-}
-
 }  // 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);
 }
 
 PrefModelAssociator::~PrefModelAssociator() {
   DCHECK(CalledOnValidThread());
   pref_service_ = NULL;
 
   STLDeleteContainerPairSecondPointers(synced_pref_observers_.begin(),
                                        synced_pref_observers_.end());
   synced_pref_observers_.clear();
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
     const syncer::SyncData& sync_pref,
     const std::string& pref_name,
-    syncer::SyncChangeList* sync_changes,
-    SyncDataMap* migrated_preference_list) {
+    syncer::SyncChangeList* sync_changes) {
   const base::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(pref_name == preference.name() ||
-           (IsMigratedPreference(pref_name.c_str()) &&
-            preference.name() ==
-                GetOldMigratedPreferenceName(pref_name.c_str())));
+    DCHECK(pref_name == preference.name());
     base::JSONReader reader;
     scoped_ptr<base::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) {
       DVLOG(1) << "Found user pref value for " << pref_name;
@@ skipping 16 matching lines @@
         pref_service_->Set(pref_name.c_str(), *new_value);
       }
 
       // If the merge resulted in an updated value, inform the syncer.
       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;
         }
-
-        if (IsMigratedPreference(pref_name.c_str())) {
-          // This preference has been migrated from an old version that must be
-          // kept in sync on older versions of Chrome.
-          std::string old_pref_name =
-              GetOldMigratedPreferenceName(pref_name.c_str());
-
-          if (preference.name() == old_pref_name) {
-            DCHECK(migrated_preference_list);
-            // If the name the syncer has is the old pre-migration value, then
-            // it's possible the new migrated preference name hasn't been synced
-            // yet. In that case the SyncChange should be an ACTION_ADD rather
-            // than an ACTION_UPDATE. Defer the decision of whether to sync with
-            // ACTION_ADD or ACTION_UPDATE until the migrated_preferences phase.
-            if (migrated_preference_list)
-              (*migrated_preference_list)[pref_name] = sync_data;
-          } else {
-            DCHECK_EQ(preference.name(), pref_name);
-            sync_changes->push_back(
-                syncer::SyncChange(FROM_HERE,
-                                   syncer::SyncChange::ACTION_UPDATE,
-                                   sync_data));
-          }
-
-          syncer::SyncData old_sync_data;
-          if (!CreatePrefSyncData(old_pref_name, *new_value, &old_sync_data)) {
-            LOG(ERROR) << "Failed to update preference.";
-            return;
-          }
-          if (migrated_preference_list)
-            (*migrated_preference_list)[old_pref_name] = old_sync_data;
-        } else {
-          sync_changes->push_back(
-            syncer::SyncChange(FROM_HERE,
-                               syncer::SyncChange::ACTION_UPDATE,
-                               sync_data));
-        }
       }
     } else if (!sync_value->IsType(base::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();
     }
     synced_preferences_.insert(preference.name());
   } else if (user_pref_value) {
     // The server does not know about this preference and should be added
@@ skipping 27 matching lines @@
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
   syncer::SyncMergeResult merge_result(type);
   sync_processor_ = sync_processor.Pass();
   sync_error_factory_ = sync_error_factory.Pass();
 
   syncer::SyncChangeList new_changes;
   std::set<std::string> remaining_preferences = registered_preferences_;
 
-  // Maintains a list of old migrated preference names that we wish to sync.
-  // Keep track of these in a list such that when the preference iteration
-  // loops below are complete we can go back and determine whether
-  SyncDataMap migrated_preference_list;
-
   // 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);
     std::string sync_pref_name = preference.name();
 
     if (remaining_preferences.count(sync_pref_name) == 0) {
-      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;
-      }
+      // 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 {

[Alexei Svitkine (slow), 2015/08/31 15:08:11]

Nit: No need for } else { if you have a continue above.

[sdefresne, 2015/09/02 11:23:37]

Done.

       remaining_preferences.erase(sync_pref_name);
     }
-    InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes,
-                         &migrated_preference_list);
+    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,
-                         &migrated_preference_list);
-  }
-
-  // Now go over any migrated preference names and build sync data for them too.
-  for (SyncDataMap::const_iterator migrated_pref_iter =
-          migrated_preference_list.begin();
-       migrated_pref_iter != migrated_preference_list.end();
-       ++migrated_pref_iter) {
-    syncer::SyncChange::SyncChangeType change_type =
-        (synced_preferences_.count(migrated_pref_iter->first) == 0) ?
-            syncer::SyncChange::ACTION_ADD :
-            syncer::SyncChange::ACTION_UPDATE;
-    new_changes.push_back(
-        syncer::SyncChange(FROM_HERE, change_type, migrated_pref_iter->second));
-    synced_preferences_.insert(migrated_pref_iter->first);
+    InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes);
   }
 
   // Push updates to sync.
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   if (merge_result.error().IsSet())
     return merge_result;
 
   models_associated_ = true;
   pref_service_->OnIsSyncingChanged();
   return merge_result;
 }
 
 void PrefModelAssociator::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(type_, type);
   models_associated_ = false;
   sync_processor_.reset();
   sync_error_factory_.reset();
   pref_service_->OnIsSyncingChanged();
 }
 
 scoped_ptr<base::Value> PrefModelAssociator::MergePreference(
     const std::string& name,
     const base::Value& local_value,
     const base::Value& server_value) {
-  // This function special cases preferences individually, so don't attempt
-  // to merge for all migrated values.
-  if (name == prefs::kURLsToRestoreOnStartup ||
-      name == prefs::kURLsToRestoreOnStartupOld) {
+  if (name == prefs::kURLsToRestoreOnStartup) {
     return make_scoped_ptr(MergeListValues(local_value, server_value));
   }
 
   content_settings::WebsiteSettingsRegistry* registry =
       content_settings::WebsiteSettingsRegistry::GetInstance();
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     ContentSettingsType type = static_cast<ContentSettingsType>(i);
     if (registry->Get(type)->pref_name() == name)
       return make_scoped_ptr(MergeDictionaryValues(local_value, server_value));
   }
@@ skipping 82 matching lines @@
       }
       // Note that for all other types we want to preserve the "to"
       // values so we do nothing here.
     } else {
       result->SetWithoutPathExpansion(it.key(), from_key_value->DeepCopy());
     }
   }
   return result;
 }
 
-// static
-bool PrefModelAssociator::IsMigratedPreference(const char* preference_name) {
-  return !GetOldMigratedPreferenceName(preference_name).empty();
-}
-
-// static
-bool PrefModelAssociator::IsOldMigratedPreference(
-    const char* old_preference_name) {
-  return !GetNewMigratedPreferenceName(old_preference_name).empty();
-}
-
 // Note: This will build a model of all preferences registered as syncable
 // with user controlled data. We do not track any information for preferences
 // not registered locally as syncable and do not inform the syncer of
 // non-user controlled preferences.
 syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
     syncer::ModelType type)
     const {
   DCHECK_EQ(type_, type);
   syncer::SyncDataList current_data;
   for (PreferenceSet::const_iterator iter = synced_preferences_.begin();
@@ skipping 31 matching lines @@
 
     const sync_pb::PreferenceSpecifics& pref_specifics =
         GetSpecifics(iter->sync_data());
 
     std::string name = pref_specifics.name();
     // 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;
 
     if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) {
       pref_service_->ClearPref(pref_name);
       continue;
     }
 
     scoped_ptr<base::Value> value(ReadPreferenceSpecifics(pref_specifics));
     if (!value.get()) {
@@ skipping 95 matching lines @@
   }
 
   base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true);
 
   NotifySyncedPrefObservers(name, false /*from_sync*/);
 
   if (synced_preferences_.count(name) == 0) {
     // Not in synced_preferences_ means no synced data. InitPrefAndAssociate(..)
     // will determine if we care about its data (e.g. if it has a default value
     // and hasn't been changed yet we don't) and take care syncing any new data.
-    InitPrefAndAssociate(syncer::SyncData(), name, &changes, NULL);
+    InitPrefAndAssociate(syncer::SyncData(), name, &changes);
   } else {
     // 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())) {
-      std::string old_pref_name = GetOldMigratedPreferenceName(name.c_str());
-      if (!CreatePrefSyncData(old_pref_name,
-                              *preference->GetValue(),
-                              &sync_data)) {
-        LOG(ERROR) << "Failed to update preference.";
-        return;
-      }
-
-      syncer::SyncChange::SyncChangeType change_type =
-          (synced_preferences_.count(old_pref_name) == 0) ?
-              syncer::SyncChange::ACTION_ADD :
-              syncer::SyncChange::ACTION_UPDATE;
-      changes.push_back(
-          syncer::SyncChange(FROM_HERE, change_type, 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));
 }