Add the InvalidationState struct to bundle local state about invalidations.

chrome/browser/sync/invalidations/invalidator_storage.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/invalidations/invalidator_storage.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "sync/internal_api/public/base/model_type.h"
 
-using syncer::InvalidationVersionMap;
+using syncer::InvalidationStateMap;
 
 namespace browser_sync {
 
 namespace {
 
 const char kSourceKey[] = "source";
 const char kNameKey[] = "name";
 const char kMaxVersionKey[] = "max-version";
 
-bool ValueToObjectIdAndVersion(const DictionaryValue& value,
-                               invalidation::ObjectId* id,
-                               int64* max_version) {
+bool ValueToObjectIdAndState(const DictionaryValue& value,
+                             invalidation::ObjectId* id,
+                             syncer::InvalidationState* state) {
   std::string source_str;
   int source = 0;
   std::string name;
   std::string max_version_str;
   if (!value.GetString(kSourceKey, &source_str)) {
     DLOG(WARNING) << "Unable to deserialize source";
     return false;
   }
   if (!value.GetString(kNameKey, &name)) {
     DLOG(WARNING) << "Unable to deserialize name";
     return false;
   }
   if (!value.GetString(kMaxVersionKey, &max_version_str)) {
     DLOG(WARNING) << "Unable to deserialize max version";
     return false;
   }
   if (!base::StringToInt(source_str, &source)) {
     DLOG(WARNING) << "Invalid source: " << source_str;
     return false;
   }
-  if (!base::StringToInt64(max_version_str, max_version)) {
+  if (!base::StringToInt64(max_version_str, &state->version)) {
     DLOG(WARNING) << "Invalid max invalidation version: " << max_version_str;
     return false;
   }
   *id = invalidation::ObjectId(source, name);
   return true;
 }
 
 // The caller owns the returned value.
-DictionaryValue* ObjectIdAndVersionToValue(const invalidation::ObjectId& id,
-                                           int64 max_version) {
+DictionaryValue* ObjectIdAndStateToValue(
+    const invalidation::ObjectId& id, const syncer::InvalidationState& state) {
   DictionaryValue* value = new DictionaryValue;
   value->SetString(kSourceKey, base::IntToString(id.source()));
   value->SetString(kNameKey, id.name());
-  value->SetString(kMaxVersionKey, base::Int64ToString(max_version));
+  value->SetString(kMaxVersionKey, base::Int64ToString(state.version));
   return value;
 }
 
 }  // namespace
 
 InvalidatorStorage::InvalidatorStorage(PrefService* pref_service)
     : pref_service_(pref_service) {
   // 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_) {
     pref_service_->RegisterListPref(prefs::kInvalidatorMaxInvalidationVersions,
                                     PrefService::UNSYNCABLE_PREF);
     pref_service_->RegisterStringPref(prefs::kInvalidatorInvalidationState,
                                       std::string(),
                                       PrefService::UNSYNCABLE_PREF);
 
     MigrateMaxInvalidationVersionsPref();
   }
 }
 
 InvalidatorStorage::~InvalidatorStorage() {
 }
 
-InvalidationVersionMap InvalidatorStorage::GetAllMaxVersions() const {
+InvalidationStateMap InvalidatorStorage::GetAllInvalidationStates() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationVersionMap max_versions;
+  InvalidationStateMap state_map;
   if (!pref_service_) {
-    return max_versions;
+    return state_map;
   }
-  const base::ListValue* max_versions_list =
+  const base::ListValue* state_map_list =
       pref_service_->GetList(prefs::kInvalidatorMaxInvalidationVersions);
-  CHECK(max_versions_list);
-  DeserializeFromList(*max_versions_list, &max_versions);
-  return max_versions;
+  CHECK(state_map_list);
+  DeserializeFromList(*state_map_list, &state_map);
+  return state_map;
 }
 
 void InvalidatorStorage::SetMaxVersion(const invalidation::ObjectId& id,
                                        int64 max_version) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(pref_service_);
-  InvalidationVersionMap max_versions = GetAllMaxVersions();
-  InvalidationVersionMap::iterator it = max_versions.find(id);
-  if ((it != max_versions.end()) && (max_version <= it->second)) {
+  InvalidationStateMap state_map = GetAllInvalidationStates();
+  InvalidationStateMap::iterator it = state_map.find(id);
+  if ((it != state_map.end()) && (max_version <= it->second.version)) {
     NOTREACHED();
     return;
   }
-  max_versions[id] = max_version;
+  state_map[id].version = max_version;
 
-  base::ListValue max_versions_list;
-  SerializeToList(max_versions, &max_versions_list);
+  base::ListValue state_map_list;
+  SerializeToList(state_map, &state_map_list);
   pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                     max_versions_list);
+                     state_map_list);
 }
 
 void InvalidatorStorage::Forget(const syncer::ObjectIdSet& ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(pref_service_);
-  InvalidationVersionMap max_versions = GetAllMaxVersions();
+  InvalidationStateMap state_map = GetAllInvalidationStates();
   for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
        ++it) {
-    max_versions.erase(*it);
+    state_map.erase(*it);
   }
 
-  base::ListValue max_versions_list;
-  SerializeToList(max_versions, &max_versions_list);
+  base::ListValue state_map_list;
+  SerializeToList(state_map, &state_map_list);
   pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                     max_versions_list);
