1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/browser/invalidation/invalidator_storage.h" 6 7#include "base/base64.h" 8#include "base/bind.h" 9#include "base/callback.h" 10#include "base/location.h" 11#include "base/logging.h" 12#include "base/metrics/histogram.h" 13#include "base/prefs/pref_service.h" 14#include "base/strings/string_number_conversions.h" 15#include "base/task_runner.h" 16#include "base/values.h" 17#include "chrome/common/pref_names.h" 18#include "components/user_prefs/pref_registry_syncable.h" 19#include "sync/internal_api/public/base/model_type.h" 20 21using syncer::InvalidationStateMap; 22 23namespace { 24 25const char kSourceKey[] = "source"; 26const char kNameKey[] = "name"; 27const char kMaxVersionKey[] = "max-version"; 28const char kPayloadKey[] = "payload"; 29const char kCurrentAckHandleKey[] = "current-ack"; 30const char kExpectedAckHandleKey[] = "expected-ack"; 31 32bool ValueToObjectIdAndState(const DictionaryValue& value, 33 invalidation::ObjectId* id, 34 syncer::InvalidationState* state) { 35 std::string source_str; 36 if (!value.GetString(kSourceKey, &source_str)) { 37 DLOG(WARNING) << "Unable to deserialize source"; 38 return false; 39 } 40 int source = 0; 41 if (!base::StringToInt(source_str, &source)) { 42 DLOG(WARNING) << "Invalid source: " << source_str; 43 return false; 44 } 45 std::string name; 46 if (!value.GetString(kNameKey, &name)) { 47 DLOG(WARNING) << "Unable to deserialize name"; 48 return false; 49 } 50 *id = invalidation::ObjectId(source, name); 51 std::string max_version_str; 52 if (!value.GetString(kMaxVersionKey, &max_version_str)) { 53 DLOG(WARNING) << "Unable to deserialize max version"; 54 return false; 55 } 56 if (!base::StringToInt64(max_version_str, &state->version)) { 57 DLOG(WARNING) << "Invalid max invalidation version: " << max_version_str; 58 return false; 59 } 60 value.GetString(kPayloadKey, &state->payload); 61 // The ack handle fields won't be set if upgrading from previous versions of 62 // Chrome. 63 const base::DictionaryValue* current_ack_handle_value = NULL; 64 if (value.GetDictionary(kCurrentAckHandleKey, ¤t_ack_handle_value)) { 65 state->current.ResetFromValue(*current_ack_handle_value); 66 } 67 const base::DictionaryValue* expected_ack_handle_value = NULL; 68 if (value.GetDictionary(kExpectedAckHandleKey, &expected_ack_handle_value)) { 69 state->expected.ResetFromValue(*expected_ack_handle_value); 70 } else { 71 // In this case, we should never have a valid current value set. 72 DCHECK(!state->current.IsValid()); 73 state->current = syncer::AckHandle::InvalidAckHandle(); 74 } 75 return true; 76} 77 78// The caller owns the returned value. 79DictionaryValue* ObjectIdAndStateToValue( 80 const invalidation::ObjectId& id, const syncer::InvalidationState& state) { 81 DictionaryValue* value = new DictionaryValue; 82 value->SetString(kSourceKey, base::IntToString(id.source())); 83 value->SetString(kNameKey, id.name()); 84 value->SetString(kMaxVersionKey, base::Int64ToString(state.version)); 85 value->SetString(kPayloadKey, state.payload); 86 if (state.current.IsValid()) 87 value->Set(kCurrentAckHandleKey, state.current.ToValue().release()); 88 if (state.expected.IsValid()) 89 value->Set(kExpectedAckHandleKey, state.expected.ToValue().release()); 90 return value; 91} 92 93} // namespace 94 95namespace invalidation { 96 97// static 98void InvalidatorStorage::RegisterProfilePrefs( 99 user_prefs::PrefRegistrySyncable* registry) { 100 registry->RegisterListPref(prefs::kInvalidatorMaxInvalidationVersions, 101 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 102 registry->RegisterStringPref( 103 prefs::kInvalidatorInvalidationState, 104 std::string(), 105 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 106 registry->RegisterStringPref( 107 prefs::kInvalidatorClientId, 108 std::string(), 109 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 110 registry->RegisterDictionaryPref( 111 prefs::kSyncMaxInvalidationVersions, 112 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 113} 114 115InvalidatorStorage::InvalidatorStorage(PrefService* pref_service) 116 : pref_service_(pref_service) { 117 // TODO(tim): Create a Mock instead of maintaining the if(!pref_service_) case 118 // throughout this file. This is a problem now due to lack of injection at 119 // ProfileSyncService. Bug 130176. 120 if (pref_service_) 121 MigrateMaxInvalidationVersionsPref(); 122} 123 124InvalidatorStorage::~InvalidatorStorage() { 125} 126 127InvalidationStateMap InvalidatorStorage::GetAllInvalidationStates() const { 128 DCHECK(thread_checker_.CalledOnValidThread()); 129 InvalidationStateMap state_map; 130 if (!pref_service_) { 131 return state_map; 132 } 133 const base::ListValue* state_map_list = 134 pref_service_->GetList(prefs::kInvalidatorMaxInvalidationVersions); 135 CHECK(state_map_list); 136 DeserializeFromList(*state_map_list, &state_map); 137 return state_map; 138} 139 140void InvalidatorStorage::SetMaxVersionAndPayload( 141 const invalidation::ObjectId& id, 142 int64 max_version, 143 const std::string& payload) { 144 DCHECK(thread_checker_.CalledOnValidThread()); 145 CHECK(pref_service_); 146 InvalidationStateMap state_map = GetAllInvalidationStates(); 147 InvalidationStateMap::iterator it = state_map.find(id); 148 if ((it != state_map.end()) && (max_version <= it->second.version)) { 149 NOTREACHED(); 150 return; 151 } 152 state_map[id].version = max_version; 153 state_map[id].payload = payload; 154 155 base::ListValue state_map_list; 156 SerializeToList(state_map, &state_map_list); 157 pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions, 158 state_map_list); 159} 160 161void InvalidatorStorage::Forget(const syncer::ObjectIdSet& ids) { 162 DCHECK(thread_checker_.CalledOnValidThread()); 163 CHECK(pref_service_); 164 InvalidationStateMap state_map = GetAllInvalidationStates(); 165 for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); 166 ++it) { 167 state_map.erase(*it); 168 } 169 170 base::ListValue state_map_list; 171 SerializeToList(state_map, &state_map_list); 172 pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions, 173 state_map_list); 174} 175 176// static 177void InvalidatorStorage::DeserializeFromList( 178 const base::ListValue& state_map_list, 179 InvalidationStateMap* state_map) { 180 state_map->clear(); 181 for (size_t i = 0; i < state_map_list.GetSize(); ++i) { 182 const DictionaryValue* value = NULL; 183 if (!state_map_list.GetDictionary(i, &value)) { 184 DLOG(WARNING) << "Unable to deserialize entry " << i; 185 continue; 186 } 187 invalidation::ObjectId id; 188 syncer::InvalidationState state; 189 if (!ValueToObjectIdAndState(*value, &id, &state)) { 190 DLOG(WARNING) << "Error while deserializing entry " << i; 191 continue; 192 } 193 (*state_map)[id] = state; 194 } 195} 196 197// static 198void InvalidatorStorage::SerializeToList( 199 const InvalidationStateMap& state_map, 200 base::ListValue* state_map_list) { 201 for (InvalidationStateMap::const_iterator it = state_map.begin(); 202 it != state_map.end(); ++it) { 203 state_map_list->Append(ObjectIdAndStateToValue(it->first, it->second)); 204 } 205} 206 207// Legacy migration code. 208void InvalidatorStorage::MigrateMaxInvalidationVersionsPref() { 209 const base::DictionaryValue* max_versions_dict = 210 pref_service_->GetDictionary(prefs::kSyncMaxInvalidationVersions); 211 CHECK(max_versions_dict); 212 if (!max_versions_dict->empty()) { 213 InvalidationStateMap state_map; 214 DeserializeMap(max_versions_dict, &state_map); 215 base::ListValue state_map_list; 216 SerializeToList(state_map, &state_map_list); 217 pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions, 218 state_map_list); 219 UMA_HISTOGRAM_BOOLEAN("InvalidatorStorage.MigrateInvalidationVersionsPref", 220 true); 221 } else { 222 UMA_HISTOGRAM_BOOLEAN("InvalidatorStorage.MigrateInvalidationVersionsPref", 223 false); 224 } 225 pref_service_->ClearPref(prefs::kSyncMaxInvalidationVersions); 226} 227 228// Legacy migration code. 229// static 230void InvalidatorStorage::DeserializeMap( 231 const base::DictionaryValue* max_versions_dict, 232 InvalidationStateMap* map) { 233 map->clear(); 234 // Convert from a string -> string DictionaryValue to a 235 // ModelType -> int64 map. 236 for (base::DictionaryValue::Iterator it(*max_versions_dict); !it.IsAtEnd(); 237 it.Advance()) { 238 int model_type_int = 0; 239 if (!base::StringToInt(it.key(), &model_type_int)) { 240 LOG(WARNING) << "Invalid model type key: " << it.key(); 241 continue; 242 } 243 if ((model_type_int < syncer::FIRST_REAL_MODEL_TYPE) || 244 (model_type_int >= syncer::MODEL_TYPE_COUNT)) { 245 LOG(WARNING) << "Out-of-range model type key: " << model_type_int; 246 continue; 247 } 248 const syncer::ModelType model_type = 249 syncer::ModelTypeFromInt(model_type_int); 250 std::string max_version_str; 251 CHECK(it.value().GetAsString(&max_version_str)); 252 int64 max_version = 0; 253 if (!base::StringToInt64(max_version_str, &max_version)) { 254 LOG(WARNING) << "Invalid max invalidation version for " 255 << syncer::ModelTypeToString(model_type) << ": " 256 << max_version_str; 257 continue; 258 } 259 invalidation::ObjectId id; 260 if (!syncer::RealModelTypeToObjectId(model_type, &id)) { 261 DLOG(WARNING) << "Invalid model type: " << model_type; 262 continue; 263 } 264 (*map)[id].version = max_version; 265 } 266} 267 268void InvalidatorStorage::SetInvalidatorClientId(const std::string& client_id) { 269 DCHECK(thread_checker_.CalledOnValidThread()); 270 Clear(); // We can't reuse our old invalidation state if the ID changes. 271 pref_service_->SetString(prefs::kInvalidatorClientId, client_id); 272} 273 274std::string InvalidatorStorage::GetInvalidatorClientId() const { 275 return pref_service_ ? 276 pref_service_->GetString(prefs::kInvalidatorClientId) : 277 std::string(); 278} 279 280void InvalidatorStorage::SetBootstrapData(const std::string& data) { 281 DCHECK(thread_checker_.CalledOnValidThread()); 282 std::string base64_data; 283 base::Base64Encode(data, &base64_data); 284 pref_service_->SetString(prefs::kInvalidatorInvalidationState, 285 base64_data); 286} 287 288std::string InvalidatorStorage::GetBootstrapData() const { 289 std::string base64_data( 290 pref_service_ 291 ? pref_service_->GetString(prefs::kInvalidatorInvalidationState) 292 : std::string()); 293 std::string data; 294 base::Base64Decode(base64_data, &data); 295 return data; 296} 297 298void InvalidatorStorage::Clear() { 299 DCHECK(thread_checker_.CalledOnValidThread()); 300 pref_service_->ClearPref(prefs::kInvalidatorMaxInvalidationVersions); 301 pref_service_->ClearPref(prefs::kInvalidatorClientId); 302 pref_service_->ClearPref(prefs::kInvalidatorInvalidationState); 303} 304 305void InvalidatorStorage::GenerateAckHandles( 306 const syncer::ObjectIdSet& ids, 307 const scoped_refptr<base::TaskRunner>& task_runner, 308 const base::Callback<void(const syncer::AckHandleMap&)> callback) { 309 DCHECK(thread_checker_.CalledOnValidThread()); 310 CHECK(pref_service_); 311 InvalidationStateMap state_map = GetAllInvalidationStates(); 312 313 syncer::AckHandleMap ack_handles; 314 for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); 315 ++it) { 316 state_map[*it].expected = syncer::AckHandle::CreateUnique(); 317 ack_handles.insert(std::make_pair(*it, state_map[*it].expected)); 318 } 319 320 base::ListValue state_map_list; 321 SerializeToList(state_map, &state_map_list); 322 pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions, 323 state_map_list); 324 325 ignore_result(task_runner->PostTask(FROM_HERE, 326 base::Bind(callback, ack_handles))); 327} 328 329void InvalidatorStorage::Acknowledge(const invalidation::ObjectId& id, 330 const syncer::AckHandle& ack_handle) { 331 DCHECK(thread_checker_.CalledOnValidThread()); 332 CHECK(pref_service_); 333 InvalidationStateMap state_map = GetAllInvalidationStates(); 334 335 InvalidationStateMap::iterator it = state_map.find(id); 336 // This could happen if the acknowledgement is delayed and Forget() has 337 // already been called. 338 if (it == state_map.end()) 339 return; 340 it->second.current = ack_handle; 341 342 base::ListValue state_map_list; 343 SerializeToList(state_map, &state_map_list); 344 pref_service_->Set(prefs::kInvalidatorMaxInvalidationVersions, 345 state_map_list); 346} 347 348} // namespace invalidation 349