| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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/sync/glue/preference_model_associator.h" | |
| 6 | |
| 7 #include "base/json/json_reader.h" | |
| 8 #include "base/logging.h" | |
| 9 #include "base/utf_string_conversions.h" | |
| 10 #include "base/values.h" | |
| 11 #include "chrome/browser/prefs/pref_service.h" | |
| 12 #include "chrome/browser/profiles/profile.h" | |
| 13 #include "chrome/browser/sync/engine/syncapi.h" | |
| 14 #include "chrome/browser/sync/glue/synchronized_preferences.h" | |
| 15 #include "chrome/browser/sync/profile_sync_service.h" | |
| 16 #include "chrome/browser/sync/protocol/preference_specifics.pb.h" | |
| 17 #include "chrome/common/pref_names.h" | |
| 18 #include "content/browser/browser_thread.h" | |
| 19 #include "content/common/json_value_serializer.h" | |
| 20 #include "content/common/notification_service.h" | |
| 21 | |
| 22 namespace browser_sync { | |
| 23 | |
| 24 PreferenceModelAssociator::PreferenceModelAssociator( | |
| 25 ProfileSyncService* sync_service) | |
| 26 : sync_service_(sync_service), | |
| 27 preferences_node_id_(sync_api::kInvalidId) { | |
| 28 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 29 DCHECK(sync_service_); | |
| 30 | |
| 31 // Add the list of kSynchronizedPreferences to our local | |
| 32 // synced_preferences set, taking care to filter out any preferences | |
| 33 // that are not registered. | |
| 34 PrefService* pref_service = sync_service_->profile()->GetPrefs(); | |
| 35 for (size_t i = 0; i < arraysize(kSynchronizedPreferences); ++i) { | |
| 36 if (pref_service->FindPreference(kSynchronizedPreferences[i])) | |
| 37 synced_preferences_.insert(kSynchronizedPreferences[i]); | |
| 38 } | |
| 39 } | |
| 40 | |
| 41 PreferenceModelAssociator::~PreferenceModelAssociator() { | |
| 42 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 43 } | |
| 44 | |
| 45 bool PreferenceModelAssociator::InitPrefNodeAndAssociate( | |
| 46 sync_api::WriteTransaction* trans, | |
| 47 const sync_api::BaseNode& root, | |
| 48 const PrefService::Preference* pref) { | |
| 49 DCHECK(pref); | |
| 50 | |
| 51 PrefService* pref_service = sync_service_->profile()->GetPrefs(); | |
| 52 base::JSONReader reader; | |
| 53 std::string tag = pref->name(); | |
| 54 sync_api::WriteNode node(trans); | |
| 55 if (node.InitByClientTagLookup(syncable::PREFERENCES, tag)) { | |
| 56 // The server has a value for the preference. | |
| 57 const sync_pb::PreferenceSpecifics& preference( | |
| 58 node.GetPreferenceSpecifics()); | |
| 59 DCHECK_EQ(tag, preference.name()); | |
| 60 | |
| 61 if (pref->IsUserModifiable()) { | |
| 62 scoped_ptr<Value> value( | |
| 63 reader.JsonToValue(preference.value(), false, false)); | |
| 64 std::string pref_name = preference.name(); | |
| 65 if (!value.get()) { | |
| 66 LOG(ERROR) << "Failed to deserialize preference value: " | |
| 67 << reader.GetErrorMessage(); | |
| 68 return false; | |
| 69 } | |
| 70 | |
| 71 // Merge the server value of this preference with the local value. | |
| 72 scoped_ptr<Value> new_value(MergePreference(*pref, *value)); | |
| 73 | |
| 74 // Update the local preference based on what we got from the | |
| 75 // sync server. | |
| 76 if (new_value->IsType(Value::TYPE_NULL)) { | |
| 77 pref_service->ClearPref(pref_name.c_str()); | |
| 78 } else if (!new_value->IsType(pref->GetType())) { | |
| 79 LOG(WARNING) << "Synced value for " << preference.name() | |
| 80 << " is of type " << new_value->GetType() | |
| 81 << " which doesn't match pref type " << pref->GetType(); | |
| 82 } else if (!pref->GetValue()->Equals(new_value.get())) { | |
| 83 pref_service->Set(pref_name.c_str(), *new_value); | |
| 84 } | |
| 85 | |
| 86 AfterUpdateOperations(pref_name); | |
| 87 | |
| 88 // If the merge resulted in an updated value, write it back to | |
| 89 // the sync node. | |
| 90 if (!value->Equals(new_value.get()) && | |
| 91 !WritePreferenceToNode(pref->name(), *new_value, &node)) | |
| 92 return false; | |
| 93 } | |
| 94 Associate(pref, node.GetId()); | |
| 95 } else if (pref->IsUserControlled()) { | |
| 96 // The server doesn't have a value, but we have a user-controlled value, | |
| 97 // so we push it to the server. | |
| 98 sync_api::WriteNode write_node(trans); | |
| 99 if (!write_node.InitUniqueByCreation(syncable::PREFERENCES, root, tag)) { | |
| 100 LOG(ERROR) << "Failed to create preference sync node."; | |
| 101 return false; | |
| 102 } | |
| 103 | |
| 104 // Update the sync node with the local value for this preference. | |
| 105 if (!WritePreferenceToNode(pref->name(), *pref->GetValue(), &write_node)) | |
| 106 return false; | |
| 107 | |
| 108 Associate(pref, write_node.GetId()); | |
| 109 } | |
| 110 | |
| 111 return true; | |
| 112 } | |
| 113 | |
| 114 bool PreferenceModelAssociator::AssociateModels() { | |
| 115 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 116 PrefService* pref_service = sync_service_->profile()->GetPrefs(); | |
| 117 | |
| 118 int64 root_id; | |
| 119 if (!GetSyncIdForTaggedNode(kPreferencesTag, &root_id)) { | |
| 120 LOG(ERROR) << "Server did not create the top-level preferences node. We " | |
| 121 << "might be running against an out-of-date server."; | |
| 122 return false; | |
| 123 } | |
| 124 | |
| 125 sync_api::WriteTransaction trans(sync_service_->GetUserShare()); | |
| 126 sync_api::ReadNode root(&trans); | |
| 127 if (!root.InitByIdLookup(root_id)) { | |
| 128 LOG(ERROR) << "Server did not create the top-level preferences node. We " | |
| 129 << "might be running against an out-of-date server."; | |
| 130 return false; | |
| 131 } | |
| 132 | |
| 133 for (std::set<std::string>::iterator it = synced_preferences_.begin(); | |
| 134 it != synced_preferences_.end(); ++it) { | |
| 135 const PrefService::Preference* pref = | |
| 136 pref_service->FindPreference((*it).c_str()); | |
| 137 DCHECK(pref); | |
| 138 InitPrefNodeAndAssociate(&trans, root, pref); | |
| 139 } | |
| 140 return true; | |
| 141 } | |
| 142 | |
| 143 bool PreferenceModelAssociator::DisassociateModels() { | |
| 144 id_map_.clear(); | |
| 145 id_map_inverse_.clear(); | |
| 146 return true; | |
| 147 } | |
| 148 | |
| 149 bool PreferenceModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) { | |
| 150 DCHECK(has_nodes); | |
| 151 *has_nodes = false; | |
| 152 int64 preferences_sync_id; | |
| 153 if (!GetSyncIdForTaggedNode(kPreferencesTag, &preferences_sync_id)) { | |
| 154 LOG(ERROR) << "Server did not create the top-level preferences node. We " | |
| 155 << "might be running against an out-of-date server."; | |
| 156 return false; | |
| 157 } | |
| 158 sync_api::ReadTransaction trans(sync_service_->GetUserShare()); | |
| 159 | |
| 160 sync_api::ReadNode preferences_node(&trans); | |
| 161 if (!preferences_node.InitByIdLookup(preferences_sync_id)) { | |
| 162 LOG(ERROR) << "Server did not create the top-level preferences node. We " | |
| 163 << "might be running against an out-of-date server."; | |
| 164 return false; | |
| 165 } | |
| 166 | |
| 167 // The sync model has user created nodes if the preferences folder has any | |
| 168 // children. | |
| 169 *has_nodes = sync_api::kInvalidId != preferences_node.GetFirstChildId(); | |
| 170 return true; | |
| 171 } | |
| 172 | |
| 173 const PrefService::Preference* | |
| 174 PreferenceModelAssociator::GetChromeNodeFromSyncId(int64 sync_id) { | |
| 175 return NULL; | |
| 176 } | |
| 177 | |
| 178 bool PreferenceModelAssociator::InitSyncNodeFromChromeId( | |
| 179 const std::string& node_id, | |
| 180 sync_api::BaseNode* sync_node) { | |
| 181 return false; | |
| 182 } | |
| 183 | |
| 184 int64 PreferenceModelAssociator::GetSyncIdFromChromeId( | |
| 185 const std::string& preference_name) { | |
| 186 PreferenceNameToSyncIdMap::const_iterator iter = | |
| 187 id_map_.find(preference_name); | |
| 188 return iter == id_map_.end() ? sync_api::kInvalidId : iter->second; | |
| 189 } | |
| 190 | |
| 191 void PreferenceModelAssociator::Associate( | |
| 192 const PrefService::Preference* preference, int64 sync_id) { | |
| 193 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 194 DCHECK_NE(sync_api::kInvalidId, sync_id); | |
| 195 DCHECK(id_map_.find(preference->name()) == id_map_.end()); | |
| 196 DCHECK(id_map_inverse_.find(sync_id) == id_map_inverse_.end()); | |
| 197 id_map_[preference->name()] = sync_id; | |
| 198 id_map_inverse_[sync_id] = preference->name(); | |
| 199 } | |
| 200 | |
| 201 void PreferenceModelAssociator::Disassociate(int64 sync_id) { | |
| 202 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 203 SyncIdToPreferenceNameMap::iterator iter = id_map_inverse_.find(sync_id); | |
| 204 if (iter == id_map_inverse_.end()) | |
| 205 return; | |
| 206 id_map_.erase(iter->second); | |
| 207 id_map_inverse_.erase(iter); | |
| 208 } | |
| 209 | |
| 210 bool PreferenceModelAssociator::GetSyncIdForTaggedNode(const std::string& tag, | |
| 211 int64* sync_id) { | |
| 212 sync_api::ReadTransaction trans(sync_service_->GetUserShare()); | |
| 213 sync_api::ReadNode sync_node(&trans); | |
| 214 if (!sync_node.InitByTagLookup(tag.c_str())) | |
| 215 return false; | |
| 216 *sync_id = sync_node.GetId(); | |
| 217 return true; | |
| 218 } | |
| 219 | |
| 220 Value* PreferenceModelAssociator::MergePreference( | |
| 221 const PrefService::Preference& local_pref, | |
| 222 const Value& server_value) { | |
| 223 const std::string& name(local_pref.name()); | |
| 224 if (name == prefs::kURLsToRestoreOnStartup || | |
| 225 name == prefs::kDesktopNotificationAllowedOrigins || | |
| 226 name == prefs::kDesktopNotificationDeniedOrigins) { | |
| 227 return MergeListValues(*local_pref.GetValue(), server_value); | |
| 228 } | |
| 229 | |
| 230 if (name == prefs::kContentSettingsPatterns || | |
| 231 name == prefs::kGeolocationContentSettings) { | |
| 232 return MergeDictionaryValues(*local_pref.GetValue(), server_value); | |
| 233 } | |
| 234 | |
| 235 // If this is not a specially handled preference, server wins. | |
| 236 return server_value.DeepCopy(); | |
| 237 } | |
| 238 | |
| 239 bool PreferenceModelAssociator::WritePreferenceToNode( | |
| 240 const std::string& name, | |
| 241 const Value& value, | |
| 242 sync_api::WriteNode* node) { | |
| 243 std::string serialized; | |
| 244 JSONStringValueSerializer json(&serialized); | |
| 245 if (!json.Serialize(value)) { | |
| 246 LOG(ERROR) << "Failed to serialize preference value."; | |
| 247 return false; | |
| 248 } | |
| 249 | |
| 250 sync_pb::PreferenceSpecifics preference; | |
| 251 preference.set_name(name); | |
| 252 preference.set_value(serialized); | |
| 253 node->SetPreferenceSpecifics(preference); | |
| 254 // TODO(viettrungluu): eliminate conversion (it's temporary) | |
| 255 node->SetTitle(UTF8ToWide(name)); | |
| 256 return true; | |
| 257 } | |
| 258 | |
| 259 Value* PreferenceModelAssociator::MergeListValues(const Value& from_value, | |
| 260 const Value& to_value) { | |
| 261 if (from_value.GetType() == Value::TYPE_NULL) | |
| 262 return to_value.DeepCopy(); | |
| 263 if (to_value.GetType() == Value::TYPE_NULL) | |
| 264 return from_value.DeepCopy(); | |
| 265 | |
| 266 DCHECK(from_value.GetType() == Value::TYPE_LIST); | |
| 267 DCHECK(to_value.GetType() == Value::TYPE_LIST); | |
| 268 const ListValue& from_list_value = static_cast<const ListValue&>(from_value); | |
| 269 const ListValue& to_list_value = static_cast<const ListValue&>(to_value); | |
| 270 ListValue* result = to_list_value.DeepCopy(); | |
| 271 | |
| 272 for (ListValue::const_iterator i = from_list_value.begin(); | |
| 273 i != from_list_value.end(); ++i) { | |
| 274 Value* value = (*i)->DeepCopy(); | |
| 275 result->AppendIfNotPresent(value); | |
| 276 } | |
| 277 return result; | |
| 278 } | |
| 279 | |
| 280 Value* PreferenceModelAssociator::MergeDictionaryValues( | |
| 281 const Value& from_value, | |
| 282 const Value& to_value) { | |
| 283 if (from_value.GetType() == Value::TYPE_NULL) | |
| 284 return to_value.DeepCopy(); | |
| 285 if (to_value.GetType() == Value::TYPE_NULL) | |
| 286 return from_value.DeepCopy(); | |
| 287 | |
| 288 DCHECK(from_value.GetType() == Value::TYPE_DICTIONARY); | |
| 289 DCHECK(to_value.GetType() == Value::TYPE_DICTIONARY); | |
| 290 const DictionaryValue& from_dict_value = | |
| 291 static_cast<const DictionaryValue&>(from_value); | |
| 292 const DictionaryValue& to_dict_value = | |
| 293 static_cast<const DictionaryValue&>(to_value); | |
| 294 DictionaryValue* result = to_dict_value.DeepCopy(); | |
| 295 | |
| 296 for (DictionaryValue::key_iterator key = from_dict_value.begin_keys(); | |
| 297 key != from_dict_value.end_keys(); ++key) { | |
| 298 Value* from_value; | |
| 299 bool success = from_dict_value.GetWithoutPathExpansion(*key, &from_value); | |
| 300 DCHECK(success); | |
| 301 | |
| 302 Value* to_key_value; | |
| 303 if (result->GetWithoutPathExpansion(*key, &to_key_value)) { | |
| 304 if (to_key_value->GetType() == Value::TYPE_DICTIONARY) { | |
| 305 Value* merged_value = MergeDictionaryValues(*from_value, *to_key_value); | |
| 306 result->SetWithoutPathExpansion(*key, merged_value); | |
| 307 } | |
| 308 // Note that for all other types we want to preserve the "to" | |
| 309 // values so we do nothing here. | |
| 310 } else { | |
| 311 result->SetWithoutPathExpansion(*key, from_value->DeepCopy()); | |
| 312 } | |
| 313 } | |
| 314 return result; | |
| 315 } | |
| 316 | |
| 317 void PreferenceModelAssociator::AfterUpdateOperations( | |
| 318 const std::string& pref_name) { | |
| 319 // The bookmark bar visibility preference requires a special | |
| 320 // notification to update the UI. | |
| 321 if (0 == pref_name.compare(prefs::kShowBookmarkBar)) { | |
| 322 NotificationService::current()->Notify( | |
| 323 NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED, | |
| 324 Source<PreferenceModelAssociator>(this), | |
| 325 NotificationService::NoDetails()); | |
| 326 } | |
| 327 } | |
| 328 | |
| 329 bool PreferenceModelAssociator::CryptoReadyIfNecessary() { | |
| 330 // We only access the cryptographer while holding a transaction. | |
| 331 sync_api::ReadTransaction trans(sync_service_->GetUserShare()); | |
| 332 syncable::ModelTypeSet encrypted_types; | |
| 333 sync_service_->GetEncryptedDataTypes(&encrypted_types); | |
| 334 return encrypted_types.count(syncable::PREFERENCES) == 0 || | |
| 335 sync_service_->IsCryptographerReady(&trans); | |
| 336 } | |
| 337 | |
| 338 } // namespace browser_sync | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 6905044:
Refactor preference syncing. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src