| OLD | NEW |
|---|
| (Empty) |
| 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/prefs/pref_model_associator.h" | |
| 6 | |
| 7 #include "base/auto_reset.h" | |
| 8 #include "base/json/json_reader.h" | |
| 9 #include "base/json/json_string_value_serializer.h" | |
| 10 #include "base/location.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/prefs/pref_service.h" | |
| 13 #include "base/stl_util.h" | |
| 14 #include "base/strings/utf_string_conversions.h" | |
| 15 #include "base/values.h" | |
| 16 #include "chrome/browser/prefs/pref_model_associator_client.h" | |
| 17 #include "chrome/browser/prefs/pref_service_syncable.h" | |
| 18 #include "sync/api/sync_change.h" | |
| 19 #include "sync/api/sync_error_factory.h" | |
| 20 #include "sync/protocol/preference_specifics.pb.h" | |
| 21 #include "sync/protocol/sync.pb.h" | |
| 22 | |
| 23 using syncer::PREFERENCES; | |
| 24 using syncer::PRIORITY_PREFERENCES; | |
| 25 | |
| 26 namespace { | |
| 27 | |
| 28 const sync_pb::PreferenceSpecifics& GetSpecifics(const syncer::SyncData& pref) { | |
| 29 DCHECK(pref.GetDataType() == syncer::PREFERENCES || | |
| 30 pref.GetDataType() == syncer::PRIORITY_PREFERENCES); | |
| 31 if (pref.GetDataType() == syncer::PRIORITY_PREFERENCES) { | |
| 32 return pref.GetSpecifics().priority_preference().preference(); | |
| 33 } else { | |
| 34 return pref.GetSpecifics().preference(); | |
| 35 } | |
| 36 } | |
| 37 | |
| 38 sync_pb::PreferenceSpecifics* GetMutableSpecifics( | |
| 39 const syncer::ModelType type, | |
| 40 sync_pb::EntitySpecifics* specifics) { | |
| 41 if (type == syncer::PRIORITY_PREFERENCES) { | |
| 42 DCHECK(!specifics->has_preference()); | |
| 43 return specifics->mutable_priority_preference()->mutable_preference(); | |
| 44 } else { | |
| 45 DCHECK(!specifics->has_priority_preference()); | |
| 46 return specifics->mutable_preference(); | |
| 47 } | |
| 48 } | |
| 49 | |
| 50 } // namespace | |
| 51 | |
| 52 PrefModelAssociator::PrefModelAssociator( | |
| 53 const PrefModelAssociatorClient* client, | |
| 54 syncer::ModelType type) | |
| 55 : models_associated_(false), | |
| 56 processing_syncer_changes_(false), | |
| 57 pref_service_(NULL), | |
| 58 type_(type), | |
| 59 client_(client) { | |
| 60 DCHECK(CalledOnValidThread()); | |
| 61 DCHECK(type_ == PREFERENCES || type_ == PRIORITY_PREFERENCES); | |
| 62 } | |
| 63 | |
| 64 PrefModelAssociator::~PrefModelAssociator() { | |
| 65 DCHECK(CalledOnValidThread()); | |
| 66 pref_service_ = NULL; | |
| 67 | |
| 68 STLDeleteContainerPairSecondPointers(synced_pref_observers_.begin(), | |
| 69 synced_pref_observers_.end()); | |
| 70 synced_pref_observers_.clear(); | |
| 71 } | |
| 72 | |
| 73 void PrefModelAssociator::InitPrefAndAssociate( | |
| 74 const syncer::SyncData& sync_pref, | |
| 75 const std::string& pref_name, | |
| 76 syncer::SyncChangeList* sync_changes, | |
| 77 SyncDataMap* migrated_preference_list) { | |
| 78 const base::Value* user_pref_value = pref_service_->GetUserPrefValue( | |
| 79 pref_name.c_str()); | |
| 80 VLOG(1) << "Associating preference " << pref_name; | |
| 81 | |
| 82 if (sync_pref.IsValid()) { | |
| 83 const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref); | |
| 84 std::string old_pref_name; | |
| 85 DCHECK(pref_name == preference.name() || | |
| 86 (client_ && | |
| 87 client_->IsMigratedPreference(pref_name, &old_pref_name) && | |
| 88 preference.name() == old_pref_name)); | |
| 89 base::JSONReader reader; | |
| 90 scoped_ptr<base::Value> sync_value(reader.ReadToValue(preference.value())); | |
| 91 if (!sync_value.get()) { | |
| 92 LOG(ERROR) << "Failed to deserialize preference value: " | |
| 93 << reader.GetErrorMessage(); | |
| 94 return; | |
| 95 } | |
| 96 | |
| 97 if (user_pref_value) { | |
| 98 DVLOG(1) << "Found user pref value for " << pref_name; | |
| 99 // We have both server and local values. Merge them. | |
| 100 scoped_ptr<base::Value> new_value( | |
| 101 MergePreference(pref_name, *user_pref_value, *sync_value)); | |
| 102 | |
| 103 // Update the local preference based on what we got from the | |
| 104 // sync server. Note: this only updates the user value store, which is | |
| 105 // ignored if the preference is policy controlled. | |
| 106 if (new_value->IsType(base::Value::TYPE_NULL)) { | |
| 107 LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str(); | |
| 108 pref_service_->ClearPref(pref_name.c_str()); | |
| 109 } else if (!new_value->IsType(user_pref_value->GetType())) { | |
| 110 LOG(WARNING) << "Synced value for " << preference.name() | |
| 111 << " is of type " << new_value->GetType() | |
| 112 << " which doesn't match pref type " | |
| 113 << user_pref_value->GetType(); | |
| 114 } else if (!user_pref_value->Equals(new_value.get())) { | |
| 115 pref_service_->Set(pref_name.c_str(), *new_value); | |
| 116 } | |
| 117 | |
| 118 // If the merge resulted in an updated value, inform the syncer. | |
| 119 if (!sync_value->Equals(new_value.get())) { | |
| 120 syncer::SyncData sync_data; | |
| 121 if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) { | |
| 122 LOG(ERROR) << "Failed to update preference."; | |
| 123 return; | |
| 124 } | |
| 125 | |
| 126 std::string old_pref_name; | |
| 127 if (client_ && | |
| 128 client_->IsMigratedPreference(pref_name, &old_pref_name)) { | |
| 129 // This preference has been migrated from an old version that must be | |
| 130 // kept in sync on older versions of Chrome. | |
| 131 if (preference.name() == old_pref_name) { | |
| 132 DCHECK(migrated_preference_list); | |
| 133 // If the name the syncer has is the old pre-migration value, then | |
| 134 // it's possible the new migrated preference name hasn't been synced | |
| 135 // yet. In that case the SyncChange should be an ACTION_ADD rather | |
| 136 // than an ACTION_UPDATE. Defer the decision of whether to sync with | |
| 137 // ACTION_ADD or ACTION_UPDATE until the migrated_preferences phase. | |
| 138 if (migrated_preference_list) | |
| 139 (*migrated_preference_list)[pref_name] = sync_data; | |
| 140 } else { | |
| 141 DCHECK_EQ(preference.name(), pref_name); | |
| 142 sync_changes->push_back( | |
| 143 syncer::SyncChange(FROM_HERE, | |
| 144 syncer::SyncChange::ACTION_UPDATE, | |
| 145 sync_data)); | |
| 146 } | |
| 147 | |
| 148 syncer::SyncData old_sync_data; | |
| 149 if (!CreatePrefSyncData(old_pref_name, *new_value, &old_sync_data)) { | |
| 150 LOG(ERROR) << "Failed to update preference."; | |
| 151 return; | |
| 152 } | |
| 153 if (migrated_preference_list) | |
| 154 (*migrated_preference_list)[old_pref_name] = old_sync_data; | |
| 155 } else { | |
| 156 sync_changes->push_back( | |
| 157 syncer::SyncChange(FROM_HERE, | |
| 158 syncer::SyncChange::ACTION_UPDATE, | |
| 159 sync_data)); | |
| 160 } | |
| 161 } | |
| 162 } else if (!sync_value->IsType(base::Value::TYPE_NULL)) { | |
| 163 // Only a server value exists. Just set the local user value. | |
| 164 pref_service_->Set(pref_name.c_str(), *sync_value); | |
| 165 } else { | |
| 166 LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str(); | |
| 167 } | |
| 168 synced_preferences_.insert(preference.name()); | |
| 169 } else if (user_pref_value) { | |
| 170 // The server does not know about this preference and should be added | |
| 171 // to the syncer's database. | |
| 172 syncer::SyncData sync_data; | |
| 173 if (!CreatePrefSyncData(pref_name, *user_pref_value, &sync_data)) { | |
| 174 LOG(ERROR) << "Failed to update preference."; | |
| 175 return; | |
| 176 } | |
| 177 sync_changes->push_back( | |
| 178 syncer::SyncChange(FROM_HERE, | |
| 179 syncer::SyncChange::ACTION_ADD, | |
| 180 sync_data)); | |
| 181 synced_preferences_.insert(pref_name); | |
| 182 } | |
| 183 | |
| 184 // Else this pref does not have a sync value but also does not have a user | |
| 185 // controlled value (either it's a default value or it's policy controlled, | |
| 186 // either way it's not interesting). We can ignore it. Once it gets changed, | |
| 187 // we'll send the new user controlled value to the syncer. | |
| 188 } | |
| 189 | |
| 190 syncer::SyncMergeResult PrefModelAssociator::MergeDataAndStartSyncing( | |
| 191 syncer::ModelType type, | |
| 192 const syncer::SyncDataList& initial_sync_data, | |
| 193 scoped_ptr<syncer::SyncChangeProcessor> sync_processor, | |
| 194 scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) { | |
| 195 DCHECK_EQ(type_, type); | |
| 196 DCHECK(CalledOnValidThread()); | |
| 197 DCHECK(pref_service_); | |
| 198 DCHECK(!sync_processor_.get()); | |
| 199 DCHECK(sync_processor.get()); | |
| 200 DCHECK(sync_error_factory.get()); | |
| 201 syncer::SyncMergeResult merge_result(type); | |
| 202 sync_processor_ = sync_processor.Pass(); | |
| 203 sync_error_factory_ = sync_error_factory.Pass(); | |
| 204 | |
| 205 syncer::SyncChangeList new_changes; | |
| 206 std::set<std::string> remaining_preferences = registered_preferences_; | |
| 207 | |
| 208 // Maintains a list of old migrated preference names that we wish to sync. | |
| 209 // Keep track of these in a list such that when the preference iteration | |
| 210 // loops below are complete we can go back and determine whether | |
| 211 SyncDataMap migrated_preference_list; | |
| 212 | |
| 213 // Go through and check for all preferences we care about that sync already | |
| 214 // knows about. | |
| 215 for (syncer::SyncDataList::const_iterator sync_iter = | |
| 216 initial_sync_data.begin(); | |
| 217 sync_iter != initial_sync_data.end(); | |
| 218 ++sync_iter) { | |
| 219 DCHECK_EQ(type_, sync_iter->GetDataType()); | |
| 220 | |
| 221 const sync_pb::PreferenceSpecifics& preference = GetSpecifics(*sync_iter); | |
| 222 std::string sync_pref_name = preference.name(); | |
| 223 | |
| 224 if (remaining_preferences.count(sync_pref_name) == 0) { | |
| 225 std::string new_pref_name; | |
| 226 if (client_ && | |
| 227 client_->IsOldMigratedPreference(sync_pref_name, &new_pref_name)) { | |
| 228 // This old pref name is not syncable locally anymore but we accept | |
| 229 // changes from other Chrome installs of previous versions and migrate | |
| 230 // them to the new name. Note that we will be merging any differences | |
| 231 // between the new and old values and sync'ing them back. | |
| 232 sync_pref_name = new_pref_name; | |
| 233 } else { | |
| 234 // We're not syncing this preference locally, ignore the sync data. | |
| 235 // TODO(zea): Eventually we want to be able to have the syncable service | |
| 236 // reconstruct all sync data for its datatype (therefore having | |
| 237 // GetAllSyncData be a complete representation). We should store this | |
| 238 // data somewhere, even if we don't use it. | |
| 239 continue; | |
| 240 } | |
| 241 } else { | |
| 242 remaining_preferences.erase(sync_pref_name); | |
| 243 } | |
| 244 InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes, | |
| 245 &migrated_preference_list); | |
| 246 } | |
| 247 | |
| 248 // Go through and build sync data for any remaining preferences. | |
| 249 for (std::set<std::string>::iterator pref_name_iter = | |
| 250 remaining_preferences.begin(); | |
| 251 pref_name_iter != remaining_preferences.end(); | |
| 252 ++pref_name_iter) { | |
| 253 InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes, | |
| 254 &migrated_preference_list); | |
| 255 } | |
| 256 | |
| 257 // Now go over any migrated preference names and build sync data for them too. | |
| 258 for (SyncDataMap::const_iterator migrated_pref_iter = | |
| 259 migrated_preference_list.begin(); | |
| 260 migrated_pref_iter != migrated_preference_list.end(); | |
| 261 ++migrated_pref_iter) { | |
| 262 syncer::SyncChange::SyncChangeType change_type = | |
| 263 (synced_preferences_.count(migrated_pref_iter->first) == 0) ? | |
| 264 syncer::SyncChange::ACTION_ADD : | |
| 265 syncer::SyncChange::ACTION_UPDATE; | |
| 266 new_changes.push_back( | |
| 267 syncer::SyncChange(FROM_HERE, change_type, migrated_pref_iter->second)); | |
| 268 synced_preferences_.insert(migrated_pref_iter->first); | |
| 269 } | |
| 270 | |
| 271 // Push updates to sync. | |
| 272 merge_result.set_error( | |
| 273 sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes)); | |
| 274 if (merge_result.error().IsSet()) | |
| 275 return merge_result; | |
| 276 | |
| 277 models_associated_ = true; | |
| 278 pref_service_->OnIsSyncingChanged(); | |
| 279 return merge_result; | |
| 280 } | |
| 281 | |
| 282 void PrefModelAssociator::StopSyncing(syncer::ModelType type) { | |
| 283 DCHECK_EQ(type_, type); | |
| 284 models_associated_ = false; | |
| 285 sync_processor_.reset(); | |
| 286 sync_error_factory_.reset(); | |
| 287 pref_service_->OnIsSyncingChanged(); | |
| 288 } | |
| 289 | |
| 290 scoped_ptr<base::Value> PrefModelAssociator::MergePreference( | |
| 291 const std::string& name, | |
| 292 const base::Value& local_value, | |
| 293 const base::Value& server_value) { | |
| 294 // This function special cases preferences individually, so don't attempt | |
| 295 // to merge for all migrated values. | |
| 296 if (client_) { | |
| 297 std::string new_pref_name; | |
| 298 DCHECK(!client_->IsOldMigratedPreference(name, &new_pref_name)); | |
| 299 if (client_->IsMergeableListPreference(name)) | |
| 300 return make_scoped_ptr(MergeListValues(local_value, server_value)); | |
| 301 if (client_->IsMergeableDictionaryPreference(name)) | |
| 302 return make_scoped_ptr(MergeDictionaryValues(local_value, server_value)); | |
| 303 } | |
| 304 | |
| 305 // If this is not a specially handled preference, server wins. | |
| 306 return make_scoped_ptr(server_value.DeepCopy()); | |
| 307 } | |
| 308 | |
| 309 bool PrefModelAssociator::CreatePrefSyncData( | |
| 310 const std::string& name, | |
| 311 const base::Value& value, | |
| 312 syncer::SyncData* sync_data) const { | |
| 313 if (value.IsType(base::Value::TYPE_NULL)) { | |
| 314 LOG(ERROR) << "Attempting to sync a null pref value for " << name; | |
| 315 return false; | |
| 316 } | |
| 317 | |
| 318 std::string serialized; | |
| 319 // TODO(zea): consider JSONWriter::Write since you don't have to check | |
| 320 // failures to deserialize. | |
| 321 JSONStringValueSerializer json(&serialized); | |
| 322 if (!json.Serialize(value)) { | |
| 323 LOG(ERROR) << "Failed to serialize preference value."; | |
| 324 return false; | |
| 325 } | |
| 326 | |
| 327 sync_pb::EntitySpecifics specifics; | |
| 328 sync_pb::PreferenceSpecifics* pref_specifics = | |
| 329 GetMutableSpecifics(type_, &specifics); | |
| 330 | |
| 331 pref_specifics->set_name(name); | |
| 332 pref_specifics->set_value(serialized); | |
| 333 *sync_data = syncer::SyncData::CreateLocalData(name, name, specifics); | |
| 334 return true; | |
| 335 } | |
| 336 | |
| 337 base::Value* PrefModelAssociator::MergeListValues(const base::Value& from_value, | |
| 338 const base::Value& to_value) { | |
| 339 if (from_value.GetType() == base::Value::TYPE_NULL) | |
| 340 return to_value.DeepCopy(); | |
| 341 if (to_value.GetType() == base::Value::TYPE_NULL) | |
| 342 return from_value.DeepCopy(); | |
| 343 | |
| 344 DCHECK(from_value.GetType() == base::Value::TYPE_LIST); | |
| 345 DCHECK(to_value.GetType() == base::Value::TYPE_LIST); | |
| 346 const base::ListValue& from_list_value = | |
| 347 static_cast<const base::ListValue&>(from_value); | |
| 348 const base::ListValue& to_list_value = | |
| 349 static_cast<const base::ListValue&>(to_value); | |
| 350 base::ListValue* result = to_list_value.DeepCopy(); | |
| 351 | |
| 352 for (base::ListValue::const_iterator i = from_list_value.begin(); | |
| 353 i != from_list_value.end(); ++i) { | |
| 354 base::Value* value = (*i)->DeepCopy(); | |
| 355 result->AppendIfNotPresent(value); | |
| 356 } | |
| 357 return result; | |
| 358 } | |
| 359 | |
| 360 base::Value* PrefModelAssociator::MergeDictionaryValues( | |
| 361 const base::Value& from_value, | |
| 362 const base::Value& to_value) { | |
| 363 if (from_value.GetType() == base::Value::TYPE_NULL) | |
| 364 return to_value.DeepCopy(); | |
| 365 if (to_value.GetType() == base::Value::TYPE_NULL) | |
| 366 return from_value.DeepCopy(); | |
| 367 | |
| 368 DCHECK_EQ(from_value.GetType(), base::Value::TYPE_DICTIONARY); | |
| 369 DCHECK_EQ(to_value.GetType(), base::Value::TYPE_DICTIONARY); | |
| 370 const base::DictionaryValue& from_dict_value = | |
| 371 static_cast<const base::DictionaryValue&>(from_value); | |
| 372 const base::DictionaryValue& to_dict_value = | |
| 373 static_cast<const base::DictionaryValue&>(to_value); | |
| 374 base::DictionaryValue* result = to_dict_value.DeepCopy(); | |
| 375 | |
| 376 for (base::DictionaryValue::Iterator it(from_dict_value); !it.IsAtEnd(); | |
| 377 it.Advance()) { | |
| 378 const base::Value* from_key_value = &it.value(); | |
| 379 base::Value* to_key_value; | |
| 380 if (result->GetWithoutPathExpansion(it.key(), &to_key_value)) { | |
| 381 if (from_key_value->GetType() == base::Value::TYPE_DICTIONARY && | |
| 382 to_key_value->GetType() == base::Value::TYPE_DICTIONARY) { | |
| 383 base::Value* merged_value = | |
| 384 MergeDictionaryValues(*from_key_value, *to_key_value); | |
| 385 result->SetWithoutPathExpansion(it.key(), merged_value); | |
| 386 } | |
| 387 // Note that for all other types we want to preserve the "to" | |
| 388 // values so we do nothing here. | |
| 389 } else { | |
| 390 result->SetWithoutPathExpansion(it.key(), from_key_value->DeepCopy()); | |
| 391 } | |
| 392 } | |
| 393 return result; | |
| 394 } | |
| 395 | |
| 396 // Note: This will build a model of all preferences registered as syncable | |
| 397 // with user controlled data. We do not track any information for preferences | |
| 398 // not registered locally as syncable and do not inform the syncer of | |
| 399 // non-user controlled preferences. | |
| 400 syncer::SyncDataList PrefModelAssociator::GetAllSyncData( | |
| 401 syncer::ModelType type) | |
| 402 const { | |
| 403 DCHECK_EQ(type_, type); | |
| 404 syncer::SyncDataList current_data; | |
| 405 for (PreferenceSet::const_iterator iter = synced_preferences_.begin(); | |
| 406 iter != synced_preferences_.end(); | |
| 407 ++iter) { | |
| 408 std::string name = *iter; | |
| 409 const PrefService::Preference* pref = | |
| 410 pref_service_->FindPreference(name.c_str()); | |
| 411 DCHECK(pref); | |
| 412 if (!pref->IsUserControlled() || pref->IsDefaultValue()) | |
| 413 continue; // This is not data we care about. | |
| 414 // TODO(zea): plumb a way to read the user controlled value. | |
| 415 syncer::SyncData sync_data; | |
| 416 if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data)) | |
| 417 continue; | |
| 418 current_data.push_back(sync_data); | |
| 419 } | |
| 420 return current_data; | |
| 421 } | |
| 422 | |
| 423 syncer::SyncError PrefModelAssociator::ProcessSyncChanges( | |
| 424 const tracked_objects::Location& from_here, | |
| 425 const syncer::SyncChangeList& change_list) { | |
| 426 if (!models_associated_) { | |
| 427 syncer::SyncError error(FROM_HERE, | |
| 428 syncer::SyncError::DATATYPE_ERROR, | |
| 429 "Models not yet associated.", | |
| 430 PREFERENCES); | |
| 431 return error; | |
| 432 } | |
| 433 base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true); | |
| 434 syncer::SyncChangeList::const_iterator iter; | |
| 435 for (iter = change_list.begin(); iter != change_list.end(); ++iter) { | |
| 436 DCHECK_EQ(type_, iter->sync_data().GetDataType()); | |
| 437 | |
| 438 const sync_pb::PreferenceSpecifics& pref_specifics = | |
| 439 GetSpecifics(iter->sync_data()); | |
| 440 | |
| 441 std::string name = pref_specifics.name(); | |
| 442 // It is possible that we may receive a change to a preference we do not | |
| 443 // want to sync. For example if the user is syncing a Mac client and a | |
| 444 // Windows client, the Windows client does not support | |
| 445 // kConfirmToQuitEnabled. Ignore updates from these preferences. | |
| 446 std::string pref_name = pref_specifics.name(); | |
| 447 std::string new_pref_name; | |
| 448 // We migrated this preference name, so do as if the name had not changed. | |
| 449 if (client_ && client_->IsOldMigratedPreference(name, &new_pref_name)) { | |
| 450 pref_name = new_pref_name; | |
| 451 } | |
| 452 | |
| 453 if (!IsPrefRegistered(pref_name.c_str())) | |
| 454 continue; | |
| 455 | |
| 456 if (iter->change_type() == syncer::SyncChange::ACTION_DELETE) { | |
| 457 pref_service_->ClearPref(pref_name); | |
| 458 continue; | |
| 459 } | |
| 460 | |
| 461 scoped_ptr<base::Value> value(ReadPreferenceSpecifics(pref_specifics)); | |
| 462 if (!value.get()) { | |
| 463 // Skip values we can't deserialize. | |
| 464 // TODO(zea): consider taking some further action such as erasing the bad | |
| 465 // data. | |
| 466 continue; | |
| 467 } | |
| 468 | |
| 469 // This will only modify the user controlled value store, which takes | |
| 470 // priority over the default value but is ignored if the preference is | |
| 471 // policy controlled. | |
| 472 pref_service_->Set(pref_name, *value); | |
| 473 | |
| 474 NotifySyncedPrefObservers(pref_specifics.name(), true /*from_sync*/); | |
| 475 | |
| 476 // Keep track of any newly synced preferences. | |
| 477 if (iter->change_type() == syncer::SyncChange::ACTION_ADD) { | |
| 478 synced_preferences_.insert(pref_specifics.name()); | |
| 479 } | |
| 480 } | |
| 481 return syncer::SyncError(); | |
| 482 } | |
| 483 | |
| 484 base::Value* PrefModelAssociator::ReadPreferenceSpecifics( | |
| 485 const sync_pb::PreferenceSpecifics& preference) { | |
| 486 base::JSONReader reader; | |
| 487 scoped_ptr<base::Value> value(reader.ReadToValue(preference.value())); | |
| 488 if (!value.get()) { | |
| 489 std::string err = "Failed to deserialize preference value: " + | |
| 490 reader.GetErrorMessage(); | |
| 491 LOG(ERROR) << err; | |
| 492 return NULL; | |
| 493 } | |
| 494 return value.release(); | |
| 495 } | |
| 496 | |
| 497 bool PrefModelAssociator::IsPrefSynced(const std::string& name) const { | |
| 498 return synced_preferences_.find(name) != synced_preferences_.end(); | |
| 499 } | |
| 500 | |
| 501 void PrefModelAssociator::AddSyncedPrefObserver(const std::string& name, | |
| 502 SyncedPrefObserver* observer) { | |
| 503 SyncedPrefObserverList* observers = synced_pref_observers_[name]; | |
| 504 if (observers == NULL) { | |
| 505 observers = new SyncedPrefObserverList; | |
| 506 synced_pref_observers_[name] = observers; | |
| 507 } | |
| 508 observers->AddObserver(observer); | |
| 509 } | |
| 510 | |
| 511 void PrefModelAssociator::RemoveSyncedPrefObserver(const std::string& name, | |
| 512 SyncedPrefObserver* observer) { | |
| 513 SyncedPrefObserverMap::iterator observer_iter = | |
| 514 synced_pref_observers_.find(name); | |
| 515 if (observer_iter == synced_pref_observers_.end()) | |
| 516 return; | |
| 517 SyncedPrefObserverList* observers = observer_iter->second; | |
| 518 observers->RemoveObserver(observer); | |
| 519 } | |
| 520 | |
| 521 void PrefModelAssociator::SetPrefModelAssociatorClientForTesting( | |
| 522 const PrefModelAssociatorClient* client) { | |
| 523 DCHECK(!client_); | |
| 524 client_ = client; | |
| 525 } | |
| 526 | |
| 527 std::set<std::string> PrefModelAssociator::registered_preferences() const { | |
| 528 return registered_preferences_; | |
| 529 } | |
| 530 | |
| 531 void PrefModelAssociator::RegisterPref(const char* name) { | |
| 532 DCHECK(!models_associated_ && registered_preferences_.count(name) == 0); | |
| 533 registered_preferences_.insert(name); | |
| 534 } | |
| 535 | |
| 536 bool PrefModelAssociator::IsPrefRegistered(const char* name) { | |
| 537 return registered_preferences_.count(name) > 0; | |
| 538 } | |
| 539 | |
| 540 void PrefModelAssociator::ProcessPrefChange(const std::string& name) { | |
| 541 if (processing_syncer_changes_) | |
| 542 return; // These are changes originating from us, ignore. | |
| 543 | |
| 544 // We only process changes if we've already associated models. | |
| 545 if (!models_associated_) | |
| 546 return; | |
| 547 | |
| 548 const PrefService::Preference* preference = | |
| 549 pref_service_->FindPreference(name.c_str()); | |
| 550 if (!preference) | |
| 551 return; | |
| 552 | |
| 553 if (!IsPrefRegistered(name.c_str())) | |
| 554 return; // We are not syncing this preference. | |
| 555 | |
| 556 syncer::SyncChangeList changes; | |
| 557 | |
| 558 if (!preference->IsUserModifiable()) { | |
| 559 // If the preference is no longer user modifiable, it must now be controlled | |
| 560 // by policy, whose values we do not sync. Just return. If the preference | |
| 561 // stops being controlled by policy, it will revert back to the user value | |
| 562 // (which we continue to update with sync changes). | |
| 563 return; | |
| 564 } | |
| 565 | |
| 566 base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true); | |
| 567 | |
| 568 NotifySyncedPrefObservers(name, false /*from_sync*/); | |
| 569 | |
| 570 if (synced_preferences_.count(name) == 0) { | |
| 571 // Not in synced_preferences_ means no synced data. InitPrefAndAssociate(..) | |
| 572 // will determine if we care about its data (e.g. if it has a default value | |
| 573 // and hasn't been changed yet we don't) and take care syncing any new data. | |
| 574 InitPrefAndAssociate(syncer::SyncData(), name, &changes, NULL); | |
| 575 } else { | |
| 576 // We are already syncing this preference, just update it's sync node. | |
| 577 syncer::SyncData sync_data; | |
| 578 if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) { | |
| 579 LOG(ERROR) << "Failed to update preference."; | |
| 580 return; | |
| 581 } | |
| 582 changes.push_back( | |
| 583 syncer::SyncChange(FROM_HERE, | |
| 584 syncer::SyncChange::ACTION_UPDATE, | |
| 585 sync_data)); | |
| 586 // This preference has been migrated from an old version that must be kept | |
| 587 // in sync on older versions of Chrome. | |
| 588 std::string old_pref_name; | |
| 589 if (client_ && client_->IsMigratedPreference(name, &old_pref_name)) { | |
| 590 if (!CreatePrefSyncData(old_pref_name, | |
| 591 *preference->GetValue(), | |
| 592 &sync_data)) { | |
| 593 LOG(ERROR) << "Failed to update preference."; | |
| 594 return; | |
| 595 } | |
| 596 | |
| 597 syncer::SyncChange::SyncChangeType change_type = | |
| 598 (synced_preferences_.count(old_pref_name) == 0) ? | |
| 599 syncer::SyncChange::ACTION_ADD : | |
| 600 syncer::SyncChange::ACTION_UPDATE; | |
| 601 changes.push_back( | |
| 602 syncer::SyncChange(FROM_HERE, change_type, sync_data)); | |
| 603 } | |
| 604 } | |
| 605 | |
| 606 syncer::SyncError error = | |
| 607 sync_processor_->ProcessSyncChanges(FROM_HERE, changes); | |
| 608 } | |
| 609 | |
| 610 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) { | |
| 611 DCHECK(pref_service_ == NULL); | |
| 612 pref_service_ = pref_service; | |
| 613 } | |
| 614 | |
| 615 void PrefModelAssociator::NotifySyncedPrefObservers(const std::string& path, | |
| 616 bool from_sync) const { | |
| 617 SyncedPrefObserverMap::const_iterator observer_iter = | |
| 618 synced_pref_observers_.find(path); | |
| 619 if (observer_iter == synced_pref_observers_.end()) | |
| 620 return; | |
| 621 SyncedPrefObserverList* observers = observer_iter->second; | |
| 622 FOR_EACH_OBSERVER(SyncedPrefObserver, *observers, | |
| 623 OnSyncedPrefChanged(path, from_sync)); | |
| 624 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1305213009:
Componentize PrefSyncableService and support classes. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@pref_service_syncable