Implement new invalidations ack tracking system

chrome/browser/invalidation/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/invalidation/invalidator_storage.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
 #include "base/values.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
-#include "sync/internal_api/public/base/model_type.h"
-
-using syncer::InvalidationStateMap;
 
 namespace {
 
-const char kSourceKey[] = "source";
-const char kNameKey[] = "name";
-const char kMaxVersionKey[] = "max-version";
-const char kPayloadKey[] = "payload";
-const char kCurrentAckHandleKey[] = "current-ack";
-const char kExpectedAckHandleKey[] = "expected-ack";
+const char kInvalidatorMaxInvalidationVersions[] =
+    "invalidator.max_invalidation_versions";
 
-bool ValueToObjectIdAndState(const DictionaryValue& value,
-                             invalidation::ObjectId* id,
-                             syncer::InvalidationState* state) {
-  std::string source_str;
-  if (!value.GetString(kSourceKey, &source_str)) {
-    DLOG(WARNING) << "Unable to deserialize source";
-    return false;
-  }
-  int source = 0;
-  if (!base::StringToInt(source_str, &source)) {
-    DLOG(WARNING) << "Invalid source: " << source_str;
-    return false;
-  }
-  std::string name;
-  if (!value.GetString(kNameKey, &name)) {
-    DLOG(WARNING) << "Unable to deserialize name";
-    return false;
-  }
-  *id = invalidation::ObjectId(source, name);
-  std::string max_version_str;
-  if (!value.GetString(kMaxVersionKey, &max_version_str)) {
-    DLOG(WARNING) << "Unable to deserialize max version";
-    return false;
-  }
-  if (!base::StringToInt64(max_version_str, &state->version)) {
-    DLOG(WARNING) << "Invalid max invalidation version: " << max_version_str;
-    return false;
-  }
-  value.GetString(kPayloadKey, &state->payload);
-  // The ack handle fields won't be set if upgrading from previous versions of
-  // Chrome.
-  const base::DictionaryValue* current_ack_handle_value = NULL;
-  if (value.GetDictionary(kCurrentAckHandleKey, &current_ack_handle_value)) {
-    state->current.ResetFromValue(*current_ack_handle_value);
-  }
-  const base::DictionaryValue* expected_ack_handle_value = NULL;
-  if (value.GetDictionary(kExpectedAckHandleKey, &expected_ack_handle_value)) {
-    state->expected.ResetFromValue(*expected_ack_handle_value);
-  } else {
-    // In this case, we should never have a valid current value set.
-    DCHECK(!state->current.IsValid());
-    state->current = syncer::AckHandle::InvalidAckHandle();
+
+bool ValueToUnackedInvalidationStorageMap(
+    const ListValue& value,
+    syncer::UnackedInvalidationsMap* map) {
+  for (size_t i = 0; i != value.GetSize(); ++i) {
+    invalidation::ObjectId invalid_id;
+    syncer::UnackedInvalidationSet storage(invalid_id);
+    const base::DictionaryValue* dict;
+    if (!value.GetDictionary(i, &dict) || !storage.ResetFromValue(*dict)) {
+      DLOG(WARNING) << "Failed to parse ObjectState at position " << i;
+      return false;
+    }
+    map->insert(std::make_pair(storage.object_id(), storage));
   }
   return true;
 }
 
-// The caller owns the returned value.
-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(state.version));
-  value->SetString(kPayloadKey, state.payload);
-  if (state.current.IsValid())
-    value->Set(kCurrentAckHandleKey, state.current.ToValue().release());
-  if (state.expected.IsValid())
-    value->Set(kExpectedAckHandleKey, state.expected.ToValue().release());
-  return value;
+scoped_ptr<base::ListValue> UnackedInvalidationStorageMapToValue(
+    const syncer::UnackedInvalidationsMap& map) {
+  scoped_ptr<base::ListValue> value(new base::ListValue);
+  for (syncer::UnackedInvalidationsMap::const_iterator it = map.begin();
+       it != map.end(); ++it) {
+    value->Append(it->second.ToValue().release());
+  }
+  return value.Pass();
 }
 
 }  // namespace
 
 namespace invalidation {
 
 // static
 void InvalidatorStorage::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
-  registry->RegisterListPref(prefs::kInvalidatorMaxInvalidationVersions,
+  registry->RegisterListPref(prefs::kInvalidatorSavedInvalidations,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       prefs::kInvalidatorInvalidationState,
       std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       prefs::kInvalidatorClientId,
       std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterDictionaryPref(
-      prefs::kSyncMaxInvalidationVersions,
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+
+  // This pref is obsolete.  We register it so we can clear it.
+  // At some point in the future, it will be safe to remove this.
+  registry->RegisterListPref(kInvalidatorMaxInvalidationVersions,
+                             user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 InvalidatorStorage::InvalidatorStorage(PrefService* pref_service)
     : pref_service_(pref_service) {
   DCHECK(pref_service);
-  MigrateMaxInvalidationVersionsPref();
+  pref_service_->ClearPref(kInvalidatorMaxInvalidationVersions);
 }
 
 InvalidatorStorage::~InvalidatorStorage() {
 }
 
-InvalidationStateMap InvalidatorStorage::GetAllInvalidationStates() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationStateMap state_map;
-  const base::ListValue* state_map_list =
-      pref_service_->GetList(prefs::kInvalidatorMaxInvalidationVersions);
-  CHECK(state_map_list);
-  DeserializeFromList(*state_map_list, &state_map);
-  return state_map;
-}
-
-void InvalidatorStorage::SetMaxVersionAndPayload(
-    const invalidation::ObjectId& id,
-    int64 max_version,
-    const std::string& payload) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationStateMap state_map = GetAllInvalidationStates();
-  InvalidationStateMap::iterator it = state_map.find(id);
-  if ((it != state_map.end()) && (max_version <= it->second.version)) {
-    NOTREACHED();
-    return;
-  }
-  state_map[id].version = max_version;
-  state_map[id].payload = payload;
-
-  base::ListValue state_map_list;
-  SerializeToList(state_map, &state_map_list);
-  pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                     state_map_list);
-}
-
-void InvalidatorStorage::Forget(const syncer::ObjectIdSet& ids) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationStateMap state_map = GetAllInvalidationStates();
-  for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
-       ++it) {
-    state_map.erase(*it);
-  }
-
-  base::ListValue state_map_list;
-  SerializeToList(state_map, &state_map_list);
-  pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                     state_map_list);
-}
-
-// static
-void InvalidatorStorage::DeserializeFromList(
-    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 (!state_map_list.GetDictionary(i, &value)) {
-      DLOG(WARNING) << "Unable to deserialize entry " << i;
-      continue;
-    }
-    invalidation::ObjectId id;
-    syncer::InvalidationState state;
-    if (!ValueToObjectIdAndState(*value, &id, &state)) {
-      DLOG(WARNING) << "Error while deserializing entry " << i;
-      continue;
-    }
-    (*state_map)[id] = state;
-  }
-}
-
-// static
-void InvalidatorStorage::SerializeToList(
-    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() {
-  const base::DictionaryValue* max_versions_dict =
-      pref_service_->GetDictionary(prefs::kSyncMaxInvalidationVersions);
-  CHECK(max_versions_dict);
-  if (!max_versions_dict->empty()) {
-    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,
-                       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,
-    InvalidationStateMap* map) {
-  map->clear();
-  // Convert from a string -> string DictionaryValue to a
-  // ModelType -> int64 map.
-  for (base::DictionaryValue::Iterator it(*max_versions_dict); !it.IsAtEnd();
-       it.Advance()) {
-    int model_type_int = 0;
-    if (!base::StringToInt(it.key(), &model_type_int)) {
-      LOG(WARNING) << "Invalid model type key: " << it.key();
-      continue;
-    }
-    if ((model_type_int < syncer::FIRST_REAL_MODEL_TYPE) ||
-        (model_type_int >= syncer::MODEL_TYPE_COUNT)) {
-      LOG(WARNING) << "Out-of-range model type key: " << model_type_int;
-      continue;
-    }
-    const syncer::ModelType model_type =
-        syncer::ModelTypeFromInt(model_type_int);
-    std::string max_version_str;
-    CHECK(it.value().GetAsString(&max_version_str));
-    int64 max_version = 0;
-    if (!base::StringToInt64(max_version_str, &max_version)) {
-      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].version = max_version;
-  }
-}
-
 void InvalidatorStorage::SetInvalidatorClientId(const std::string& client_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   Clear();  // We can't reuse our old invalidation state if the ID changes.
   pref_service_->SetString(prefs::kInvalidatorClientId, client_id);
 }
 
 std::string InvalidatorStorage::GetInvalidatorClientId() const {
   return pref_service_->GetString(prefs::kInvalidatorClientId);
 }
 
 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_->GetString(prefs::kInvalidatorInvalidationState));
   std::string data;
   base::Base64Decode(base64_data, &data);
   return data;
 }
 
