OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/syncable_prefs/pref_model_associator.h" | 5 #include "components/sync_preferences/pref_model_associator.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/auto_reset.h" | 9 #include "base/auto_reset.h" |
10 #include "base/json/json_reader.h" | 10 #include "base/json/json_reader.h" |
11 #include "base/json/json_string_value_serializer.h" | 11 #include "base/json/json_string_value_serializer.h" |
12 #include "base/location.h" | 12 #include "base/location.h" |
13 #include "base/logging.h" | 13 #include "base/logging.h" |
14 #include "base/memory/ptr_util.h" | 14 #include "base/memory/ptr_util.h" |
15 #include "base/strings/utf_string_conversions.h" | 15 #include "base/strings/utf_string_conversions.h" |
16 #include "base/values.h" | 16 #include "base/values.h" |
17 #include "components/prefs/pref_service.h" | 17 #include "components/prefs/pref_service.h" |
18 #include "components/sync/model/sync_change.h" | 18 #include "components/sync/model/sync_change.h" |
19 #include "components/sync/model/sync_error_factory.h" | 19 #include "components/sync/model/sync_error_factory.h" |
20 #include "components/sync/protocol/preference_specifics.pb.h" | 20 #include "components/sync/protocol/preference_specifics.pb.h" |
21 #include "components/sync/protocol/sync.pb.h" | 21 #include "components/sync/protocol/sync.pb.h" |
22 #include "components/syncable_prefs/pref_model_associator_client.h" | 22 #include "components/sync_preferences/pref_model_associator_client.h" |
23 #include "components/syncable_prefs/pref_service_syncable.h" | 23 #include "components/sync_preferences/pref_service_syncable.h" |
24 | 24 |
25 using syncer::PREFERENCES; | 25 using syncer::PREFERENCES; |
26 using syncer::PRIORITY_PREFERENCES; | 26 using syncer::PRIORITY_PREFERENCES; |
27 | 27 |
28 namespace syncable_prefs { | 28 namespace sync_preferences { |
29 | 29 |
30 namespace { | 30 namespace { |
31 | 31 |
32 const sync_pb::PreferenceSpecifics& GetSpecifics(const syncer::SyncData& pref) { | 32 const sync_pb::PreferenceSpecifics& GetSpecifics(const syncer::SyncData& pref) { |
33 DCHECK(pref.GetDataType() == syncer::PREFERENCES || | 33 DCHECK(pref.GetDataType() == syncer::PREFERENCES || |
34 pref.GetDataType() == syncer::PRIORITY_PREFERENCES); | 34 pref.GetDataType() == syncer::PRIORITY_PREFERENCES); |
35 if (pref.GetDataType() == syncer::PRIORITY_PREFERENCES) { | 35 if (pref.GetDataType() == syncer::PRIORITY_PREFERENCES) { |
36 return pref.GetSpecifics().priority_preference().preference(); | 36 return pref.GetSpecifics().priority_preference().preference(); |
37 } else { | 37 } else { |
38 return pref.GetSpecifics().preference(); | 38 return pref.GetSpecifics().preference(); |
(...skipping 30 matching lines...) Expand all Loading... |
69 DCHECK(CalledOnValidThread()); | 69 DCHECK(CalledOnValidThread()); |
70 pref_service_ = NULL; | 70 pref_service_ = NULL; |
71 | 71 |
72 synced_pref_observers_.clear(); | 72 synced_pref_observers_.clear(); |
73 } | 73 } |
74 | 74 |
75 void PrefModelAssociator::InitPrefAndAssociate( | 75 void PrefModelAssociator::InitPrefAndAssociate( |
76 const syncer::SyncData& sync_pref, | 76 const syncer::SyncData& sync_pref, |
77 const std::string& pref_name, | 77 const std::string& pref_name, |
78 syncer::SyncChangeList* sync_changes) { | 78 syncer::SyncChangeList* sync_changes) { |
79 const base::Value* user_pref_value = pref_service_->GetUserPrefValue( | 79 const base::Value* user_pref_value = |
80 pref_name.c_str()); | 80 pref_service_->GetUserPrefValue(pref_name.c_str()); |
81 VLOG(1) << "Associating preference " << pref_name; | 81 VLOG(1) << "Associating preference " << pref_name; |
82 | 82 |
83 if (sync_pref.IsValid()) { | 83 if (sync_pref.IsValid()) { |
84 const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref); | 84 const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref); |
85 DCHECK(pref_name == preference.name()); | 85 DCHECK(pref_name == preference.name()); |
86 base::JSONReader reader; | 86 base::JSONReader reader; |
87 std::unique_ptr<base::Value> sync_value( | 87 std::unique_ptr<base::Value> sync_value( |
88 reader.ReadToValue(preference.value())); | 88 reader.ReadToValue(preference.value())); |
89 if (!sync_value.get()) { | 89 if (!sync_value.get()) { |
90 LOG(ERROR) << "Failed to deserialize preference value: " | 90 LOG(ERROR) << "Failed to deserialize preference value: " |
(...skipping 23 matching lines...) Expand all Loading... |
114 } | 114 } |
115 | 115 |
116 // If the merge resulted in an updated value, inform the syncer. | 116 // If the merge resulted in an updated value, inform the syncer. |
117 if (!sync_value->Equals(new_value.get())) { | 117 if (!sync_value->Equals(new_value.get())) { |
118 syncer::SyncData sync_data; | 118 syncer::SyncData sync_data; |
119 if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) { | 119 if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) { |
120 LOG(ERROR) << "Failed to update preference."; | 120 LOG(ERROR) << "Failed to update preference."; |
121 return; | 121 return; |
122 } | 122 } |
123 | 123 |
124 sync_changes->push_back( | 124 sync_changes->push_back(syncer::SyncChange( |
125 syncer::SyncChange(FROM_HERE, | 125 FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data)); |
126 syncer::SyncChange::ACTION_UPDATE, | |
127 sync_data)); | |
128 } | 126 } |
129 } else if (!sync_value->IsType(base::Value::TYPE_NULL)) { | 127 } else if (!sync_value->IsType(base::Value::TYPE_NULL)) { |
130 // Only a server value exists. Just set the local user value. | 128 // Only a server value exists. Just set the local user value. |
131 pref_service_->Set(pref_name.c_str(), *sync_value); | 129 pref_service_->Set(pref_name.c_str(), *sync_value); |
132 } else { | 130 } else { |
133 LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str(); | 131 LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str(); |
134 } | 132 } |
135 synced_preferences_.insert(preference.name()); | 133 synced_preferences_.insert(preference.name()); |
136 } else if (user_pref_value) { | 134 } else if (user_pref_value) { |
137 // The server does not know about this preference and should be added | 135 // The server does not know about this preference and should be added |
138 // to the syncer's database. | 136 // to the syncer's database. |
139 syncer::SyncData sync_data; | 137 syncer::SyncData sync_data; |
140 if (!CreatePrefSyncData(pref_name, *user_pref_value, &sync_data)) { | 138 if (!CreatePrefSyncData(pref_name, *user_pref_value, &sync_data)) { |
141 LOG(ERROR) << "Failed to update preference."; | 139 LOG(ERROR) << "Failed to update preference."; |
142 return; | 140 return; |
143 } | 141 } |
144 sync_changes->push_back( | 142 sync_changes->push_back(syncer::SyncChange( |
145 syncer::SyncChange(FROM_HERE, | 143 FROM_HERE, syncer::SyncChange::ACTION_ADD, sync_data)); |
146 syncer::SyncChange::ACTION_ADD, | |
147 sync_data)); | |
148 synced_preferences_.insert(pref_name); | 144 synced_preferences_.insert(pref_name); |
149 } | 145 } |
150 | 146 |
151 // Else this pref does not have a sync value but also does not have a user | 147 // Else this pref does not have a sync value but also does not have a user |
152 // controlled value (either it's a default value or it's policy controlled, | 148 // controlled value (either it's a default value or it's policy controlled, |
153 // either way it's not interesting). We can ignore it. Once it gets changed, | 149 // either way it's not interesting). We can ignore it. Once it gets changed, |
154 // we'll send the new user controlled value to the syncer. | 150 // we'll send the new user controlled value to the syncer. |
155 } | 151 } |
156 | 152 |
157 void PrefModelAssociator::RegisterMergeDataFinishedCallback( | 153 void PrefModelAssociator::RegisterMergeDataFinishedCallback( |
(...skipping 19 matching lines...) Expand all Loading... |
177 sync_processor_ = std::move(sync_processor); | 173 sync_processor_ = std::move(sync_processor); |
178 sync_error_factory_ = std::move(sync_error_factory); | 174 sync_error_factory_ = std::move(sync_error_factory); |
179 | 175 |
180 syncer::SyncChangeList new_changes; | 176 syncer::SyncChangeList new_changes; |
181 std::set<std::string> remaining_preferences = registered_preferences_; | 177 std::set<std::string> remaining_preferences = registered_preferences_; |
182 | 178 |
183 // Go through and check for all preferences we care about that sync already | 179 // Go through and check for all preferences we care about that sync already |
184 // knows about. | 180 // knows about. |
185 for (syncer::SyncDataList::const_iterator sync_iter = | 181 for (syncer::SyncDataList::const_iterator sync_iter = |
186 initial_sync_data.begin(); | 182 initial_sync_data.begin(); |
187 sync_iter != initial_sync_data.end(); | 183 sync_iter != initial_sync_data.end(); ++sync_iter) { |
188 ++sync_iter) { | |
189 DCHECK_EQ(type_, sync_iter->GetDataType()); | 184 DCHECK_EQ(type_, sync_iter->GetDataType()); |
190 | 185 |
191 const sync_pb::PreferenceSpecifics& preference = GetSpecifics(*sync_iter); | 186 const sync_pb::PreferenceSpecifics& preference = GetSpecifics(*sync_iter); |
192 std::string sync_pref_name = preference.name(); | 187 std::string sync_pref_name = preference.name(); |
193 | 188 |
194 if (remaining_preferences.count(sync_pref_name) == 0) { | 189 if (remaining_preferences.count(sync_pref_name) == 0) { |
195 // We're not syncing this preference locally, ignore the sync data. | 190 // We're not syncing this preference locally, ignore the sync data. |
196 // TODO(zea): Eventually we want to be able to have the syncable service | 191 // TODO(zea): Eventually we want to be able to have the syncable service |
197 // reconstruct all sync data for its datatype (therefore having | 192 // reconstruct all sync data for its datatype (therefore having |
198 // GetAllSyncData be a complete representation). We should store this | 193 // GetAllSyncData be a complete representation). We should store this |
199 // data somewhere, even if we don't use it. | 194 // data somewhere, even if we don't use it. |
200 continue; | 195 continue; |
201 } | 196 } |
202 | 197 |
203 remaining_preferences.erase(sync_pref_name); | 198 remaining_preferences.erase(sync_pref_name); |
204 InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes); | 199 InitPrefAndAssociate(*sync_iter, sync_pref_name, &new_changes); |
205 } | 200 } |
206 | 201 |
207 // Go through and build sync data for any remaining preferences. | 202 // Go through and build sync data for any remaining preferences. |
208 for (std::set<std::string>::iterator pref_name_iter = | 203 for (std::set<std::string>::iterator pref_name_iter = |
209 remaining_preferences.begin(); | 204 remaining_preferences.begin(); |
210 pref_name_iter != remaining_preferences.end(); | 205 pref_name_iter != remaining_preferences.end(); ++pref_name_iter) { |
211 ++pref_name_iter) { | |
212 InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes); | 206 InitPrefAndAssociate(syncer::SyncData(), *pref_name_iter, &new_changes); |
213 } | 207 } |
214 | 208 |
215 // Push updates to sync. | 209 // Push updates to sync. |
216 merge_result.set_error( | 210 merge_result.set_error( |
217 sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes)); | 211 sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes)); |
218 if (merge_result.error().IsSet()) | 212 if (merge_result.error().IsSet()) |
219 return merge_result; | 213 return merge_result; |
220 | 214 |
221 for (const auto& callback : callback_list_) | 215 for (const auto& callback : callback_list_) |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
336 } | 330 } |
337 } | 331 } |
338 return result; | 332 return result; |
339 } | 333 } |
340 | 334 |
341 // Note: This will build a model of all preferences registered as syncable | 335 // Note: This will build a model of all preferences registered as syncable |
342 // with user controlled data. We do not track any information for preferences | 336 // with user controlled data. We do not track any information for preferences |
343 // not registered locally as syncable and do not inform the syncer of | 337 // not registered locally as syncable and do not inform the syncer of |
344 // non-user controlled preferences. | 338 // non-user controlled preferences. |
345 syncer::SyncDataList PrefModelAssociator::GetAllSyncData( | 339 syncer::SyncDataList PrefModelAssociator::GetAllSyncData( |
346 syncer::ModelType type) | 340 syncer::ModelType type) const { |
347 const { | |
348 DCHECK_EQ(type_, type); | 341 DCHECK_EQ(type_, type); |
349 syncer::SyncDataList current_data; | 342 syncer::SyncDataList current_data; |
350 for (PreferenceSet::const_iterator iter = synced_preferences_.begin(); | 343 for (PreferenceSet::const_iterator iter = synced_preferences_.begin(); |
351 iter != synced_preferences_.end(); | 344 iter != synced_preferences_.end(); ++iter) { |
352 ++iter) { | |
353 std::string name = *iter; | 345 std::string name = *iter; |
354 const PrefService::Preference* pref = | 346 const PrefService::Preference* pref = |
355 pref_service_->FindPreference(name.c_str()); | 347 pref_service_->FindPreference(name.c_str()); |
356 DCHECK(pref); | 348 DCHECK(pref); |
357 if (!pref->IsUserControlled() || pref->IsDefaultValue()) | 349 if (!pref->IsUserControlled() || pref->IsDefaultValue()) |
358 continue; // This is not data we care about. | 350 continue; // This is not data we care about. |
359 // TODO(zea): plumb a way to read the user controlled value. | 351 // TODO(zea): plumb a way to read the user controlled value. |
360 syncer::SyncData sync_data; | 352 syncer::SyncData sync_data; |
361 if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data)) | 353 if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data)) |
362 continue; | 354 continue; |
363 current_data.push_back(sync_data); | 355 current_data.push_back(sync_data); |
364 } | 356 } |
365 return current_data; | 357 return current_data; |
366 } | 358 } |
367 | 359 |
368 syncer::SyncError PrefModelAssociator::ProcessSyncChanges( | 360 syncer::SyncError PrefModelAssociator::ProcessSyncChanges( |
369 const tracked_objects::Location& from_here, | 361 const tracked_objects::Location& from_here, |
370 const syncer::SyncChangeList& change_list) { | 362 const syncer::SyncChangeList& change_list) { |
371 if (!models_associated_) { | 363 if (!models_associated_) { |
372 syncer::SyncError error(FROM_HERE, | 364 syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
373 syncer::SyncError::DATATYPE_ERROR, | 365 "Models not yet associated.", PREFERENCES); |
374 "Models not yet associated.", | |
375 PREFERENCES); | |
376 return error; | 366 return error; |
377 } | 367 } |
378 base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true); | 368 base::AutoReset<bool> processing_changes(&processing_syncer_changes_, true); |
379 syncer::SyncChangeList::const_iterator iter; | 369 syncer::SyncChangeList::const_iterator iter; |
380 for (iter = change_list.begin(); iter != change_list.end(); ++iter) { | 370 for (iter = change_list.begin(); iter != change_list.end(); ++iter) { |
381 DCHECK_EQ(type_, iter->sync_data().GetDataType()); | 371 DCHECK_EQ(type_, iter->sync_data().GetDataType()); |
382 | 372 |
383 const sync_pb::PreferenceSpecifics& pref_specifics = | 373 const sync_pb::PreferenceSpecifics& pref_specifics = |
384 GetSpecifics(iter->sync_data()); | 374 GetSpecifics(iter->sync_data()); |
385 | 375 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
418 } | 408 } |
419 } | 409 } |
420 return syncer::SyncError(); | 410 return syncer::SyncError(); |
421 } | 411 } |
422 | 412 |
423 base::Value* PrefModelAssociator::ReadPreferenceSpecifics( | 413 base::Value* PrefModelAssociator::ReadPreferenceSpecifics( |
424 const sync_pb::PreferenceSpecifics& preference) { | 414 const sync_pb::PreferenceSpecifics& preference) { |
425 base::JSONReader reader; | 415 base::JSONReader reader; |
426 std::unique_ptr<base::Value> value(reader.ReadToValue(preference.value())); | 416 std::unique_ptr<base::Value> value(reader.ReadToValue(preference.value())); |
427 if (!value.get()) { | 417 if (!value.get()) { |
428 std::string err = "Failed to deserialize preference value: " + | 418 std::string err = |
429 reader.GetErrorMessage(); | 419 "Failed to deserialize preference value: " + reader.GetErrorMessage(); |
430 LOG(ERROR) << err; | 420 LOG(ERROR) << err; |
431 return NULL; | 421 return NULL; |
432 } | 422 } |
433 return value.release(); | 423 return value.release(); |
434 } | 424 } |
435 | 425 |
436 bool PrefModelAssociator::IsPrefSynced(const std::string& name) const { | 426 bool PrefModelAssociator::IsPrefSynced(const std::string& name) const { |
437 return synced_preferences_.find(name) != synced_preferences_.end(); | 427 return synced_preferences_.find(name) != synced_preferences_.end(); |
438 } | 428 } |
439 | 429 |
440 void PrefModelAssociator::AddSyncedPrefObserver(const std::string& name, | 430 void PrefModelAssociator::AddSyncedPrefObserver(const std::string& name, |
441 SyncedPrefObserver* observer) { | 431 SyncedPrefObserver* observer) { |
442 std::unique_ptr<SyncedPrefObserverList>& observers = | 432 std::unique_ptr<SyncedPrefObserverList>& observers = |
443 synced_pref_observers_[name]; | 433 synced_pref_observers_[name]; |
444 if (!observers) | 434 if (!observers) |
445 observers = base::MakeUnique<SyncedPrefObserverList>(); | 435 observers = base::MakeUnique<SyncedPrefObserverList>(); |
446 | 436 |
447 observers->AddObserver(observer); | 437 observers->AddObserver(observer); |
448 } | 438 } |
449 | 439 |
450 void PrefModelAssociator::RemoveSyncedPrefObserver(const std::string& name, | 440 void PrefModelAssociator::RemoveSyncedPrefObserver( |
| 441 const std::string& name, |
451 SyncedPrefObserver* observer) { | 442 SyncedPrefObserver* observer) { |
452 auto observer_iter = synced_pref_observers_.find(name); | 443 auto observer_iter = synced_pref_observers_.find(name); |
453 if (observer_iter == synced_pref_observers_.end()) | 444 if (observer_iter == synced_pref_observers_.end()) |
454 return; | 445 return; |
455 SyncedPrefObserverList* observers = observer_iter->second.get(); | 446 SyncedPrefObserverList* observers = observer_iter->second.get(); |
456 observers->RemoveObserver(observer); | 447 observers->RemoveObserver(observer); |
457 } | 448 } |
458 | 449 |
459 void PrefModelAssociator::SetPrefModelAssociatorClientForTesting( | 450 void PrefModelAssociator::SetPrefModelAssociatorClientForTesting( |
460 const PrefModelAssociatorClient* client) { | 451 const PrefModelAssociatorClient* client) { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
510 // will determine if we care about its data (e.g. if it has a default value | 501 // will determine if we care about its data (e.g. if it has a default value |
511 // and hasn't been changed yet we don't) and take care syncing any new data. | 502 // and hasn't been changed yet we don't) and take care syncing any new data. |
512 InitPrefAndAssociate(syncer::SyncData(), name, &changes); | 503 InitPrefAndAssociate(syncer::SyncData(), name, &changes); |
513 } else { | 504 } else { |
514 // We are already syncing this preference, just update it's sync node. | 505 // We are already syncing this preference, just update it's sync node. |
515 syncer::SyncData sync_data; | 506 syncer::SyncData sync_data; |
516 if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) { | 507 if (!CreatePrefSyncData(name, *preference->GetValue(), &sync_data)) { |
517 LOG(ERROR) << "Failed to update preference."; | 508 LOG(ERROR) << "Failed to update preference."; |
518 return; | 509 return; |
519 } | 510 } |
520 changes.push_back( | 511 changes.push_back(syncer::SyncChange( |
521 syncer::SyncChange(FROM_HERE, | 512 FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data)); |
522 syncer::SyncChange::ACTION_UPDATE, | |
523 sync_data)); | |
524 } | 513 } |
525 | 514 |
526 syncer::SyncError error = | 515 syncer::SyncError error = |
527 sync_processor_->ProcessSyncChanges(FROM_HERE, changes); | 516 sync_processor_->ProcessSyncChanges(FROM_HERE, changes); |
528 } | 517 } |
529 | 518 |
530 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) { | 519 void PrefModelAssociator::SetPrefService(PrefServiceSyncable* pref_service) { |
531 DCHECK(pref_service_ == NULL); | 520 DCHECK(pref_service_ == NULL); |
532 pref_service_ = pref_service; | 521 pref_service_ = pref_service; |
533 } | 522 } |
534 | 523 |
535 void PrefModelAssociator::NotifySyncedPrefObservers(const std::string& path, | 524 void PrefModelAssociator::NotifySyncedPrefObservers(const std::string& path, |
536 bool from_sync) const { | 525 bool from_sync) const { |
537 auto observer_iter = synced_pref_observers_.find(path); | 526 auto observer_iter = synced_pref_observers_.find(path); |
538 if (observer_iter == synced_pref_observers_.end()) | 527 if (observer_iter == synced_pref_observers_.end()) |
539 return; | 528 return; |
540 SyncedPrefObserverList* observers = observer_iter->second.get(); | 529 SyncedPrefObserverList* observers = observer_iter->second.get(); |
541 for (auto& observer : *observers) | 530 for (auto& observer : *observers) |
542 observer.OnSyncedPrefChanged(path, from_sync); | 531 observer.OnSyncedPrefChanged(path, from_sync); |
543 } | 532 } |
544 | 533 |
545 } // namespace syncable_prefs | 534 } // namespace sync_preferences |
OLD | NEW |