Commit InvalidationService implementations

chrome/browser/sync/invalidations/invalidator_storage.cc

Index: chrome/browser/sync/invalidations/invalidator_storage.cc
diff --git a/chrome/browser/sync/invalidations/invalidator_storage.cc b/chrome/browser/sync/invalidations/invalidator_storage.cc
deleted file mode 100644
index ab3b5a6e071c90c2a09e02dcc5bf25f40fd7ada6..0000000000000000000000000000000000000000
--- a/chrome/browser/sync/invalidations/invalidator_storage.cc
+++ /dev/null
@@ -1,348 +0,0 @@
-// 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/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 browser_sync {
-
-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";
-
-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();
-  }
-  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;
-}
-
-}  // namespace
-
-// static
-void InvalidatorStorage::RegisterUserPrefs(
-    user_prefs::PrefRegistrySyncable* registry) {
-  registry->RegisterListPref(prefs::kInvalidatorMaxInvalidationVersions,
-                             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);
-}
-
-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_)
-    MigrateMaxInvalidationVersionsPref();
-}
-
-InvalidatorStorage::~InvalidatorStorage() {
-}
-
-InvalidationStateMap InvalidatorStorage::GetAllInvalidationStates() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  InvalidationStateMap state_map;
-  if (!pref_service_) {
-    return 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());
-  CHECK(pref_service_);
-  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());
-  CHECK(pref_service_);
-  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_ ?
-      pref_service_->GetString(prefs::kInvalidatorClientId) :
-          std::string();
-}
-
-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());
-  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::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());
-  CHECK(pref_service_);
-  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());
-  CHECK(pref_service_);
-  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 browser_sync