+void InvalidatorStorage::SetSavedInvalidations(
+      const syncer::UnackedInvalidationsMap& map) {
+  scoped_ptr<base::ListValue> value(UnackedInvalidationStorageMapToValue(map));
+  pref_service_->Set(prefs::kInvalidatorSavedInvalidations, *value.get());
+}
+
+syncer::UnackedInvalidationsMap
+InvalidatorStorage::GetSavedInvalidations() const {
+  syncer::UnackedInvalidationsMap map;
+  const base::ListValue* value =
+      pref_service_->GetList(prefs::kInvalidatorSavedInvalidations);
+  if (!ValueToUnackedInvalidationStorageMap(*value, &map)) {
+    return syncer::UnackedInvalidationsMap();
+  } else {
+    return map;
+  }
+}
+
 void InvalidatorStorage::Clear() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  pref_service_->ClearPref(prefs::kInvalidatorMaxInvalidationVersions);
+  pref_service_->ClearPref(prefs::kInvalidatorSavedInvalidations);
   pref_service_->ClearPref(prefs::kInvalidatorClientId);
   pref_service_->ClearPref(prefs::kInvalidatorInvalidationState);
 }
 
-void InvalidatorStorage::GenerateAckHandles(
-    const syncer::ObjectIdSet& ids,
-    const scoped_refptr<base::TaskRunner>& task_runner,
-    const base::Callback<void(const syncer::AckHandleMap&)> callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationStateMap state_map = GetAllInvalidationStates();
-
-  syncer::AckHandleMap ack_handles;
-  for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
-       ++it) {
-    state_map[*it].expected = syncer::AckHandle::CreateUnique();
-    ack_handles.insert(std::make_pair(*it, state_map[*it].expected));
-  }
-
-  base::ListValue state_map_list;
-  SerializeToList(state_map, &state_map_list);
-  pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                     state_map_list);
-
-  ignore_result(task_runner->PostTask(FROM_HERE,
-                                      base::Bind(callback, ack_handles)));
-}
-
-void InvalidatorStorage::Acknowledge(const invalidation::ObjectId& id,
-                                     const syncer::AckHandle& ack_handle) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationStateMap state_map = GetAllInvalidationStates();
-
-  InvalidationStateMap::iterator it = state_map.find(id);
-  // This could happen if the acknowledgement is delayed and Forget() has
-  // already been called.
-  if (it == state_map.end())
-    return;
-  it->second.current = ack_handle;
-
-  base::ListValue state_map_list;
-  SerializeToList(state_map, &state_map_list);
-  pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions,
-                     state_map_list);
-}
-
 }  // namespace invalidation