+                     state_map_list);
 }
 
 // static
 void InvalidatorStorage::DeserializeFromList(
-    const base::ListValue& max_versions_list,
-    InvalidationVersionMap* max_versions_map) {
-  max_versions_map->clear();
-  for (size_t i = 0; i < max_versions_list.GetSize(); ++i) {
+    const base::ListValue& state_map_list,
+    InvalidationStateMap* state_map) {
+  state_map->clear();
+  for (size_t i = 0; i < state_map_list.GetSize(); ++i) {
     const DictionaryValue* value = NULL;
-    if (!max_versions_list.GetDictionary(i, &value)) {
+    if (!state_map_list.GetDictionary(i, &value)) {
       DLOG(WARNING) << "Unable to deserialize entry " << i;
       continue;
     }
     invalidation::ObjectId id;
-    int64 max_version = 0;
-    if (!ValueToObjectIdAndVersion(*value, &id, &max_version)) {
+    syncer::InvalidationState state;
+    if (!ValueToObjectIdAndState(*value, &id, &state)) {
       DLOG(WARNING) << "Error while deserializing entry " << i;
       continue;
     }
-    (*max_versions_map)[id] = max_version;
+    (*state_map)[id] = state;
   }
 }
 
 // static
 void InvalidatorStorage::SerializeToList(
-    const InvalidationVersionMap& max_versions_map,
-    base::ListValue* max_versions_list) {
-  for (InvalidationVersionMap::const_iterator it = max_versions_map.begin();
-       it != max_versions_map.end(); ++it) {
-    max_versions_list->Append(ObjectIdAndVersionToValue(it->first, it->second));
+    const InvalidationStateMap& state_map,
+    base::ListValue* state_map_list) {
+  for (InvalidationStateMap::const_iterator it = state_map.begin();
+       it != state_map.end(); ++it) {
+    state_map_list->Append(ObjectIdAndStateToValue(it->first, it->second));
   }
 }
 
 // Legacy migration code.
 void InvalidatorStorage::MigrateMaxInvalidationVersionsPref() {
   pref_service_->RegisterDictionaryPref(prefs::kSyncMaxInvalidationVersions,
                                         PrefService::UNSYNCABLE_PREF);
   const base::DictionaryValue* max_versions_dict =
       pref_service_->GetDictionary(prefs::kSyncMaxInvalidationVersions);
   CHECK(max_versions_dict);
   if (!max_versions_dict->empty()) {
-    InvalidationVersionMap max_versions;
-    DeserializeMap(max_versions_dict, &max_versions);
-    base::ListValue max_versions_list;
-    SerializeToList(max_versions, &max_versions_list);
+    InvalidationStateMap state_map;
+    DeserializeMap(max_versions_dict, &state_map);
+    base::ListValue state_map_list;
+    SerializeToList(state_map, &state_map_list);
     pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                       max_versions_list);
+                       state_map_list);
     UMA_HISTOGRAM_BOOLEAN("InvalidatorStorage.MigrateInvalidationVersionsPref",
                           true);
   } else {
     UMA_HISTOGRAM_BOOLEAN("InvalidatorStorage.MigrateInvalidationVersionsPref",
                           false);
   }
   pref_service_->ClearPref(prefs::kSyncMaxInvalidationVersions);
 }
 
 // Legacy migration code.
 // static
 void InvalidatorStorage::DeserializeMap(
     const base::DictionaryValue* max_versions_dict,
-    InvalidationVersionMap* map) {
+    InvalidationStateMap* map) {
   map->clear();
   // Convert from a string -> string DictionaryValue to a
   // ModelType -> int64 map.
   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;
@@ skipping 12 matching lines @@
       LOG(WARNING) << "Invalid max invalidation version for "
                    << syncer::ModelTypeToString(model_type) << ": "
                    << max_version_str;
       continue;
     }
     invalidation::ObjectId id;
     if (!syncer::RealModelTypeToObjectId(model_type, &id)) {
       DLOG(WARNING) << "Invalid model type: " << model_type;
       continue;
     }
-    (*map)[id] = max_version;
+    (*map)[id].version = max_version;
   }
 }
 
 void InvalidatorStorage::SetBootstrapData(const std::string& data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::string base64_data;
   base::Base64Encode(data, &base64_data);
   pref_service_->SetString(prefs::kInvalidatorInvalidationState,
                            base64_data);
 }
 
 std::string InvalidatorStorage::GetBootstrapData() const {
   std::string base64_data(pref_service_ ?
       pref_service_->GetString(prefs::kInvalidatorInvalidationState) : "");
   std::string data;
   base::Base64Decode(base64_data, &data);
   return data;
 }
 
 void InvalidatorStorage::Clear() {
   DCHECK(thread_checker_.CalledOnValidThread());
   pref_service_->ClearPref(prefs::kInvalidatorMaxInvalidationVersions);
   pref_service_->ClearPref(prefs::kInvalidatorInvalidationState);
 }
 
 }  // namespace browser_sync