| 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 <map> | |
| 6 #include <string> | |
| 7 #include <utility> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/bind_helpers.h" | |
| 11 #include "base/callback.h" | |
| 12 #include "base/json/json_reader.h" | |
| 13 #include "base/json/json_string_value_serializer.h" | |
| 14 #include "base/json/json_writer.h" | |
| 15 #include "base/location.h" | |
| 16 #include "base/prefs/scoped_user_pref_update.h" | |
| 17 #include "base/stl_util.h" | |
| 18 #include "base/strings/string_piece.h" | |
| 19 #include "base/strings/utf_string_conversions.h" | |
| 20 #include "chrome/browser/invalidation/fake_invalidation_service.h" | |
| 21 #include "chrome/browser/invalidation/invalidation_service_factory.h" | |
| 22 #include "chrome/browser/prefs/pref_model_associator.h" | |
| 23 #include "chrome/browser/prefs/pref_service_syncable.h" | |
| 24 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" | |
| 25 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h" | |
| 26 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" | |
| 27 #include "chrome/browser/signin/signin_manager_factory.h" | |
| 28 #include "chrome/browser/sync/abstract_profile_sync_service_test.h" | |
| 29 #include "chrome/browser/sync/glue/sync_backend_host.h" | |
| 30 #include "chrome/browser/sync/glue/ui_data_type_controller.h" | |
| 31 #include "chrome/browser/sync/profile_sync_service_factory.h" | |
| 32 #include "chrome/browser/sync/profile_sync_test_util.h" | |
| 33 #include "chrome/browser/sync/test_profile_sync_service.h" | |
| 34 #include "chrome/common/pref_names.h" | |
| 35 #include "chrome/test/base/testing_browser_process.h" | |
| 36 #include "chrome/test/base/testing_pref_service_syncable.h" | |
| 37 #include "chrome/test/base/testing_profile.h" | |
| 38 #include "chrome/test/base/testing_profile_manager.h" | |
| 39 #include "components/signin/core/browser/signin_manager.h" | |
| 40 #include "components/sync_driver/generic_change_processor.h" | |
| 41 #include "components/user_prefs/pref_registry_syncable.h" | |
| 42 #include "google_apis/gaia/gaia_constants.h" | |
| 43 #include "sync/api/attachments/fake_attachment_service.h" | |
| 44 #include "sync/api/sync_data.h" | |
| 45 #include "sync/internal_api/public/base/model_type.h" | |
| 46 #include "sync/internal_api/public/change_record.h" | |
| 47 #include "sync/internal_api/public/data_type_debug_info_listener.h" | |
| 48 #include "sync/internal_api/public/read_node.h" | |
| 49 #include "sync/internal_api/public/read_transaction.h" | |
| 50 #include "sync/internal_api/public/write_node.h" | |
| 51 #include "sync/internal_api/public/write_transaction.h" | |
| 52 #include "sync/protocol/preference_specifics.pb.h" | |
| 53 #include "testing/gmock/include/gmock/gmock.h" | |
| 54 #include "testing/gtest/include/gtest/gtest.h" | |
| 55 | |
| 56 using base::JSONReader; | |
| 57 using browser_sync::GenericChangeProcessor; | |
| 58 using browser_sync::SharedChangeProcessor; | |
| 59 using browser_sync::UIDataTypeController; | |
| 60 using syncer::ChangeRecord; | |
| 61 using testing::Invoke; | |
| 62 using testing::Return; | |
| 63 using testing::_; | |
| 64 | |
| 65 namespace { | |
| 66 const char kTestProfileName[] = "test-profile"; | |
| 67 } | |
| 68 | |
| 69 typedef std::map<const std::string, const base::Value*> PreferenceValues; | |
| 70 | |
| 71 ACTION_P(CreateAndSaveChangeProcessor, change_processor) { | |
| 72 syncer::UserShare* user_share = arg0->GetUserShare(); | |
| 73 *change_processor = new GenericChangeProcessor( | |
| 74 arg1, | |
| 75 arg2, | |
| 76 arg3, | |
| 77 user_share, | |
| 78 syncer::FakeAttachmentService::CreateForTest()); | |
| 79 return *change_processor; | |
| 80 } | |
| 81 | |
| 82 ACTION_P(ReturnNewDataTypeManagerWithDebugListener, debug_listener) { | |
| 83 return new browser_sync::DataTypeManagerImpl( | |
| 84 debug_listener, | |
| 85 arg1, | |
| 86 arg2, | |
| 87 arg3, | |
| 88 arg4, | |
| 89 arg5); | |
| 90 } | |
| 91 | |
| 92 // TODO(zea): Refactor to remove the ProfileSyncService usage. | |
| 93 class ProfileSyncServicePreferenceTest | |
| 94 : public AbstractProfileSyncServiceTest, | |
| 95 public syncer::DataTypeDebugInfoListener { | |
| 96 public: | |
| 97 int64 SetSyncedValue(const std::string& name, const base::Value& value) { | |
| 98 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 99 syncer::ReadNode root(&trans); | |
| 100 if (root.InitByTagLookup(syncer::ModelTypeToRootTag( | |
| 101 syncer::PREFERENCES)) != syncer::BaseNode::INIT_OK) { | |
| 102 return syncer::kInvalidId; | |
| 103 } | |
| 104 | |
| 105 syncer::WriteNode tag_node(&trans); | |
| 106 syncer::WriteNode node(&trans); | |
| 107 | |
| 108 if (tag_node.InitByClientTagLookup(syncer::PREFERENCES, name) == | |
| 109 syncer::BaseNode::INIT_OK) { | |
| 110 return WriteSyncedValue(name, value, &tag_node); | |
| 111 } | |
| 112 | |
| 113 syncer::WriteNode::InitUniqueByCreationResult result = | |
| 114 node.InitUniqueByCreation(syncer::PREFERENCES, root, name); | |
| 115 if (result == syncer::WriteNode::INIT_SUCCESS) | |
| 116 return WriteSyncedValue(name, value, &node); | |
| 117 | |
| 118 return syncer::kInvalidId; | |
| 119 } | |
| 120 | |
| 121 // DataTypeDebugInfoListener implementation. | |
| 122 virtual void OnDataTypeConfigureComplete( | |
| 123 const std::vector<syncer::DataTypeConfigurationStats>& | |
| 124 configuration_stats) OVERRIDE { | |
| 125 ASSERT_EQ(1u, configuration_stats.size()); | |
| 126 association_stats_ = configuration_stats[0].association_stats; | |
| 127 } | |
| 128 | |
| 129 protected: | |
| 130 ProfileSyncServicePreferenceTest() | |
| 131 : profile_manager_(TestingBrowserProcess::GetGlobal()), | |
| 132 debug_ptr_factory_(this), | |
| 133 example_url0_("http://example.com/0"), | |
| 134 example_url1_("http://example.com/1"), | |
| 135 example_url2_("http://example.com/2"), | |
| 136 not_synced_preference_name_("nonsense_pref_name"), | |
| 137 not_synced_preference_default_value_("default"), | |
| 138 non_default_charset_value_("foo") {} | |
| 139 | |
| 140 virtual void SetUp() { | |
| 141 AbstractProfileSyncServiceTest::SetUp(); | |
| 142 ASSERT_TRUE(profile_manager_.SetUp()); | |
| 143 TestingProfile::TestingFactories testing_factories; | |
| 144 testing_factories.push_back(std::make_pair( | |
| 145 ProfileOAuth2TokenServiceFactory::GetInstance(), | |
| 146 BuildAutoIssuingFakeProfileOAuth2TokenService)); | |
| 147 profile_ = profile_manager_.CreateTestingProfile( | |
| 148 kTestProfileName, | |
| 149 scoped_ptr<PrefServiceSyncable>(), | |
| 150 base::UTF8ToUTF16(kTestProfileName), | |
| 151 0, | |
| 152 std::string(), | |
| 153 testing_factories); | |
| 154 invalidation::InvalidationServiceFactory::GetInstance()->SetTestingFactory( | |
| 155 profile_, invalidation::FakeInvalidationService::Build); | |
| 156 prefs_ = profile_->GetTestingPrefService(); | |
| 157 | |
| 158 prefs_->registry()->RegisterStringPref( | |
| 159 not_synced_preference_name_.c_str(), | |
| 160 not_synced_preference_default_value_, | |
| 161 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 162 } | |
| 163 | |
| 164 virtual void TearDown() { | |
| 165 profile_ = NULL; | |
| 166 profile_manager_.DeleteTestingProfile(kTestProfileName); | |
| 167 AbstractProfileSyncServiceTest::TearDown(); | |
| 168 } | |
| 169 | |
| 170 int GetSyncPreferenceCount() { | |
| 171 syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 172 syncer::ReadNode node(&trans); | |
| 173 if (node.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::PREFERENCES)) != | |
| 174 syncer::BaseNode::INIT_OK) | |
| 175 return 0; | |
| 176 return node.GetTotalNodeCount() - 1; | |
| 177 } | |
| 178 | |
| 179 bool StartSyncService(const base::Closure& callback, | |
| 180 bool will_fail_association) { | |
| 181 if (sync_service_) | |
| 182 return false; | |
| 183 | |
| 184 SigninManagerBase* signin = | |
| 185 SigninManagerFactory::GetForProfile(profile_); | |
| 186 signin->SetAuthenticatedUsername("test"); | |
| 187 sync_service_ = TestProfileSyncService::BuildAutoStartAsyncInit(profile_, | |
| 188 callback); | |
| 189 pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>( | |
| 190 prefs_->GetSyncableService(syncer::PREFERENCES)); | |
| 191 if (!pref_sync_service_) | |
| 192 return false; | |
| 193 ProfileSyncComponentsFactoryMock* components = | |
| 194 sync_service_->components_factory_mock(); | |
| 195 EXPECT_CALL(*components, GetSyncableServiceForType(syncer::PREFERENCES)). | |
| 196 WillOnce(Return(pref_sync_service_->AsWeakPtr())); | |
| 197 | |
| 198 EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _, _)). | |
| 199 WillOnce(ReturnNewDataTypeManagerWithDebugListener( | |
| 200 syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr()))); | |
| 201 dtc_ = new UIDataTypeController(base::MessageLoopProxy::current(), | |
| 202 base::Closure(), | |
| 203 syncer::PREFERENCES, | |
| 204 components, | |
| 205 profile_, | |
| 206 sync_service_); | |
| 207 EXPECT_CALL(*components, CreateSharedChangeProcessor()). | |
| 208 WillOnce(Return(new SharedChangeProcessor())); | |
| 209 EXPECT_CALL(*components, CreateGenericChangeProcessor(_, _, _, _)). | |
| 210 WillOnce(CreateAndSaveChangeProcessor( | |
| 211 &change_processor_)); | |
| 212 sync_service_->RegisterDataTypeController(dtc_); | |
| 213 ProfileOAuth2TokenServiceFactory::GetForProfile(profile_) | |
| 214 ->UpdateCredentials("test", "oauth2_login_token"); | |
| 215 | |
| 216 sync_service_->Initialize(); | |
| 217 base::MessageLoop::current()->Run(); | |
| 218 | |
| 219 // It's possible this test triggered an unrecoverable error, in which case | |
| 220 // we can't get the preference count. | |
| 221 if (sync_service_->ShouldPushChanges()) { | |
| 222 EXPECT_EQ(GetSyncPreferenceCount(), | |
| 223 association_stats_.num_sync_items_after_association); | |
| 224 } | |
| 225 EXPECT_EQ(association_stats_.num_sync_items_after_association, | |
| 226 association_stats_.num_sync_items_before_association + | |
| 227 association_stats_.num_sync_items_added - | |
| 228 association_stats_.num_sync_items_deleted); | |
| 229 | |
| 230 return true; | |
| 231 } | |
| 232 | |
| 233 const base::Value& GetPreferenceValue(const std::string& name) { | |
| 234 const PrefService::Preference* preference = | |
| 235 prefs_->FindPreference(name.c_str()); | |
| 236 return *preference->GetValue(); | |
| 237 } | |
| 238 | |
| 239 // Caller gets ownership of the returned value. | |
| 240 const base::Value* GetSyncedValue(const std::string& name) { | |
| 241 syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 242 syncer::ReadNode node(&trans); | |
| 243 | |
| 244 if (node.InitByClientTagLookup(syncer::PREFERENCES, name) != | |
| 245 syncer::BaseNode::INIT_OK) { | |
| 246 return NULL; | |
| 247 } | |
| 248 | |
| 249 const sync_pb::PreferenceSpecifics& specifics( | |
| 250 node.GetEntitySpecifics().preference()); | |
| 251 | |
| 252 return base::JSONReader::Read(specifics.value()); | |
| 253 } | |
| 254 | |
| 255 int64 WriteSyncedValue(const std::string& name, | |
| 256 const base::Value& value, | |
| 257 syncer::WriteNode* node) { | |
| 258 syncer::SyncData sync_data; | |
| 259 if (!pref_sync_service_->CreatePrefSyncData(name, | |
| 260 value, | |
| 261 &sync_data)) { | |
| 262 return syncer::kInvalidId; | |
| 263 } | |
| 264 node->SetEntitySpecifics(sync_data.GetSpecifics()); | |
| 265 return node->GetId(); | |
| 266 } | |
| 267 | |
| 268 bool IsSynced(const std::string& pref_name) { | |
| 269 return pref_sync_service_->registered_preferences().count(pref_name) > 0; | |
| 270 } | |
| 271 | |
| 272 bool HasSyncData(const std::string& pref_name) { | |
| 273 return pref_sync_service_->IsPrefSynced(pref_name); | |
| 274 } | |
| 275 | |
| 276 std::string ValueString(const base::Value& value) { | |
| 277 std::string serialized; | |
| 278 JSONStringValueSerializer json(&serialized); | |
| 279 json.Serialize(value); | |
| 280 return serialized; | |
| 281 } | |
| 282 | |
| 283 // Returns whether a given preference name is a new name of a migrated | |
| 284 // preference. Exposed here for testing. | |
| 285 static bool IsMigratedPreference(const char* preference_name) { | |
| 286 return PrefModelAssociator::IsMigratedPreference(preference_name); | |
| 287 } | |
| 288 static bool IsOldMigratedPreference(const char* old_preference_name) { | |
| 289 return PrefModelAssociator::IsOldMigratedPreference(old_preference_name); | |
| 290 } | |
| 291 | |
| 292 TestingProfileManager profile_manager_; | |
| 293 TestingProfile* profile_; | |
| 294 TestingPrefServiceSyncable* prefs_; | |
| 295 | |
| 296 UIDataTypeController* dtc_; | |
| 297 PrefModelAssociator* pref_sync_service_; | |
| 298 GenericChangeProcessor* change_processor_; | |
| 299 syncer::DataTypeAssociationStats association_stats_; | |
| 300 base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_; | |
| 301 | |
| 302 std::string example_url0_; | |
| 303 std::string example_url1_; | |
| 304 std::string example_url2_; | |
| 305 std::string not_synced_preference_name_; | |
| 306 std::string not_synced_preference_default_value_; | |
| 307 std::string non_default_charset_value_; | |
| 308 }; | |
| 309 | |
| 310 class AddPreferenceEntriesHelper { | |
| 311 public: | |
| 312 AddPreferenceEntriesHelper(ProfileSyncServicePreferenceTest* test, | |
| 313 const PreferenceValues& entries) | |
| 314 : callback_(base::Bind( | |
| 315 &AddPreferenceEntriesHelper::AddPreferenceEntriesCallback, | |
| 316 base::Unretained(this), test, entries)), | |
| 317 success_(false) { | |
| 318 } | |
| 319 | |
| 320 const base::Closure& callback() const { return callback_; } | |
| 321 bool success() { return success_; } | |
| 322 | |
| 323 private: | |
| 324 void AddPreferenceEntriesCallback(ProfileSyncServicePreferenceTest* test, | |
| 325 const PreferenceValues& entries) { | |
| 326 if (!test->CreateRoot(syncer::PREFERENCES)) | |
| 327 return; | |
| 328 | |
| 329 for (PreferenceValues::const_iterator i = entries.begin(); | |
| 330 i != entries.end(); ++i) { | |
| 331 if (test->SetSyncedValue(i->first, *i->second) == syncer::kInvalidId) | |
| 332 return; | |
| 333 } | |
| 334 success_ = true; | |
| 335 } | |
| 336 | |
| 337 base::Closure callback_; | |
| 338 bool success_; | |
| 339 }; | |
| 340 | |
| 341 TEST_F(ProfileSyncServicePreferenceTest, CreatePrefSyncData) { | |
| 342 prefs_->SetString(prefs::kHomePage, example_url0_); | |
| 343 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 344 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 345 ASSERT_TRUE(create_root.success()); | |
| 346 | |
| 347 const PrefService::Preference* pref = | |
| 348 prefs_->FindPreference(prefs::kHomePage); | |
| 349 syncer::SyncData sync_data; | |
| 350 EXPECT_TRUE(pref_sync_service_->CreatePrefSyncData(pref->name(), | |
| 351 *pref->GetValue(), &sync_data)); | |
| 352 EXPECT_EQ(std::string(prefs::kHomePage), | |
| 353 syncer::SyncDataLocal(sync_data).GetTag()); | |
| 354 const sync_pb::PreferenceSpecifics& specifics(sync_data.GetSpecifics(). | |
| 355 preference()); | |
| 356 EXPECT_EQ(std::string(prefs::kHomePage), specifics.name()); | |
| 357 | |
| 358 scoped_ptr<base::Value> value(base::JSONReader::Read(specifics.value())); | |
| 359 EXPECT_TRUE(pref->GetValue()->Equals(value.get())); | |
| 360 } | |
| 361 | |
| 362 TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationDoNotSyncDefaults) { | |
| 363 const PrefService::Preference* pref = | |
| 364 prefs_->FindPreference(prefs::kHomePage); | |
| 365 EXPECT_TRUE(pref->IsDefaultValue()); | |
| 366 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 367 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 368 ASSERT_TRUE(create_root.success()); | |
| 369 EXPECT_TRUE(IsSynced(prefs::kHomePage)); | |
| 370 EXPECT_TRUE(pref->IsDefaultValue()); | |
| 371 EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL); | |
| 372 EXPECT_TRUE(GetSyncedValue(not_synced_preference_name_) == NULL); | |
| 373 } | |
| 374 | |
| 375 TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationEmptyCloud) { | |
| 376 prefs_->SetString(prefs::kHomePage, example_url0_); | |
| 377 { | |
| 378 ListPrefUpdate update(prefs_, prefs::kURLsToRestoreOnStartup); | |
| 379 base::ListValue* url_list = update.Get(); | |
| 380 url_list->Append(new base::StringValue(example_url0_)); | |
| 381 url_list->Append(new base::StringValue(example_url1_)); | |
| 382 } | |
| 383 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 384 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 385 ASSERT_TRUE(create_root.success()); | |
| 386 | |
| 387 scoped_ptr<const base::Value> value(GetSyncedValue(prefs::kHomePage)); | |
| 388 ASSERT_TRUE(value.get()); | |
| 389 EXPECT_TRUE(GetPreferenceValue(prefs::kHomePage).Equals(value.get())); | |
| 390 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 391 ASSERT_TRUE(value.get()); | |
| 392 EXPECT_TRUE( | |
| 393 GetPreferenceValue(prefs::kURLsToRestoreOnStartup).Equals(value.get())); | |
| 394 } | |
| 395 | |
| 396 TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationCloudHasData) { | |
| 397 prefs_->SetString(prefs::kHomePage, example_url0_); | |
| 398 { | |
| 399 ListPrefUpdate update(prefs_, prefs::kURLsToRestoreOnStartup); | |
| 400 base::ListValue* url_list = update.Get(); | |
| 401 url_list->Append(new base::StringValue(example_url0_)); | |
| 402 url_list->Append(new base::StringValue(example_url1_)); | |
| 403 } | |
| 404 | |
| 405 PreferenceValues cloud_data; | |
| 406 STLValueDeleter<PreferenceValues> cloud_data_deleter(&cloud_data); | |
| 407 cloud_data[prefs::kHomePage] = new base::StringValue(example_url1_); | |
| 408 base::ListValue* urls_to_restore = new base::ListValue; | |
| 409 urls_to_restore->Append(new base::StringValue(example_url1_)); | |
| 410 urls_to_restore->Append(new base::StringValue(example_url2_)); | |
| 411 cloud_data[prefs::kURLsToRestoreOnStartup] = urls_to_restore; | |
| 412 cloud_data[prefs::kDefaultCharset] = | |
| 413 new base::StringValue(non_default_charset_value_); | |
| 414 | |
| 415 AddPreferenceEntriesHelper helper(this, cloud_data); | |
| 416 ASSERT_TRUE(StartSyncService(helper.callback(), false)); | |
| 417 ASSERT_TRUE(helper.success()); | |
| 418 | |
| 419 scoped_ptr<const base::Value> value(GetSyncedValue(prefs::kHomePage)); | |
| 420 ASSERT_TRUE(value.get()); | |
| 421 std::string string_value; | |
| 422 EXPECT_TRUE(value->GetAsString(&string_value)); | |
| 423 EXPECT_EQ(example_url1_, string_value); | |
| 424 EXPECT_EQ(example_url1_, prefs_->GetString(prefs::kHomePage)); | |
| 425 | |
| 426 scoped_ptr<base::ListValue> expected_urls(new base::ListValue); | |
| 427 expected_urls->Append(new base::StringValue(example_url1_)); | |
| 428 expected_urls->Append(new base::StringValue(example_url2_)); | |
| 429 expected_urls->Append(new base::StringValue(example_url0_)); | |
| 430 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 431 ASSERT_TRUE(value.get()); | |
| 432 EXPECT_TRUE(value->Equals(expected_urls.get())); | |
| 433 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup). | |
| 434 Equals(expected_urls.get())); | |
| 435 | |
| 436 value.reset(GetSyncedValue(prefs::kDefaultCharset)); | |
| 437 ASSERT_TRUE(value.get()); | |
| 438 EXPECT_TRUE(value->GetAsString(&string_value)); | |
| 439 EXPECT_EQ(non_default_charset_value_, string_value); | |
| 440 EXPECT_EQ(non_default_charset_value_, | |
| 441 prefs_->GetString(prefs::kDefaultCharset)); | |
| 442 } | |
| 443 | |
| 444 TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationMigrateOldData) { | |
| 445 ASSERT_TRUE(IsMigratedPreference(prefs::kURLsToRestoreOnStartup)); | |
| 446 ASSERT_TRUE(IsOldMigratedPreference(prefs::kURLsToRestoreOnStartupOld)); | |
| 447 | |
| 448 PreferenceValues cloud_data; | |
| 449 STLValueDeleter<PreferenceValues> cloud_data_deleter(&cloud_data); | |
| 450 base::ListValue* urls_to_restore = new base::ListValue; | |
| 451 urls_to_restore->Append(new base::StringValue(example_url1_)); | |
| 452 urls_to_restore->Append(new base::StringValue(example_url2_)); | |
| 453 cloud_data[prefs::kURLsToRestoreOnStartupOld] = urls_to_restore; | |
| 454 | |
| 455 AddPreferenceEntriesHelper helper(this, cloud_data); | |
| 456 ASSERT_TRUE(StartSyncService(helper.callback(), false)); | |
| 457 ASSERT_TRUE(helper.success()); | |
| 458 | |
| 459 // Expect that the new preference data contains the old pref's values. | |
| 460 scoped_ptr<base::ListValue> expected_urls(new base::ListValue); | |
| 461 expected_urls->Append(new base::StringValue(example_url1_)); | |
| 462 expected_urls->Append(new base::StringValue(example_url2_)); | |
| 463 | |
| 464 ASSERT_TRUE(HasSyncData(prefs::kURLsToRestoreOnStartup)); | |
| 465 scoped_ptr<const base::Value> value( | |
| 466 GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 467 ASSERT_TRUE(value.get()); | |
| 468 EXPECT_TRUE(value->Equals(expected_urls.get())); | |
| 469 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup). | |
| 470 Equals(expected_urls.get())); | |
| 471 | |
| 472 // The old preference value should be the same. | |
| 473 expected_urls.reset(new base::ListValue); | |
| 474 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartupOld)); | |
| 475 ASSERT_TRUE(value.get()); | |
| 476 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartupOld). | |
| 477 Equals(expected_urls.get())); | |
| 478 } | |
| 479 | |
| 480 TEST_F(ProfileSyncServicePreferenceTest, | |
| 481 ModelAssociationCloudHasOldMigratedData) { | |
| 482 ASSERT_TRUE(IsMigratedPreference(prefs::kURLsToRestoreOnStartup)); | |
| 483 ASSERT_TRUE(IsOldMigratedPreference(prefs::kURLsToRestoreOnStartupOld)); | |
| 484 prefs_->SetString(prefs::kHomePage, example_url0_); | |
| 485 { | |
| 486 ListPrefUpdate update(prefs_, prefs::kURLsToRestoreOnStartup); | |
| 487 base::ListValue* url_list = update.Get(); | |
| 488 url_list->Append(new base::StringValue(example_url0_)); | |
| 489 url_list->Append(new base::StringValue(example_url1_)); | |
| 490 } | |
| 491 | |
| 492 PreferenceValues cloud_data; | |
| 493 STLValueDeleter<PreferenceValues> cloud_data_deleter(&cloud_data); | |
| 494 cloud_data[prefs::kHomePage] = new base::StringValue(example_url1_); | |
| 495 base::ListValue* urls_to_restore = new base::ListValue; | |
| 496 urls_to_restore->Append(new base::StringValue(example_url1_)); | |
| 497 urls_to_restore->Append(new base::StringValue(example_url2_)); | |
| 498 cloud_data[prefs::kURLsToRestoreOnStartupOld] = urls_to_restore; | |
| 499 | |
| 500 AddPreferenceEntriesHelper helper(this, cloud_data); | |
| 501 ASSERT_TRUE(StartSyncService(helper.callback(), false)); | |
| 502 ASSERT_TRUE(helper.success()); | |
| 503 | |
| 504 scoped_ptr<const base::Value> value(GetSyncedValue(prefs::kHomePage)); | |
| 505 ASSERT_TRUE(value.get()); | |
| 506 std::string string_value; | |
| 507 EXPECT_TRUE(value->GetAsString(&string_value)); | |
| 508 EXPECT_EQ(example_url1_, string_value); | |
| 509 EXPECT_EQ(example_url1_, prefs_->GetString(prefs::kHomePage)); | |
| 510 | |
| 511 // Expect that the new preference data contains the merged old prefs values. | |
| 512 scoped_ptr<base::ListValue> expected_urls(new base::ListValue); | |
| 513 expected_urls->Append(new base::StringValue(example_url1_)); | |
| 514 expected_urls->Append(new base::StringValue(example_url2_)); | |
| 515 expected_urls->Append(new base::StringValue(example_url0_)); | |
| 516 | |
| 517 ASSERT_TRUE(HasSyncData(prefs::kURLsToRestoreOnStartup)); | |
| 518 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 519 ASSERT_TRUE(value.get()); | |
| 520 EXPECT_TRUE(value->Equals(expected_urls.get())); | |
| 521 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup). | |
| 522 Equals(expected_urls.get())); | |
| 523 | |
| 524 // The old preference name should also contain the merged sync data. | |
| 525 expected_urls.reset(new base::ListValue); | |
| 526 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartupOld)); | |
| 527 ASSERT_TRUE(value.get()); | |
| 528 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartupOld). | |
| 529 Equals(expected_urls.get())); | |
| 530 } | |
| 531 | |
| 532 TEST_F(ProfileSyncServicePreferenceTest, | |
| 533 ModelAssociationCloudHasNewMigratedData) { | |
| 534 ASSERT_TRUE(IsMigratedPreference(prefs::kURLsToRestoreOnStartup)); | |
| 535 ASSERT_TRUE(IsOldMigratedPreference(prefs::kURLsToRestoreOnStartupOld)); | |
| 536 prefs_->SetString(prefs::kHomePage, example_url0_); | |
| 537 { | |
| 538 ListPrefUpdate update(prefs_, prefs::kURLsToRestoreOnStartupOld); | |
| 539 base::ListValue* url_list = update.Get(); | |
| 540 url_list->Append(new base::StringValue(example_url0_)); | |
| 541 url_list->Append(new base::StringValue(example_url1_)); | |
| 542 } | |
| 543 | |
| 544 PreferenceValues cloud_data; | |
| 545 STLValueDeleter<PreferenceValues> cloud_data_deleter(&cloud_data); | |
| 546 cloud_data[prefs::kHomePage] = new base::StringValue(example_url1_); | |
| 547 base::ListValue* urls_to_restore = new base::ListValue; | |
| 548 urls_to_restore->Append(new base::StringValue(example_url1_)); | |
| 549 urls_to_restore->Append(new base::StringValue(example_url2_)); | |
| 550 cloud_data[prefs::kURLsToRestoreOnStartup] = urls_to_restore; | |
| 551 | |
| 552 AddPreferenceEntriesHelper helper(this, cloud_data); | |
| 553 ASSERT_TRUE(StartSyncService(helper.callback(), false)); | |
| 554 ASSERT_TRUE(helper.success()); | |
| 555 | |
| 556 scoped_ptr<const base::Value> value(GetSyncedValue(prefs::kHomePage)); | |
| 557 ASSERT_TRUE(value.get()); | |
| 558 std::string string_value; | |
| 559 EXPECT_TRUE(value->GetAsString(&string_value)); | |
| 560 EXPECT_EQ(example_url1_, string_value); | |
| 561 EXPECT_EQ(example_url1_, prefs_->GetString(prefs::kHomePage)); | |
| 562 | |
| 563 // Expect that the cloud data under the new migrated preference name sticks. | |
| 564 scoped_ptr<base::ListValue> expected_urls(new base::ListValue); | |
| 565 expected_urls->Append(new base::StringValue(example_url1_)); | |
| 566 expected_urls->Append(new base::StringValue(example_url2_)); | |
| 567 | |
| 568 ASSERT_TRUE(HasSyncData(prefs::kURLsToRestoreOnStartup)); | |
| 569 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 570 ASSERT_TRUE(value.get()); | |
| 571 EXPECT_TRUE(value->Equals(expected_urls.get())); | |
| 572 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup). | |
| 573 Equals(expected_urls.get())); | |
| 574 | |
| 575 // The old preference data should still be here, though not synced. | |
| 576 expected_urls.reset(new base::ListValue); | |
| 577 expected_urls->Append(new base::StringValue(example_url0_)); | |
| 578 expected_urls->Append(new base::StringValue(example_url1_)); | |
| 579 | |
| 580 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartupOld)); | |
| 581 ASSERT_FALSE(value.get()); | |
| 582 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartupOld). | |
| 583 Equals(expected_urls.get())); | |
| 584 } | |
| 585 | |
| 586 TEST_F(ProfileSyncServicePreferenceTest, | |
| 587 ModelAssociationCloudAddsOldAndNewMigratedData) { | |
| 588 ASSERT_TRUE(IsMigratedPreference(prefs::kURLsToRestoreOnStartup)); | |
| 589 ASSERT_TRUE(IsOldMigratedPreference(prefs::kURLsToRestoreOnStartupOld)); | |
| 590 prefs_->SetString(prefs::kHomePage, example_url0_); | |
| 591 { | |
| 592 ListPrefUpdate update_old(prefs_, prefs::kURLsToRestoreOnStartupOld); | |
| 593 base::ListValue* url_list_old = update_old.Get(); | |
| 594 url_list_old->Append(new base::StringValue(example_url0_)); | |
| 595 url_list_old->Append(new base::StringValue(example_url1_)); | |
| 596 ListPrefUpdate update(prefs_, prefs::kURLsToRestoreOnStartup); | |
| 597 base::ListValue* url_list = update.Get(); | |
| 598 url_list->Append(new base::StringValue(example_url1_)); | |
| 599 url_list->Append(new base::StringValue(example_url2_)); | |
| 600 } | |
| 601 | |
| 602 PreferenceValues cloud_data; | |
| 603 STLValueDeleter<PreferenceValues> cloud_data_deleter(&cloud_data); | |
| 604 cloud_data[prefs::kHomePage] = new base::StringValue(example_url1_); | |
| 605 | |
| 606 AddPreferenceEntriesHelper helper(this, cloud_data); | |
| 607 ASSERT_TRUE(StartSyncService(helper.callback(), false)); | |
| 608 ASSERT_TRUE(helper.success()); | |
| 609 | |
| 610 scoped_ptr<const base::Value> value(GetSyncedValue(prefs::kHomePage)); | |
| 611 ASSERT_TRUE(value.get()); | |
| 612 std::string string_value; | |
| 613 EXPECT_TRUE(value->GetAsString(&string_value)); | |
| 614 EXPECT_EQ(example_url1_, string_value); | |
| 615 EXPECT_EQ(example_url1_, prefs_->GetString(prefs::kHomePage)); | |
| 616 | |
| 617 // Expect that the cloud data under the new migrated preference name sticks. | |
| 618 scoped_ptr<base::ListValue> expected_urls(new base::ListValue); | |
| 619 expected_urls->Append(new base::StringValue(example_url1_)); | |
| 620 expected_urls->Append(new base::StringValue(example_url2_)); | |
| 621 | |
| 622 ASSERT_TRUE(HasSyncData(prefs::kURLsToRestoreOnStartup)); | |
| 623 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 624 ASSERT_TRUE(value.get()); | |
| 625 EXPECT_TRUE(value->Equals(expected_urls.get())); | |
| 626 EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup). | |
| 627 Equals(expected_urls.get())); | |
| 628 | |
| 629 // Should not have synced in the old startup url values. | |
| 630 value.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartupOld)); | |
| 631 ASSERT_FALSE(value.get()); | |
| 632 EXPECT_FALSE(GetPreferenceValue(prefs::kURLsToRestoreOnStartupOld). | |
| 633 Equals(expected_urls.get())); | |
| 634 } | |
| 635 | |
| 636 TEST_F(ProfileSyncServicePreferenceTest, FailModelAssociation) { | |
| 637 ASSERT_TRUE(StartSyncService(base::Closure(), true)); | |
| 638 EXPECT_TRUE(sync_service_->HasUnrecoverableError()); | |
| 639 } | |
| 640 | |
| 641 TEST_F(ProfileSyncServicePreferenceTest, UpdatedPreferenceWithDefaultValue) { | |
| 642 const PrefService::Preference* pref = | |
| 643 prefs_->FindPreference(prefs::kHomePage); | |
| 644 EXPECT_TRUE(pref->IsDefaultValue()); | |
| 645 | |
| 646 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 647 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 648 ASSERT_TRUE(create_root.success()); | |
| 649 | |
| 650 base::StringValue expected(example_url0_); | |
| 651 profile_->GetPrefs()->Set(prefs::kHomePage, expected); | |
| 652 | |
| 653 scoped_ptr<const base::Value> actual(GetSyncedValue(prefs::kHomePage)); | |
| 654 ASSERT_TRUE(actual.get()); | |
| 655 EXPECT_TRUE(expected.Equals(actual.get())); | |
| 656 } | |
| 657 | |
| 658 TEST_F(ProfileSyncServicePreferenceTest, UpdatedPreferenceWithValue) { | |
| 659 profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_); | |
| 660 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 661 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 662 ASSERT_TRUE(create_root.success()); | |
| 663 | |
| 664 base::StringValue expected(example_url1_); | |
| 665 profile_->GetPrefs()->Set(prefs::kHomePage, expected); | |
| 666 | |
| 667 scoped_ptr<const base::Value> actual(GetSyncedValue(prefs::kHomePage)); | |
| 668 ASSERT_TRUE(actual.get()); | |
| 669 EXPECT_TRUE(expected.Equals(actual.get())); | |
| 670 } | |
| 671 | |
| 672 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionUpdate) { | |
| 673 profile_->GetPrefs()->SetString(prefs::kHomePage, example_url0_); | |
| 674 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 675 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 676 ASSERT_TRUE(create_root.success()); | |
| 677 | |
| 678 base::StringValue expected(example_url1_); | |
| 679 int64 node_id = SetSyncedValue(prefs::kHomePage, expected); | |
| 680 ASSERT_NE(node_id, syncer::kInvalidId); | |
| 681 { | |
| 682 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 683 change_processor_->ApplyChangesFromSyncModel( | |
| 684 &trans, 0, | |
| 685 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList( | |
| 686 node_id, ChangeRecord::ACTION_UPDATE)); | |
| 687 } | |
| 688 change_processor_->CommitChangesFromSyncModel(); | |
| 689 | |
| 690 const base::Value& actual = GetPreferenceValue(prefs::kHomePage); | |
| 691 EXPECT_TRUE(expected.Equals(&actual)); | |
| 692 } | |
| 693 | |
| 694 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeActionAdd) { | |
| 695 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 696 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 697 ASSERT_TRUE(create_root.success()); | |
| 698 | |
| 699 base::StringValue expected(example_url0_); | |
| 700 int64 node_id = SetSyncedValue(prefs::kHomePage, expected); | |
| 701 ASSERT_NE(node_id, syncer::kInvalidId); | |
| 702 { | |
| 703 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 704 change_processor_->ApplyChangesFromSyncModel( | |
| 705 &trans, 0, | |
| 706 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList( | |
| 707 node_id, ChangeRecord::ACTION_ADD)); | |
| 708 } | |
| 709 change_processor_->CommitChangesFromSyncModel(); | |
| 710 | |
| 711 const base::Value& actual = GetPreferenceValue(prefs::kHomePage); | |
| 712 EXPECT_TRUE(expected.Equals(&actual)); | |
| 713 EXPECT_EQ(1U, | |
| 714 pref_sync_service_->registered_preferences().count(prefs::kHomePage)); | |
| 715 } | |
| 716 | |
| 717 TEST_F(ProfileSyncServicePreferenceTest, UpdatedSyncNodeUnknownPreference) { | |
| 718 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 719 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 720 ASSERT_TRUE(create_root.success()); | |
| 721 | |
| 722 base::StringValue expected(example_url0_); | |
| 723 int64 node_id = SetSyncedValue("unknown preference", expected); | |
| 724 ASSERT_NE(node_id, syncer::kInvalidId); | |
| 725 { | |
| 726 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 727 change_processor_->ApplyChangesFromSyncModel( | |
| 728 &trans, 0, | |
| 729 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList( | |
| 730 node_id, ChangeRecord::ACTION_UPDATE)); | |
| 731 } | |
| 732 change_processor_->CommitChangesFromSyncModel(); | |
| 733 | |
| 734 // Nothing interesting happens on the client when it gets an update | |
| 735 // of an unknown preference. We just should not crash. | |
| 736 } | |
| 737 | |
| 738 TEST_F(ProfileSyncServicePreferenceTest, ManagedPreferences) { | |
| 739 // Make the homepage preference managed. | |
| 740 base::StringValue managed_value("http://example.com"); | |
| 741 prefs_->SetManagedPref(prefs::kHomePage, managed_value.DeepCopy()); | |
| 742 | |
| 743 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 744 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 745 ASSERT_TRUE(create_root.success()); | |
| 746 | |
| 747 // Changing the homepage preference should not sync anything. | |
| 748 base::StringValue user_value("http://chromium..com"); | |
| 749 prefs_->SetUserPref(prefs::kHomePage, user_value.DeepCopy()); | |
| 750 EXPECT_EQ(NULL, GetSyncedValue(prefs::kHomePage)); | |
| 751 | |
| 752 // An incoming sync transaction should change the user value, not the managed | |
| 753 // value. | |
| 754 base::StringValue sync_value("http://crbug.com"); | |
| 755 int64 node_id = SetSyncedValue(prefs::kHomePage, sync_value); | |
| 756 ASSERT_NE(node_id, syncer::kInvalidId); | |
| 757 { | |
| 758 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 759 change_processor_->ApplyChangesFromSyncModel( | |
| 760 &trans, 0, | |
| 761 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList( | |
| 762 node_id, ChangeRecord::ACTION_UPDATE)); | |
| 763 } | |
| 764 change_processor_->CommitChangesFromSyncModel(); | |
| 765 | |
| 766 EXPECT_TRUE(managed_value.Equals(prefs_->GetManagedPref(prefs::kHomePage))); | |
| 767 EXPECT_TRUE(sync_value.Equals(prefs_->GetUserPref(prefs::kHomePage))); | |
| 768 } | |
| 769 | |
| 770 // List preferences have special handling at association time due to our ability | |
| 771 // to merge the local and sync value. Make sure the merge logic doesn't merge | |
| 772 // managed preferences. | |
| 773 TEST_F(ProfileSyncServicePreferenceTest, ManagedListPreferences) { | |
| 774 // Make the list of urls to restore on startup managed. | |
| 775 base::ListValue managed_value; | |
| 776 managed_value.Append(new base::StringValue(example_url0_)); | |
| 777 managed_value.Append(new base::StringValue(example_url1_)); | |
| 778 prefs_->SetManagedPref(prefs::kURLsToRestoreOnStartup, | |
| 779 managed_value.DeepCopy()); | |
| 780 | |
| 781 // Set a cloud version. | |
| 782 PreferenceValues cloud_data; | |
| 783 STLValueDeleter<PreferenceValues> cloud_data_deleter(&cloud_data); | |
| 784 base::ListValue* urls_to_restore = new base::ListValue; | |
| 785 urls_to_restore->Append(new base::StringValue(example_url1_)); | |
| 786 urls_to_restore->Append(new base::StringValue(example_url2_)); | |
| 787 cloud_data[prefs::kURLsToRestoreOnStartup] = urls_to_restore; | |
| 788 | |
| 789 // Start sync and verify the synced value didn't get merged. | |
| 790 AddPreferenceEntriesHelper helper(this, cloud_data); | |
| 791 ASSERT_TRUE(StartSyncService(helper.callback(), false)); | |
| 792 ASSERT_TRUE(helper.success()); | |
| 793 scoped_ptr<const base::Value> actual( | |
| 794 GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 795 EXPECT_TRUE(cloud_data[prefs::kURLsToRestoreOnStartup]->Equals(actual.get())); | |
| 796 | |
| 797 // Changing the user's urls to restore on startup pref should not sync | |
| 798 // anything. | |
| 799 base::ListValue user_value; | |
| 800 user_value.Append(new base::StringValue("http://chromium.org")); | |
| 801 prefs_->SetUserPref(prefs::kURLsToRestoreOnStartup, user_value.DeepCopy()); | |
| 802 actual.reset(GetSyncedValue(prefs::kURLsToRestoreOnStartup)); | |
| 803 EXPECT_TRUE(cloud_data[prefs::kURLsToRestoreOnStartup]->Equals(actual.get())); | |
| 804 | |
| 805 // An incoming sync transaction should change the user value, not the managed | |
| 806 // value. | |
| 807 base::ListValue sync_value; | |
| 808 sync_value.Append(new base::StringValue("http://crbug.com")); | |
| 809 int64 node_id = SetSyncedValue(prefs::kURLsToRestoreOnStartup, sync_value); | |
| 810 ASSERT_NE(node_id, syncer::kInvalidId); | |
| 811 { | |
| 812 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 813 change_processor_->ApplyChangesFromSyncModel( | |
| 814 &trans, 0, | |
| 815 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList( | |
| 816 node_id, ChangeRecord::ACTION_UPDATE)); | |
| 817 } | |
| 818 change_processor_->CommitChangesFromSyncModel(); | |
| 819 | |
| 820 EXPECT_TRUE(managed_value.Equals( | |
| 821 prefs_->GetManagedPref(prefs::kURLsToRestoreOnStartup))); | |
| 822 EXPECT_TRUE(sync_value.Equals( | |
| 823 prefs_->GetUserPref(prefs::kURLsToRestoreOnStartup))); | |
| 824 } | |
| 825 | |
| 826 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedPreferences) { | |
| 827 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 828 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 829 ASSERT_TRUE(create_root.success()); | |
| 830 | |
| 831 base::StringValue initial_value("http://example.com/initial"); | |
| 832 profile_->GetPrefs()->Set(prefs::kHomePage, initial_value); | |
| 833 scoped_ptr<const base::Value> actual(GetSyncedValue(prefs::kHomePage)); | |
| 834 ASSERT_TRUE(actual.get()); | |
| 835 EXPECT_TRUE(initial_value.Equals(actual.get())); | |
| 836 | |
| 837 // Switch kHomePage to managed and set a different value. | |
| 838 base::StringValue managed_value("http://example.com/managed"); | |
| 839 profile_->GetTestingPrefService()->SetManagedPref(prefs::kHomePage, | |
| 840 managed_value.DeepCopy()); | |
| 841 | |
| 842 // The pref value should be the one dictated by policy. | |
| 843 EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(prefs::kHomePage))); | |
| 844 | |
| 845 // Switch kHomePage back to unmanaged. | |
| 846 profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage); | |
| 847 | |
| 848 // The original value should be picked up. | |
| 849 EXPECT_TRUE(initial_value.Equals(&GetPreferenceValue(prefs::kHomePage))); | |
| 850 } | |
| 851 | |
| 852 TEST_F(ProfileSyncServicePreferenceTest, | |
| 853 DynamicManagedPreferencesWithSyncChange) { | |
| 854 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 855 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 856 ASSERT_TRUE(create_root.success()); | |
| 857 | |
| 858 base::StringValue initial_value("http://example.com/initial"); | |
| 859 profile_->GetPrefs()->Set(prefs::kHomePage, initial_value); | |
| 860 scoped_ptr<const base::Value> actual(GetSyncedValue(prefs::kHomePage)); | |
| 861 EXPECT_TRUE(initial_value.Equals(actual.get())); | |
| 862 | |
| 863 // Switch kHomePage to managed and set a different value. | |
| 864 base::StringValue managed_value("http://example.com/managed"); | |
| 865 profile_->GetTestingPrefService()->SetManagedPref(prefs::kHomePage, | |
| 866 managed_value.DeepCopy()); | |
| 867 | |
| 868 // Change the sync value. | |
| 869 base::StringValue sync_value("http://example.com/sync"); | |
| 870 int64 node_id = SetSyncedValue(prefs::kHomePage, sync_value); | |
| 871 ASSERT_NE(node_id, syncer::kInvalidId); | |
| 872 { | |
| 873 syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); | |
| 874 change_processor_->ApplyChangesFromSyncModel( | |
| 875 &trans, 0, | |
| 876 ProfileSyncServiceTestHelper::MakeSingletonChangeRecordList( | |
| 877 node_id, ChangeRecord::ACTION_ADD)); | |
| 878 } | |
| 879 change_processor_->CommitChangesFromSyncModel(); | |
| 880 | |
| 881 // The pref value should still be the one dictated by policy. | |
| 882 EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(prefs::kHomePage))); | |
| 883 | |
| 884 // Switch kHomePage back to unmanaged. | |
| 885 profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage); | |
| 886 | |
| 887 // Sync value should be picked up. | |
| 888 EXPECT_TRUE(sync_value.Equals(&GetPreferenceValue(prefs::kHomePage))); | |
| 889 } | |
| 890 | |
| 891 TEST_F(ProfileSyncServicePreferenceTest, DynamicManagedDefaultPreferences) { | |
| 892 const PrefService::Preference* pref = | |
| 893 prefs_->FindPreference(prefs::kHomePage); | |
| 894 EXPECT_TRUE(pref->IsDefaultValue()); | |
| 895 CreateRootHelper create_root(this, syncer::PREFERENCES); | |
| 896 ASSERT_TRUE(StartSyncService(create_root.callback(), false)); | |
| 897 ASSERT_TRUE(create_root.success()); | |
| 898 EXPECT_TRUE(IsSynced(prefs::kHomePage)); | |
| 899 EXPECT_TRUE(pref->IsDefaultValue()); | |
| 900 EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL); | |
| 901 // Switch kHomePage to managed and set a different value. | |
| 902 base::StringValue managed_value("http://example.com/managed"); | |
| 903 profile_->GetTestingPrefService()->SetManagedPref(prefs::kHomePage, | |
| 904 managed_value.DeepCopy()); | |
| 905 // The pref value should be the one dictated by policy. | |
| 906 EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(prefs::kHomePage))); | |
| 907 EXPECT_FALSE(pref->IsDefaultValue()); | |
| 908 // There should be no synced value. | |
| 909 EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL); | |
| 910 // Switch kHomePage back to unmanaged. | |
| 911 profile_->GetTestingPrefService()->RemoveManagedPref(prefs::kHomePage); | |
| 912 // The original value should be picked up. | |
| 913 EXPECT_TRUE(pref->IsDefaultValue()); | |
| 914 // There should still be no synced value. | |
| 915 EXPECT_TRUE(GetSyncedValue(prefs::kHomePage) == NULL); | |
| 916 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 258753002:
prefs / sync: rewrite ProfileSyncServicePreferenceTest to rely on sync/api instead of c/b/s/glue. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src