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 40 matching lines @@
 
 // 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 },
+  // arraysize macro does not supports empty arrays, so we use a sentinel
+  // value when there are no migrated preferences.
+  { NULL, NULL },

[gab, 2015/08/24 21:48:45]

+zea: Think we should keep this around or simply get rid of it? I know it was
tricky to add so perhaps it is indeed worth keeping around an an empty list for
now?

[Nicolas Zea, 2015/08/25 17:10:30]

I'd rather get rid of it personally. If someone does want to bring it back,
it'll be preserved in the git history (and we could always leave a comment
explaining that if a migration does happen, where it should be performed and
how).

[sdefresne, 2015/08/26 16:00:56]

Done.

 };
 
 std::string GetOldMigratedPreferenceName(const char* preference_name) {
   for (size_t i = 0; i < arraysize(kMigratedPreferences); ++i) {
-    if (!strcmp(kMigratedPreferences[i].new_name, preference_name))
+    if (kMigratedPreferences[i].new_name &&
+        !strcmp(kMigratedPreferences[i].new_name, preference_name)) {
+      DCHECK(kMigratedPreferences[i].old_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))
+    if (kMigratedPreferences[i].old_name &&
+        !strcmp(kMigratedPreferences[i].old_name, old_preference_name)) {
+      DCHECK(kMigratedPreferences[i].new_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),
@@ skipping 225 matching lines @@
   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 316 matching lines @@
 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));
 }