OLD | NEW |
| (Empty) |
1 // Copyright 2014 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 "components/syncable_prefs/pref_service_syncable.h" | |
6 | |
7 #include <stdint.h> | |
8 | |
9 #include "base/json/json_reader.h" | |
10 #include "base/json/json_string_value_serializer.h" | |
11 #include "base/json/json_writer.h" | |
12 #include "base/macros.h" | |
13 #include "base/memory/ptr_util.h" | |
14 #include "base/message_loop/message_loop.h" | |
15 #include "base/strings/utf_string_conversions.h" | |
16 #include "components/pref_registry/pref_registry_syncable.h" | |
17 #include "components/prefs/scoped_user_pref_update.h" | |
18 #include "components/sync/model/attachments/attachment_id.h" | |
19 #include "components/sync/model/attachments/attachment_service_proxy_for_test.h" | |
20 #include "components/sync/model/sync_change.h" | |
21 #include "components/sync/model/sync_data.h" | |
22 #include "components/sync/model/sync_error_factory_mock.h" | |
23 #include "components/sync/model/syncable_service.h" | |
24 #include "components/sync/protocol/preference_specifics.pb.h" | |
25 #include "components/sync/protocol/sync.pb.h" | |
26 #include "components/syncable_prefs/pref_model_associator.h" | |
27 #include "components/syncable_prefs/pref_model_associator_client.h" | |
28 #include "components/syncable_prefs/testing_pref_service_syncable.h" | |
29 #include "testing/gtest/include/gtest/gtest.h" | |
30 | |
31 using syncer::SyncChange; | |
32 using syncer::SyncData; | |
33 | |
34 namespace syncable_prefs { | |
35 | |
36 namespace { | |
37 | |
38 const char kExampleUrl0[] = "http://example.com/0"; | |
39 const char kExampleUrl1[] = "http://example.com/1"; | |
40 const char kExampleUrl2[] = "http://example.com/2"; | |
41 const char kStringPrefName[] = "string_pref_name"; | |
42 const char kListPrefName[] = "list_pref_name"; | |
43 const char kUnsyncedPreferenceName[] = "nonsense_pref_name"; | |
44 const char kUnsyncedPreferenceDefaultValue[] = "default"; | |
45 const char kDefaultCharsetPrefName[] = "default_charset"; | |
46 const char kNonDefaultCharsetValue[] = "foo"; | |
47 const char kDefaultCharsetValue[] = "utf-8"; | |
48 | |
49 void Increment(int* num) { | |
50 (*num)++; | |
51 } | |
52 | |
53 class TestPrefModelAssociatorClient : public PrefModelAssociatorClient { | |
54 public: | |
55 TestPrefModelAssociatorClient() {} | |
56 ~TestPrefModelAssociatorClient() override {} | |
57 | |
58 // PrefModelAssociatorClient implementation. | |
59 bool IsMergeableListPreference(const std::string& pref_name) const override { | |
60 return pref_name == kListPrefName; | |
61 } | |
62 | |
63 bool IsMergeableDictionaryPreference( | |
64 const std::string& pref_name) const override { | |
65 return false; | |
66 } | |
67 | |
68 private: | |
69 DISALLOW_COPY_AND_ASSIGN(TestPrefModelAssociatorClient); | |
70 }; | |
71 | |
72 class TestSyncProcessorStub : public syncer::SyncChangeProcessor { | |
73 public: | |
74 explicit TestSyncProcessorStub(syncer::SyncChangeList* output) | |
75 : output_(output), fail_next_(false) {} | |
76 syncer::SyncError ProcessSyncChanges( | |
77 const tracked_objects::Location& from_here, | |
78 const syncer::SyncChangeList& change_list) override { | |
79 if (output_) | |
80 output_->insert(output_->end(), change_list.begin(), change_list.end()); | |
81 if (fail_next_) { | |
82 fail_next_ = false; | |
83 return syncer::SyncError( | |
84 FROM_HERE, syncer::SyncError::DATATYPE_ERROR, "Error", | |
85 syncer::PREFERENCES); | |
86 } | |
87 return syncer::SyncError(); | |
88 } | |
89 | |
90 void FailNextProcessSyncChanges() { | |
91 fail_next_ = true; | |
92 } | |
93 | |
94 syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override { | |
95 return syncer::SyncDataList(); | |
96 } | |
97 private: | |
98 syncer::SyncChangeList* output_; | |
99 bool fail_next_; | |
100 }; | |
101 | |
102 class PrefServiceSyncableTest : public testing::Test { | |
103 public: | |
104 PrefServiceSyncableTest() | |
105 : pref_sync_service_(NULL), | |
106 test_processor_(NULL), | |
107 next_pref_remote_sync_node_id_(0) {} | |
108 | |
109 void SetUp() override { | |
110 prefs_.SetPrefModelAssociatorClientForTesting(&client_); | |
111 prefs_.registry()->RegisterStringPref(kUnsyncedPreferenceName, | |
112 kUnsyncedPreferenceDefaultValue); | |
113 prefs_.registry()->RegisterStringPref( | |
114 kStringPrefName, | |
115 std::string(), | |
116 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); | |
117 prefs_.registry()->RegisterListPref( | |
118 kListPrefName, | |
119 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); | |
120 prefs_.registry()->RegisterStringPref( | |
121 kDefaultCharsetPrefName, | |
122 kDefaultCharsetValue, | |
123 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); | |
124 | |
125 pref_sync_service_ = reinterpret_cast<PrefModelAssociator*>( | |
126 prefs_.GetSyncableService(syncer::PREFERENCES)); | |
127 ASSERT_TRUE(pref_sync_service_); | |
128 } | |
129 | |
130 syncer::SyncChange MakeRemoteChange(int64_t id, | |
131 const std::string& name, | |
132 const base::Value& value, | |
133 SyncChange::SyncChangeType type) { | |
134 std::string serialized; | |
135 JSONStringValueSerializer json(&serialized); | |
136 if (!json.Serialize(value)) | |
137 return syncer::SyncChange(); | |
138 sync_pb::EntitySpecifics entity; | |
139 sync_pb::PreferenceSpecifics* pref_one = entity.mutable_preference(); | |
140 pref_one->set_name(name); | |
141 pref_one->set_value(serialized); | |
142 return syncer::SyncChange( | |
143 FROM_HERE, | |
144 type, | |
145 syncer::SyncData::CreateRemoteData( | |
146 id, | |
147 entity, | |
148 base::Time(), | |
149 syncer::AttachmentIdList(), | |
150 syncer::AttachmentServiceProxyForTest::Create())); | |
151 } | |
152 | |
153 void AddToRemoteDataList(const std::string& name, | |
154 const base::Value& value, | |
155 syncer::SyncDataList* out) { | |
156 std::string serialized; | |
157 JSONStringValueSerializer json(&serialized); | |
158 ASSERT_TRUE(json.Serialize(value)); | |
159 sync_pb::EntitySpecifics one; | |
160 sync_pb::PreferenceSpecifics* pref_one = one.mutable_preference(); | |
161 pref_one->set_name(name); | |
162 pref_one->set_value(serialized); | |
163 out->push_back(SyncData::CreateRemoteData( | |
164 ++next_pref_remote_sync_node_id_, | |
165 one, | |
166 base::Time(), | |
167 syncer::AttachmentIdList(), | |
168 syncer::AttachmentServiceProxyForTest::Create())); | |
169 } | |
170 | |
171 void InitWithSyncDataTakeOutput(const syncer::SyncDataList& initial_data, | |
172 syncer::SyncChangeList* output) { | |
173 test_processor_ = new TestSyncProcessorStub(output); | |
174 syncer::SyncMergeResult r = pref_sync_service_->MergeDataAndStartSyncing( | |
175 syncer::PREFERENCES, initial_data, base::WrapUnique(test_processor_), | |
176 base::MakeUnique<syncer::SyncErrorFactoryMock>()); | |
177 EXPECT_FALSE(r.error().IsSet()); | |
178 } | |
179 | |
180 void InitWithNoSyncData() { | |
181 InitWithSyncDataTakeOutput(syncer::SyncDataList(), NULL); | |
182 } | |
183 | |
184 const base::Value& GetPreferenceValue(const std::string& name) { | |
185 const PrefService::Preference* preference = | |
186 prefs_.FindPreference(name.c_str()); | |
187 return *preference->GetValue(); | |
188 } | |
189 | |
190 std::unique_ptr<base::Value> FindValue(const std::string& name, | |
191 const syncer::SyncChangeList& list) { | |
192 syncer::SyncChangeList::const_iterator it = list.begin(); | |
193 for (; it != list.end(); ++it) { | |
194 if (syncer::SyncDataLocal(it->sync_data()).GetTag() == name) { | |
195 return base::JSONReader::Read( | |
196 it->sync_data().GetSpecifics().preference().value()); | |
197 } | |
198 } | |
199 return nullptr; | |
200 } | |
201 | |
202 bool IsSynced(const std::string& pref_name) { | |
203 return pref_sync_service_->registered_preferences().count(pref_name) > 0; | |
204 } | |
205 | |
206 bool HasSyncData(const std::string& pref_name) { | |
207 return pref_sync_service_->IsPrefSynced(pref_name); | |
208 } | |
209 | |
210 PrefService* GetPrefs() { return &prefs_; } | |
211 TestingPrefServiceSyncable* GetTestingPrefService() { return &prefs_; } | |
212 | |
213 protected: | |
214 TestPrefModelAssociatorClient client_; | |
215 TestingPrefServiceSyncable prefs_; | |
216 | |
217 PrefModelAssociator* pref_sync_service_; | |
218 TestSyncProcessorStub* test_processor_; | |
219 | |
220 // TODO(tim): Remove this by fixing AttachmentServiceProxyForTest. | |
221 base::MessageLoop loop_; | |
222 | |
223 int next_pref_remote_sync_node_id_; | |
224 }; | |
225 | |
226 TEST_F(PrefServiceSyncableTest, CreatePrefSyncData) { | |
227 prefs_.SetString(kStringPrefName, kExampleUrl0); | |
228 | |
229 const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName); | |
230 syncer::SyncData sync_data; | |
231 EXPECT_TRUE(pref_sync_service_->CreatePrefSyncData(pref->name(), | |
232 *pref->GetValue(), &sync_data)); | |
233 EXPECT_EQ(std::string(kStringPrefName), | |
234 syncer::SyncDataLocal(sync_data).GetTag()); | |
235 const sync_pb::PreferenceSpecifics& specifics(sync_data.GetSpecifics(). | |
236 preference()); | |
237 EXPECT_EQ(std::string(kStringPrefName), specifics.name()); | |
238 | |
239 std::unique_ptr<base::Value> value = | |
240 base::JSONReader::Read(specifics.value()); | |
241 EXPECT_TRUE(pref->GetValue()->Equals(value.get())); | |
242 } | |
243 | |
244 TEST_F(PrefServiceSyncableTest, ModelAssociationDoNotSyncDefaults) { | |
245 const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName); | |
246 EXPECT_TRUE(pref->IsDefaultValue()); | |
247 syncer::SyncChangeList out; | |
248 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
249 | |
250 EXPECT_TRUE(IsSynced(kStringPrefName)); | |
251 EXPECT_TRUE(pref->IsDefaultValue()); | |
252 EXPECT_FALSE(FindValue(kStringPrefName, out).get()); | |
253 } | |
254 | |
255 TEST_F(PrefServiceSyncableTest, ModelAssociationEmptyCloud) { | |
256 prefs_.SetString(kStringPrefName, kExampleUrl0); | |
257 { | |
258 ListPrefUpdate update(GetPrefs(), kListPrefName); | |
259 base::ListValue* url_list = update.Get(); | |
260 url_list->AppendString(kExampleUrl0); | |
261 url_list->AppendString(kExampleUrl1); | |
262 } | |
263 syncer::SyncChangeList out; | |
264 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
265 | |
266 std::unique_ptr<base::Value> value(FindValue(kStringPrefName, out)); | |
267 ASSERT_TRUE(value.get()); | |
268 EXPECT_TRUE(GetPreferenceValue(kStringPrefName).Equals(value.get())); | |
269 value = FindValue(kListPrefName, out); | |
270 ASSERT_TRUE(value.get()); | |
271 EXPECT_TRUE(GetPreferenceValue(kListPrefName).Equals(value.get())); | |
272 } | |
273 | |
274 TEST_F(PrefServiceSyncableTest, ModelAssociationCloudHasData) { | |
275 prefs_.SetString(kStringPrefName, kExampleUrl0); | |
276 { | |
277 ListPrefUpdate update(GetPrefs(), kListPrefName); | |
278 base::ListValue* url_list = update.Get(); | |
279 url_list->AppendString(kExampleUrl0); | |
280 url_list->AppendString(kExampleUrl1); | |
281 } | |
282 | |
283 syncer::SyncDataList in; | |
284 syncer::SyncChangeList out; | |
285 AddToRemoteDataList(kStringPrefName, base::StringValue(kExampleUrl1), &in); | |
286 base::ListValue urls_to_restore; | |
287 urls_to_restore.AppendString(kExampleUrl1); | |
288 urls_to_restore.AppendString(kExampleUrl2); | |
289 AddToRemoteDataList(kListPrefName, urls_to_restore, &in); | |
290 AddToRemoteDataList(kDefaultCharsetPrefName, | |
291 base::StringValue(kNonDefaultCharsetValue), | |
292 &in); | |
293 InitWithSyncDataTakeOutput(in, &out); | |
294 | |
295 ASSERT_FALSE(FindValue(kStringPrefName, out).get()); | |
296 ASSERT_FALSE(FindValue(kDefaultCharsetPrefName, out).get()); | |
297 | |
298 EXPECT_EQ(kExampleUrl1, prefs_.GetString(kStringPrefName)); | |
299 | |
300 std::unique_ptr<base::ListValue> expected_urls(new base::ListValue); | |
301 expected_urls->AppendString(kExampleUrl1); | |
302 expected_urls->AppendString(kExampleUrl2); | |
303 expected_urls->AppendString(kExampleUrl0); | |
304 std::unique_ptr<base::Value> value(FindValue(kListPrefName, out)); | |
305 ASSERT_TRUE(value.get()); | |
306 EXPECT_TRUE(value->Equals(expected_urls.get())); | |
307 EXPECT_TRUE(GetPreferenceValue(kListPrefName).Equals(expected_urls.get())); | |
308 EXPECT_EQ(kNonDefaultCharsetValue, prefs_.GetString(kDefaultCharsetPrefName)); | |
309 } | |
310 | |
311 TEST_F(PrefServiceSyncableTest, FailModelAssociation) { | |
312 syncer::SyncChangeList output; | |
313 TestSyncProcessorStub* stub = new TestSyncProcessorStub(&output); | |
314 stub->FailNextProcessSyncChanges(); | |
315 syncer::SyncMergeResult r = pref_sync_service_->MergeDataAndStartSyncing( | |
316 syncer::PREFERENCES, syncer::SyncDataList(), base::WrapUnique(stub), | |
317 base::MakeUnique<syncer::SyncErrorFactoryMock>()); | |
318 EXPECT_TRUE(r.error().IsSet()); | |
319 } | |
320 | |
321 TEST_F(PrefServiceSyncableTest, UpdatedPreferenceWithDefaultValue) { | |
322 const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName); | |
323 EXPECT_TRUE(pref->IsDefaultValue()); | |
324 | |
325 syncer::SyncChangeList out; | |
326 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
327 out.clear(); | |
328 | |
329 base::StringValue expected(kExampleUrl0); | |
330 GetPrefs()->Set(kStringPrefName, expected); | |
331 | |
332 std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out)); | |
333 ASSERT_TRUE(actual.get()); | |
334 EXPECT_TRUE(expected.Equals(actual.get())); | |
335 } | |
336 | |
337 TEST_F(PrefServiceSyncableTest, UpdatedPreferenceWithValue) { | |
338 GetPrefs()->SetString(kStringPrefName, kExampleUrl0); | |
339 syncer::SyncChangeList out; | |
340 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
341 out.clear(); | |
342 | |
343 base::StringValue expected(kExampleUrl1); | |
344 GetPrefs()->Set(kStringPrefName, expected); | |
345 | |
346 std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out)); | |
347 ASSERT_TRUE(actual.get()); | |
348 EXPECT_TRUE(expected.Equals(actual.get())); | |
349 } | |
350 | |
351 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeActionUpdate) { | |
352 GetPrefs()->SetString(kStringPrefName, kExampleUrl0); | |
353 InitWithNoSyncData(); | |
354 | |
355 base::StringValue expected(kExampleUrl1); | |
356 syncer::SyncChangeList list; | |
357 list.push_back(MakeRemoteChange( | |
358 1, kStringPrefName, expected, SyncChange::ACTION_UPDATE)); | |
359 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
360 | |
361 const base::Value& actual = GetPreferenceValue(kStringPrefName); | |
362 EXPECT_TRUE(expected.Equals(&actual)); | |
363 } | |
364 | |
365 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeActionAdd) { | |
366 InitWithNoSyncData(); | |
367 | |
368 base::StringValue expected(kExampleUrl0); | |
369 syncer::SyncChangeList list; | |
370 list.push_back(MakeRemoteChange( | |
371 1, kStringPrefName, expected, SyncChange::ACTION_ADD)); | |
372 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
373 | |
374 const base::Value& actual = GetPreferenceValue(kStringPrefName); | |
375 EXPECT_TRUE(expected.Equals(&actual)); | |
376 EXPECT_EQ(1U, | |
377 pref_sync_service_->registered_preferences().count(kStringPrefName)); | |
378 } | |
379 | |
380 TEST_F(PrefServiceSyncableTest, UpdatedSyncNodeUnknownPreference) { | |
381 InitWithNoSyncData(); | |
382 syncer::SyncChangeList list; | |
383 base::StringValue expected(kExampleUrl0); | |
384 list.push_back(MakeRemoteChange( | |
385 1, "unknown preference", expected, SyncChange::ACTION_UPDATE)); | |
386 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
387 // Nothing interesting happens on the client when it gets an update | |
388 // of an unknown preference. We just should not crash. | |
389 } | |
390 | |
391 TEST_F(PrefServiceSyncableTest, ManagedPreferences) { | |
392 // Make the homepage preference managed. | |
393 base::StringValue managed_value("http://example.com"); | |
394 prefs_.SetManagedPref(kStringPrefName, managed_value.DeepCopy()); | |
395 | |
396 syncer::SyncChangeList out; | |
397 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
398 out.clear(); | |
399 | |
400 // Changing the homepage preference should not sync anything. | |
401 base::StringValue user_value("http://chromium..com"); | |
402 prefs_.SetUserPref(kStringPrefName, user_value.DeepCopy()); | |
403 EXPECT_TRUE(out.empty()); | |
404 | |
405 // An incoming sync transaction should change the user value, not the managed | |
406 // value. | |
407 base::StringValue sync_value("http://crbug.com"); | |
408 syncer::SyncChangeList list; | |
409 list.push_back(MakeRemoteChange( | |
410 1, kStringPrefName, sync_value, SyncChange::ACTION_UPDATE)); | |
411 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
412 | |
413 EXPECT_TRUE(managed_value.Equals(prefs_.GetManagedPref(kStringPrefName))); | |
414 EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(kStringPrefName))); | |
415 } | |
416 | |
417 // List preferences have special handling at association time due to our ability | |
418 // to merge the local and sync value. Make sure the merge logic doesn't merge | |
419 // managed preferences. | |
420 TEST_F(PrefServiceSyncableTest, ManagedListPreferences) { | |
421 // Make the list of urls to restore on startup managed. | |
422 base::ListValue managed_value; | |
423 managed_value.AppendString(kExampleUrl0); | |
424 managed_value.AppendString(kExampleUrl1); | |
425 prefs_.SetManagedPref(kListPrefName, managed_value.DeepCopy()); | |
426 | |
427 // Set a cloud version. | |
428 syncer::SyncDataList in; | |
429 syncer::SyncChangeList out; | |
430 base::ListValue urls_to_restore; | |
431 urls_to_restore.AppendString(kExampleUrl1); | |
432 urls_to_restore.AppendString(kExampleUrl2); | |
433 AddToRemoteDataList(kListPrefName, urls_to_restore, &in); | |
434 | |
435 // Start sync and verify the synced value didn't get merged. | |
436 InitWithSyncDataTakeOutput(in, &out); | |
437 EXPECT_FALSE(FindValue(kListPrefName, out).get()); | |
438 out.clear(); | |
439 | |
440 // Changing the user's urls to restore on startup pref should not sync | |
441 // anything. | |
442 base::ListValue user_value; | |
443 user_value.AppendString("http://chromium.org"); | |
444 prefs_.SetUserPref(kListPrefName, user_value.DeepCopy()); | |
445 EXPECT_FALSE(FindValue(kListPrefName, out).get()); | |
446 | |
447 // An incoming sync transaction should change the user value, not the managed | |
448 // value. | |
449 base::ListValue sync_value; | |
450 sync_value.AppendString("http://crbug.com"); | |
451 syncer::SyncChangeList list; | |
452 list.push_back(MakeRemoteChange( | |
453 1, kListPrefName, sync_value, | |
454 SyncChange::ACTION_UPDATE)); | |
455 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
456 | |
457 EXPECT_TRUE(managed_value.Equals(prefs_.GetManagedPref(kListPrefName))); | |
458 EXPECT_TRUE(sync_value.Equals(prefs_.GetUserPref(kListPrefName))); | |
459 } | |
460 | |
461 TEST_F(PrefServiceSyncableTest, DynamicManagedPreferences) { | |
462 syncer::SyncChangeList out; | |
463 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
464 out.clear(); | |
465 base::StringValue initial_value("http://example.com/initial"); | |
466 GetPrefs()->Set(kStringPrefName, initial_value); | |
467 std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out)); | |
468 ASSERT_TRUE(actual.get()); | |
469 EXPECT_TRUE(initial_value.Equals(actual.get())); | |
470 | |
471 // Switch kHomePage to managed and set a different value. | |
472 base::StringValue managed_value("http://example.com/managed"); | |
473 GetTestingPrefService()->SetManagedPref(kStringPrefName, | |
474 managed_value.DeepCopy()); | |
475 | |
476 // The pref value should be the one dictated by policy. | |
477 EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kStringPrefName))); | |
478 | |
479 // Switch kHomePage back to unmanaged. | |
480 GetTestingPrefService()->RemoveManagedPref(kStringPrefName); | |
481 | |
482 // The original value should be picked up. | |
483 EXPECT_TRUE(initial_value.Equals(&GetPreferenceValue(kStringPrefName))); | |
484 } | |
485 | |
486 TEST_F(PrefServiceSyncableTest, DynamicManagedPreferencesWithSyncChange) { | |
487 syncer::SyncChangeList out; | |
488 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
489 out.clear(); | |
490 | |
491 base::StringValue initial_value("http://example.com/initial"); | |
492 GetPrefs()->Set(kStringPrefName, initial_value); | |
493 std::unique_ptr<base::Value> actual(FindValue(kStringPrefName, out)); | |
494 EXPECT_TRUE(initial_value.Equals(actual.get())); | |
495 | |
496 // Switch kHomePage to managed and set a different value. | |
497 base::StringValue managed_value("http://example.com/managed"); | |
498 GetTestingPrefService()->SetManagedPref(kStringPrefName, | |
499 managed_value.DeepCopy()); | |
500 | |
501 // Change the sync value. | |
502 base::StringValue sync_value("http://example.com/sync"); | |
503 syncer::SyncChangeList list; | |
504 list.push_back(MakeRemoteChange( | |
505 1, kStringPrefName, sync_value, SyncChange::ACTION_UPDATE)); | |
506 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
507 | |
508 // The pref value should still be the one dictated by policy. | |
509 EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kStringPrefName))); | |
510 | |
511 // Switch kHomePage back to unmanaged. | |
512 GetTestingPrefService()->RemoveManagedPref(kStringPrefName); | |
513 | |
514 // Sync value should be picked up. | |
515 EXPECT_TRUE(sync_value.Equals(&GetPreferenceValue(kStringPrefName))); | |
516 } | |
517 | |
518 TEST_F(PrefServiceSyncableTest, DynamicManagedDefaultPreferences) { | |
519 const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName); | |
520 EXPECT_TRUE(pref->IsDefaultValue()); | |
521 syncer::SyncChangeList out; | |
522 InitWithSyncDataTakeOutput(syncer::SyncDataList(), &out); | |
523 | |
524 EXPECT_TRUE(IsSynced(kStringPrefName)); | |
525 EXPECT_TRUE(pref->IsDefaultValue()); | |
526 EXPECT_FALSE(FindValue(kStringPrefName, out).get()); | |
527 out.clear(); | |
528 | |
529 // Switch kHomePage to managed and set a different value. | |
530 base::StringValue managed_value("http://example.com/managed"); | |
531 GetTestingPrefService()->SetManagedPref(kStringPrefName, | |
532 managed_value.DeepCopy()); | |
533 // The pref value should be the one dictated by policy. | |
534 EXPECT_TRUE(managed_value.Equals(&GetPreferenceValue(kStringPrefName))); | |
535 EXPECT_FALSE(pref->IsDefaultValue()); | |
536 // There should be no synced value. | |
537 EXPECT_FALSE(FindValue(kStringPrefName, out).get()); | |
538 // Switch kHomePage back to unmanaged. | |
539 GetTestingPrefService()->RemoveManagedPref(kStringPrefName); | |
540 // The original value should be picked up. | |
541 EXPECT_TRUE(pref->IsDefaultValue()); | |
542 // There should still be no synced value. | |
543 EXPECT_FALSE(FindValue(kStringPrefName, out).get()); | |
544 } | |
545 | |
546 TEST_F(PrefServiceSyncableTest, DeletePreference) { | |
547 prefs_.SetString(kStringPrefName, kExampleUrl0); | |
548 const PrefService::Preference* pref = prefs_.FindPreference(kStringPrefName); | |
549 EXPECT_FALSE(pref->IsDefaultValue()); | |
550 | |
551 InitWithNoSyncData(); | |
552 | |
553 std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue(); | |
554 syncer::SyncChangeList list; | |
555 list.push_back(MakeRemoteChange( | |
556 1, kStringPrefName, *null_value, SyncChange::ACTION_DELETE)); | |
557 pref_sync_service_->ProcessSyncChanges(FROM_HERE, list); | |
558 EXPECT_TRUE(pref->IsDefaultValue()); | |
559 } | |
560 | |
561 TEST_F(PrefServiceSyncableTest, RegisterMergeDataFinishedCallback) { | |
562 int num_callbacks = 0; | |
563 | |
564 prefs_.RegisterMergeDataFinishedCallback( | |
565 base::Bind(&Increment, &num_callbacks)); | |
566 EXPECT_EQ(0, num_callbacks); | |
567 | |
568 InitWithNoSyncData(); | |
569 EXPECT_EQ(1, num_callbacks); | |
570 } | |
571 | |
572 } // namespace | |
573 | |
574 } // namespace syncable_prefs | |
OLD | NEW |