sync: move invalidation version prefs out of SyncPrefs into InvalidatorStorage.

chrome/browser/sync/sync_prefs.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/sync/sync_prefs.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 namespace browser_sync {
 
 SyncPrefObserver::~SyncPrefObserver() {}
 
 SyncPrefs::SyncPrefs(PrefService* pref_service)
     : pref_service_(pref_service) {
   RegisterPrefGroups();
+  // TODO(tim): Create a Mock instead of maintaining the if(!pref_service_) case
+  // throughout this file.  This is a problem now due to lack of injection at
+  // ProfileSyncService. Bug 130176.
   if (pref_service_) {
     RegisterPreferences();
     // Watch the preference that indicates sync is managed so we can take
     // appropriate action.
     pref_sync_managed_.Init(prefs::kSyncManaged, pref_service_, this);
   }
 }
 
 SyncPrefs::~SyncPrefs() {
   DCHECK(non_thread_safe_.CalledOnValidThread());
@@ skipping 11 matching lines @@
 
 void SyncPrefs::ClearPreferences() {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->ClearPref(prefs::kSyncLastSyncedTime);
   pref_service_->ClearPref(prefs::kSyncHasSetupCompleted);
   pref_service_->ClearPref(prefs::kSyncEncryptionBootstrapToken);
 
   // TODO(nick): The current behavior does not clear
   // e.g. prefs::kSyncBookmarks.  Is that really what we want?
-
-  pref_service_->ClearPref(prefs::kSyncMaxInvalidationVersions);
 }
 
 bool SyncPrefs::HasSyncSetupCompleted() const {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   return
       pref_service_ &&
       pref_service_->GetBoolean(prefs::kSyncHasSetupCompleted);
 }
 
 void SyncPrefs::SetSyncSetupCompleted() {
@@ skipping 115 matching lines @@
   return pref_service_ ?
       pref_service_->GetString(prefs::kSyncSpareBootstrapToken) : "";
 }
 
 void SyncPrefs::SetSpareBootstrapToken(const std::string& token) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   pref_service_->SetString(prefs::kSyncSpareBootstrapToken, token);
 }
 #endif
 
-sync_notifier::InvalidationVersionMap SyncPrefs::GetAllMaxVersions() const {
-  DCHECK(non_thread_safe_.CalledOnValidThread());
-  if (!pref_service_) {
-    return sync_notifier::InvalidationVersionMap();
-  }
-  // Complicated gross code to convert from a string -> string
-  // DictionaryValue to a ModelType -> int64 map.
-  const base::DictionaryValue* max_versions_dict =
-      pref_service_->GetDictionary(prefs::kSyncMaxInvalidationVersions);
-  CHECK(max_versions_dict);
-  sync_notifier::InvalidationVersionMap max_versions;
-  for (base::DictionaryValue::key_iterator it =
-           max_versions_dict->begin_keys();
-       it != max_versions_dict->end_keys(); ++it) {
-    int model_type_int = 0;
-    if (!base::StringToInt(*it, &model_type_int)) {
-      LOG(WARNING) << "Invalid model type key: " << *it;
-      continue;
-    }
-    if ((model_type_int < syncable::FIRST_REAL_MODEL_TYPE) ||
-        (model_type_int >= syncable::MODEL_TYPE_COUNT)) {
-      LOG(WARNING) << "Out-of-range model type key: " << model_type_int;
-      continue;
-    }
-    const syncable::ModelType model_type =
-        syncable::ModelTypeFromInt(model_type_int);
-    std::string max_version_str;
-    CHECK(max_versions_dict->GetString(*it, &max_version_str));
-    int64 max_version = 0;
-    if (!base::StringToInt64(max_version_str, &max_version)) {
-      LOG(WARNING) << "Invalid max invalidation version for "
-                   << syncable::ModelTypeToString(model_type) << ": "
-                   << max_version_str;
-      continue;
-    }
-    max_versions[model_type] = max_version;
-  }
-  return max_versions;
-}
-
-void SyncPrefs::SetMaxVersion(syncable::ModelType model_type,
-                              int64 max_version) {
-  DCHECK(non_thread_safe_.CalledOnValidThread());
-  DCHECK(syncable::IsRealDataType(model_type));
-  CHECK(pref_service_);
-  sync_notifier::InvalidationVersionMap max_versions =
-      GetAllMaxVersions();
-  sync_notifier::InvalidationVersionMap::iterator it =
-      max_versions.find(model_type);
-  if ((it != max_versions.end()) && (max_version <= it->second)) {
-    NOTREACHED();
-    return;
-  }
-  max_versions[model_type] = max_version;
-
-  // Gross code to convert from a ModelType -> int64 map to a string
-  // -> string DictionaryValue.
-  base::DictionaryValue max_versions_dict;
-  for (sync_notifier::InvalidationVersionMap::const_iterator it =
-           max_versions.begin();
-       it != max_versions.end(); ++it) {
-    max_versions_dict.SetString(
-        base::IntToString(it->first),
-        base::Int64ToString(it->second));
-  }
-  pref_service_->Set(prefs::kSyncMaxInvalidationVersions, max_versions_dict);
-}
 
 void SyncPrefs::AcknowledgeSyncedTypes(
     syncable::ModelTypeSet types) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   // Add the types to the current set of acknowledged
   // types, and then store the resulting set in prefs.
   const syncable::ModelTypeSet acknowledged_types =
       Union(types,
             syncable::ModelTypeSetFromValue(
@@ skipping 159 matching lines @@
   model_set.Put(syncable::THEMES);
   model_set.Put(syncable::EXTENSIONS);
   model_set.Put(syncable::NIGORI);
   model_set.Put(syncable::SEARCH_ENGINES);
   model_set.Put(syncable::APPS);
   model_set.Put(syncable::TYPED_URLS);
   model_set.Put(syncable::SESSIONS);
   pref_service_->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
                                   syncable::ModelTypeSetToValue(model_set),
                                   PrefService::UNSYNCABLE_PREF);
-
-  pref_service_->RegisterDictionaryPref(prefs::kSyncMaxInvalidationVersions,
-                                        PrefService::UNSYNCABLE_PREF);
 }
 
 void SyncPrefs::RegisterDataTypePreferredPref(syncable::ModelType type,
                                               bool is_preferred) {
   DCHECK(non_thread_safe_.CalledOnValidThread());
   CHECK(pref_service_);
   const char* pref_name = GetPrefNameForDataType(type);
   if (!pref_name) {
     NOTREACHED();
     return;
@@ skipping 38 matching lines @@
     if (types.Has(i->first))
       types_with_groups.PutAll(i->second);
     else
       types_with_groups.RemoveAll(i->second);
   }
   types_with_groups.RetainAll(registered_types);
   return types_with_groups;
 }
 
 }  // namespace browser_sync