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 "chrome/browser/chromeos/preferences.h" | 5 #include "chrome/browser/chromeos/preferences.h" |
6 | 6 |
| 7 #include "base/json/json_string_value_serializer.h" |
7 #include "base/prefs/pref_member.h" | 8 #include "base/prefs/pref_member.h" |
| 9 #include "chrome/browser/chromeos/input_method/input_method_configuration.h" |
8 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h" | 10 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h" |
9 #include "chrome/browser/chromeos/login/users/fake_user_manager.h" | 11 #include "chrome/browser/chromeos/login/users/fake_user_manager.h" |
10 #include "chrome/browser/chromeos/login/users/user_manager.h" | 12 #include "chrome/browser/chromeos/login/users/user_manager.h" |
| 13 #include "chrome/browser/chromeos/system/fake_input_device_settings.h" |
11 #include "chrome/browser/download/download_prefs.h" | 14 #include "chrome/browser/download/download_prefs.h" |
12 #include "chrome/common/pref_names.h" | 15 #include "chrome/common/pref_names.h" |
13 #include "chrome/test/base/testing_pref_service_syncable.h" | 16 #include "chrome/test/base/testing_pref_service_syncable.h" |
14 #include "components/pref_registry/pref_registry_syncable.h" | 17 #include "components/pref_registry/pref_registry_syncable.h" |
| 18 #include "sync/api/attachments/attachment_id.h" |
| 19 #include "sync/api/attachments/attachment_service_proxy_for_test.h" |
| 20 #include "sync/api/fake_sync_change_processor.h" |
| 21 #include "sync/api/sync_change.h" |
| 22 #include "sync/api/sync_data.h" |
| 23 #include "sync/api/sync_error_factory.h" |
| 24 #include "sync/api/sync_error_factory_mock.h" |
| 25 #include "sync/api/syncable_service.h" |
| 26 #include "sync/protocol/preference_specifics.pb.h" |
| 27 #include "sync/protocol/sync.pb.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 28 #include "testing/gtest/include/gtest/gtest.h" |
16 | 29 |
17 namespace chromeos { | 30 namespace chromeos { |
18 namespace { | 31 namespace { |
19 | 32 |
| 33 syncer::SyncData |
| 34 CreatePrefSyncData(const std::string& name, const base::Value& value) { |
| 35 std::string serialized; |
| 36 JSONStringValueSerializer json(&serialized); |
| 37 json.Serialize(value); |
| 38 sync_pb::EntitySpecifics specifics; |
| 39 sync_pb::PreferenceSpecifics* pref = specifics.mutable_preference(); |
| 40 pref->set_name(name); |
| 41 pref->set_value(serialized); |
| 42 return syncer::SyncData::CreateRemoteData( |
| 43 1, |
| 44 specifics, |
| 45 base::Time(), |
| 46 syncer::AttachmentIdList(), |
| 47 syncer::AttachmentServiceProxyForTest::Create()); |
| 48 } |
| 49 |
20 class MyMockInputMethodManager : public input_method::MockInputMethodManager { | 50 class MyMockInputMethodManager : public input_method::MockInputMethodManager { |
21 public: | 51 public: |
22 MyMockInputMethodManager(StringPrefMember* previous, | 52 MyMockInputMethodManager(StringPrefMember* previous, |
23 StringPrefMember* current) | 53 StringPrefMember* current) |
24 : previous_(previous), | 54 : previous_(previous), |
25 current_(current) { | 55 current_(current) { |
26 } | 56 } |
27 virtual ~MyMockInputMethodManager() { | 57 virtual ~MyMockInputMethodManager() { |
28 } | 58 } |
29 | 59 |
30 virtual void ChangeInputMethod(const std::string& input_method_id) OVERRIDE { | 60 virtual void ChangeInputMethod(const std::string& input_method_id) OVERRIDE { |
31 last_input_method_id_ = input_method_id; | 61 last_input_method_id_ = input_method_id; |
32 // Do the same thing as BrowserStateMonitor::UpdateUserPreferences. | 62 // Do the same thing as BrowserStateMonitor::UpdateUserPreferences. |
33 const std::string current_input_method_on_pref = current_->GetValue(); | 63 const std::string current_input_method_on_pref = current_->GetValue(); |
34 if (current_input_method_on_pref == input_method_id) | 64 if (current_input_method_on_pref == input_method_id) |
35 return; | 65 return; |
36 previous_->SetValue(current_input_method_on_pref); | 66 previous_->SetValue(current_input_method_on_pref); |
37 current_->SetValue(input_method_id); | 67 current_->SetValue(input_method_id); |
38 } | 68 } |
39 | 69 |
40 std::string last_input_method_id_; | 70 std::string last_input_method_id_; |
41 | 71 |
42 private: | 72 private: |
43 StringPrefMember* previous_; | 73 StringPrefMember* previous_; |
44 StringPrefMember* current_; | 74 StringPrefMember* current_; |
45 }; | 75 }; |
46 | 76 |
47 } // anonymous namespace | 77 } // anonymous namespace |
48 | 78 |
49 TEST(PreferencesTest, TestUpdatePrefOnBrowserScreenDetails) { | 79 class PreferencesTest : public testing::Test { |
50 chromeos::FakeUserManager* user_manager = new chromeos::FakeUserManager(); | 80 public: |
51 chromeos::ScopedUserManagerEnabler user_manager_enabler(user_manager); | 81 PreferencesTest() {} |
52 const char test_user_email[] = "test_user@example.com"; | 82 virtual ~PreferencesTest() {} |
53 const User* test_user = user_manager->AddUser(test_user_email); | 83 |
54 user_manager->LoginUser(test_user_email); | 84 virtual void SetUp() OVERRIDE { |
55 | 85 chromeos::FakeUserManager* user_manager = new chromeos::FakeUserManager(); |
56 TestingPrefServiceSyncable prefs; | 86 user_manager_enabler_.reset( |
57 Preferences::RegisterProfilePrefs(prefs.registry()); | 87 new chromeos::ScopedUserManagerEnabler(user_manager)); |
58 DownloadPrefs::RegisterProfilePrefs(prefs.registry()); | 88 |
59 // kSelectFileLastDirectory is registered for Profile. Here we register it for | 89 const char test_user_email[] = "test_user@example.com"; |
60 // testing. | 90 test_user_ = user_manager->AddUser(test_user_email); |
61 prefs.registry()->RegisterStringPref( | 91 user_manager->LoginUser(test_user_email); |
62 prefs::kSelectFileLastDirectory, | 92 user_manager->SwitchActiveUser(test_user_email); |
63 std::string(), | 93 |
64 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | 94 pref_service_.reset(new TestingPrefServiceSyncable); |
65 | 95 Preferences::RegisterProfilePrefs(pref_service_->registry()); |
66 StringPrefMember previous; | 96 DownloadPrefs::RegisterProfilePrefs(pref_service_->registry()); |
67 previous.Init(prefs::kLanguagePreviousInputMethod, &prefs); | 97 |
68 previous.SetValue("KeyboardA"); | 98 // kSelectFileLastDirectory is registered for Profile. Here we register it |
69 StringPrefMember current; | 99 // for testing. |
70 current.Init(prefs::kLanguageCurrentInputMethod, &prefs); | 100 pref_service_->registry()->RegisterStringPref( |
71 current.SetValue("KeyboardB"); | 101 prefs::kSelectFileLastDirectory, |
72 | 102 std::string(), |
73 MyMockInputMethodManager mock_manager(&previous, ¤t); | 103 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); |
74 Preferences testee(&mock_manager); | 104 |
75 testee.InitUserPrefsForTesting(&prefs, test_user); | 105 previous_input_method_.Init( |
76 testee.SetInputMethodListForTesting(); | 106 prefs::kLanguagePreviousInputMethod, pref_service_.get()); |
77 | 107 previous_input_method_.SetValue("KeyboardA"); |
78 // Confirm they're unchanged. | 108 current_input_method_.Init( |
79 EXPECT_EQ("KeyboardA", previous.GetValue()); | 109 prefs::kLanguageCurrentInputMethod, pref_service_.get()); |
80 EXPECT_EQ("KeyboardB", current.GetValue()); | 110 current_input_method_.SetValue("KeyboardB"); |
81 EXPECT_EQ("KeyboardB", mock_manager.last_input_method_id_); | 111 |
| 112 mock_manager_ = new MyMockInputMethodManager(&previous_input_method_, |
| 113 ¤t_input_method_); |
| 114 input_method::InitializeForTesting(mock_manager_); |
| 115 system::InputDeviceSettings::SetSettingsForTesting( |
| 116 new system::FakeInputDeviceSettings()); |
| 117 prefs_.reset(new Preferences(mock_manager_)); |
| 118 } |
| 119 |
| 120 virtual void TearDown() OVERRIDE { |
| 121 input_method::Shutdown(); |
| 122 } |
| 123 |
| 124 scoped_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_; |
| 125 const User* test_user_; |
| 126 scoped_ptr<TestingPrefServiceSyncable> pref_service_; |
| 127 StringPrefMember previous_input_method_; |
| 128 StringPrefMember current_input_method_; |
| 129 MyMockInputMethodManager* mock_manager_; |
| 130 scoped_ptr<Preferences> prefs_; |
| 131 |
| 132 private: |
| 133 DISALLOW_COPY_AND_ASSIGN(PreferencesTest); |
| 134 }; |
| 135 |
| 136 TEST_F(PreferencesTest, TestUpdatePrefOnBrowserScreenDetails) { |
| 137 prefs_->Init(pref_service_.get(), test_user_); |
| 138 |
| 139 // Confirm the current and previous input methods are unchanged. |
| 140 EXPECT_EQ("KeyboardA", previous_input_method_.GetValue()); |
| 141 EXPECT_EQ("KeyboardB", current_input_method_.GetValue()); |
| 142 EXPECT_EQ("KeyboardB", mock_manager_->last_input_method_id_); |
| 143 } |
| 144 |
| 145 class InputMethodPreferencesTest : public PreferencesTest { |
| 146 public: |
| 147 InputMethodPreferencesTest() {} |
| 148 virtual ~InputMethodPreferencesTest() {} |
| 149 |
| 150 virtual void SetUp() OVERRIDE { |
| 151 PreferencesTest::SetUp(); |
| 152 |
| 153 preferred_languages_.Init(prefs::kLanguagePreferredLanguages, |
| 154 pref_service_.get()); |
| 155 preferred_languages_syncable_.Init( |
| 156 prefs::kLanguagePreferredLanguagesSyncable, |
| 157 pref_service_.get()); |
| 158 preload_engines_.Init(prefs::kLanguagePreloadEngines, pref_service_.get()); |
| 159 preload_engines_syncable_.Init(prefs::kLanguagePreloadEnginesSyncable, |
| 160 pref_service_.get()); |
| 161 enabled_extension_imes_.Init(prefs::kLanguageEnabledExtensionImes, |
| 162 pref_service_.get()); |
| 163 enabled_extension_imes_syncable_.Init( |
| 164 prefs::kLanguageEnabledExtensionImesSyncable, pref_service_.get()); |
| 165 } |
| 166 |
| 167 // Helper function to set local language and input values. |
| 168 void SetLocalValues(const std::string& preferred_languages, |
| 169 const std::string& preload_engines, |
| 170 const std::string& enabled_extension_imes) { |
| 171 preferred_languages_.SetValue(preferred_languages); |
| 172 preload_engines_.SetValue(preload_engines); |
| 173 enabled_extension_imes_.SetValue(enabled_extension_imes); |
| 174 } |
| 175 |
| 176 // Helper function to set global language and input values. |
| 177 void SetGlobalValues(const std::string& preferred_languages, |
| 178 const std::string& preload_engines, |
| 179 const std::string& enabled_extension_imes) { |
| 180 preferred_languages_syncable_.SetValue(preferred_languages); |
| 181 preload_engines_syncable_.SetValue(preload_engines); |
| 182 enabled_extension_imes_syncable_.SetValue(enabled_extension_imes); |
| 183 } |
| 184 |
| 185 // Helper function to check local language and input values. |
| 186 void ExpectLocalValues(const std::string& preferred_languages, |
| 187 const std::string& preload_engines, |
| 188 const std::string& enabled_extension_imes) { |
| 189 EXPECT_EQ(preferred_languages, preferred_languages_.GetValue()); |
| 190 EXPECT_EQ(preload_engines, preload_engines_.GetValue()); |
| 191 EXPECT_EQ(enabled_extension_imes, enabled_extension_imes_.GetValue()); |
| 192 } |
| 193 |
| 194 // Helper function to check global language and input values. |
| 195 void ExpectGlobalValues(const std::string& preferred_languages, |
| 196 const std::string& preload_engines, |
| 197 const std::string& enabled_extension_imes) { |
| 198 EXPECT_EQ(preferred_languages, preferred_languages_syncable_.GetValue()); |
| 199 EXPECT_EQ(preload_engines, preload_engines_syncable_.GetValue()); |
| 200 EXPECT_EQ(enabled_extension_imes, |
| 201 enabled_extension_imes_syncable_.GetValue()); |
| 202 } |
| 203 |
| 204 StringPrefMember preferred_languages_; |
| 205 StringPrefMember preferred_languages_syncable_; |
| 206 StringPrefMember preload_engines_; |
| 207 StringPrefMember preload_engines_syncable_; |
| 208 StringPrefMember enabled_extension_imes_; |
| 209 StringPrefMember enabled_extension_imes_syncable_; |
| 210 |
| 211 private: |
| 212 DISALLOW_COPY_AND_ASSIGN(InputMethodPreferencesTest); |
| 213 }; |
| 214 |
| 215 TEST_F(InputMethodPreferencesTest, TestOOBEAndSync) { |
| 216 // Choose options at OOBE. |
| 217 SetLocalValues("es", "xkb-old:es", ""); |
| 218 pref_service_->SetBoolean(prefs::kLanguageShouldMergeInputMethods, true); |
| 219 |
| 220 // Initialize preferences. |
| 221 prefs_->Init(pref_service_.get(), test_user_); |
| 222 |
| 223 // Add an input method before syncing starts. |
| 224 preload_engines_.SetValue("xkb-old:es,xkb-old:us"); |
| 225 |
| 226 // Create some values to come from the server. |
| 227 syncer::SyncDataList sync_data_list; |
| 228 sync_data_list.push_back(CreatePrefSyncData( |
| 229 prefs::kLanguagePreferredLanguagesSyncable, base::StringValue("ru,fi"))); |
| 230 sync_data_list.push_back(CreatePrefSyncData( |
| 231 prefs::kLanguagePreloadEnginesSyncable, base::StringValue("xkb-old:ru"))); |
| 232 sync_data_list.push_back(CreatePrefSyncData( |
| 233 prefs::kLanguageEnabledExtensionImesSyncable, base::StringValue("ime1"))); |
| 234 |
| 235 // Sync for the first time. |
| 236 syncer::SyncableService* sync = |
| 237 pref_service_->GetSyncableService(syncer::PREFERENCES); |
| 238 sync->MergeDataAndStartSyncing(syncer::PREFERENCES, |
| 239 sync_data_list, |
| 240 scoped_ptr<syncer::SyncChangeProcessor>( |
| 241 new syncer::FakeSyncChangeProcessor), |
| 242 scoped_ptr<syncer::SyncErrorFactory>( |
| 243 new syncer::SyncErrorFactoryMock)); |
| 244 { |
| 245 SCOPED_TRACE("Server values should have merged with local values."); |
| 246 ExpectLocalValues("es,ru,fi", "xkb-old:es,xkb-old:us,xkb-old:ru", "ime1"); |
| 247 } |
| 248 |
| 249 // Update the global values from the server again. |
| 250 syncer::SyncChangeList change_list; |
| 251 change_list.push_back(syncer::SyncChange( |
| 252 FROM_HERE, |
| 253 syncer::SyncChange::ACTION_UPDATE, |
| 254 CreatePrefSyncData( |
| 255 prefs::kLanguagePreferredLanguagesSyncable, |
| 256 base::StringValue("de")))); |
| 257 change_list.push_back(syncer::SyncChange( |
| 258 FROM_HERE, |
| 259 syncer::SyncChange::ACTION_UPDATE, |
| 260 CreatePrefSyncData( |
| 261 prefs::kLanguagePreloadEnginesSyncable, |
| 262 base::StringValue("xkb-old:de")))); |
| 263 change_list.push_back(syncer::SyncChange( |
| 264 FROM_HERE, |
| 265 syncer::SyncChange::ACTION_UPDATE, |
| 266 CreatePrefSyncData( |
| 267 prefs::kLanguageEnabledExtensionImesSyncable, |
| 268 base::StringValue("ime2")))); |
| 269 sync->ProcessSyncChanges(FROM_HERE, change_list); |
| 270 |
| 271 { |
| 272 SCOPED_TRACE("Local preferences should have remained the same."); |
| 273 ExpectLocalValues("es,ru,fi", "xkb-old:es,xkb-old:us,xkb-old:ru", "ime1"); |
| 274 } |
| 275 { |
| 276 // Change local preferences. |
| 277 SCOPED_TRACE("Global preferences should have been updated."); |
| 278 SetLocalValues("jp", "xkb-old:jp", "ime2"); |
| 279 ExpectGlobalValues("jp", "xkb-old:jp", "ime2"); |
| 280 } |
| 281 } |
| 282 |
| 283 TEST_F(InputMethodPreferencesTest, TestLogIn) { |
| 284 // Set up existing preference values. |
| 285 SetLocalValues("es", "xkb-old:es", "ime1"); |
| 286 SetGlobalValues("es", "xkb-old:es", "ime1"); |
| 287 pref_service_->SetBoolean(prefs::kLanguageShouldMergeInputMethods, false); |
| 288 |
| 289 // Initialize preferences. |
| 290 prefs_->Init(pref_service_.get(), test_user_); |
| 291 |
| 292 // Create some values to come from the server. |
| 293 syncer::SyncDataList sync_data_list; |
| 294 sync_data_list.push_back(CreatePrefSyncData( |
| 295 prefs::kLanguagePreferredLanguages, base::StringValue("ru,fi"))); |
| 296 sync_data_list.push_back(CreatePrefSyncData( |
| 297 prefs::kLanguagePreloadEngines, base::StringValue("xkb-old:ru"))); |
| 298 sync_data_list.push_back(CreatePrefSyncData( |
| 299 prefs::kLanguageEnabledExtensionImes, base::StringValue("ime1"))); |
| 300 |
| 301 // Sync. |
| 302 syncer::SyncableService* sync = |
| 303 pref_service_->GetSyncableService(syncer::PREFERENCES); |
| 304 sync->MergeDataAndStartSyncing(syncer::PREFERENCES, |
| 305 sync_data_list, |
| 306 scoped_ptr<syncer::SyncChangeProcessor>( |
| 307 new syncer::FakeSyncChangeProcessor), |
| 308 scoped_ptr<syncer::SyncErrorFactory>( |
| 309 new syncer::SyncErrorFactoryMock)); |
| 310 { |
| 311 SCOPED_TRACE("Local preferences should have remained the same."); |
| 312 ExpectLocalValues("es", "xkb-old:es", "ime1"); |
| 313 } |
| 314 { |
| 315 // Change local preferences. |
| 316 SCOPED_TRACE("Global preferences should have been updated."); |
| 317 SetLocalValues("jp", "xkb-old:jp", "ime2"); |
| 318 ExpectGlobalValues("jp", "xkb-old:jp", "ime2"); |
| 319 } |
| 320 } |
| 321 |
| 322 TEST_F(InputMethodPreferencesTest, TestLogInDifferentGlobalValues) { |
| 323 // Set up existing preferences. |
| 324 SetLocalValues("es", "xkb-old:es", "ime1"); |
| 325 pref_service_->SetBoolean(prefs::kLanguageShouldMergeInputMethods, false); |
| 326 |
| 327 // The global preferences have changed since we initialized the local prefs. |
| 328 SetGlobalValues("ru", "xkb-old:ru", "ime2"); |
| 329 |
| 330 // Initialize preferences. |
| 331 prefs_->Init(pref_service_.get(), test_user_); |
| 332 { |
| 333 SCOPED_TRACE("Local preferences should have remained the same."); |
| 334 ExpectLocalValues("es", "xkb-old:es", "ime1"); |
| 335 } |
| 336 { |
| 337 // Change local preferences. |
| 338 SCOPED_TRACE("Global preferences should have been updated."); |
| 339 SetLocalValues("jp", "xkb-old:jp", "ime3"); |
| 340 ExpectGlobalValues("jp", "xkb-old:jp", "ime3"); |
| 341 } |
| 342 } |
| 343 |
| 344 TEST_F(InputMethodPreferencesTest, TestLogInLegacy) { |
| 345 // Simulate existing local preferences from M-36. |
| 346 SetLocalValues("es", "xkb-old:es", "ime1"); |
| 347 |
| 348 // Initialize preferences. |
| 349 prefs_->Init(pref_service_.get(), test_user_); |
| 350 |
| 351 // Sync. Since this is an existing profile, the local values don't change. |
| 352 syncer::SyncDataList sync_data_list; |
| 353 sync_data_list.push_back(CreatePrefSyncData( |
| 354 prefs::kLanguagePreferredLanguagesSyncable, base::StringValue("ru,fi"))); |
| 355 sync_data_list.push_back(CreatePrefSyncData( |
| 356 prefs::kLanguagePreloadEnginesSyncable, base::StringValue("xkb-old:ru"))); |
| 357 sync_data_list.push_back(CreatePrefSyncData( |
| 358 prefs::kLanguageEnabledExtensionImesSyncable, base::StringValue("ime2"))); |
| 359 |
| 360 syncer::SyncableService* sync = |
| 361 pref_service_->GetSyncableService(syncer::PREFERENCES); |
| 362 sync->MergeDataAndStartSyncing(syncer::PREFERENCES, |
| 363 sync_data_list, |
| 364 scoped_ptr<syncer::SyncChangeProcessor>( |
| 365 new syncer::FakeSyncChangeProcessor), |
| 366 scoped_ptr<syncer::SyncErrorFactory>( |
| 367 new syncer::SyncErrorFactoryMock)); |
| 368 { |
| 369 SCOPED_TRACE("Local preferences should have remained the same."); |
| 370 ExpectLocalValues("es", "xkb-old:es", "ime1"); |
| 371 } |
| 372 { |
| 373 // Change local preferences. |
| 374 SCOPED_TRACE("Global preferences should have been updated."); |
| 375 SetLocalValues("jp", "xkb-old:jp", "ime3"); |
| 376 ExpectGlobalValues("jp", "xkb-old:jp", "ime3"); |
| 377 } |
| 378 } |
| 379 |
| 380 TEST_F(InputMethodPreferencesTest, MergeStressTest) { |
| 381 SetLocalValues("es", "xkb-old:es,xkb-old:us,xkb-old:jp", ""); |
| 382 pref_service_->SetBoolean(prefs::kLanguageShouldMergeInputMethods, true); |
| 383 |
| 384 // Initialize preferences. |
| 385 prefs_->Init(pref_service_.get(), test_user_); |
| 386 |
| 387 // Change input methods and languages before syncing starts. |
| 388 SetLocalValues("en,es,jp,ar", |
| 389 "xkb-old:es,xkb-old:jp,xkb-old:dv,xkb-old:ar", |
| 390 "ime2,ime1,ime4"); |
| 391 |
| 392 // Create some tricky values to come from the server. |
| 393 syncer::SyncDataList sync_data_list; |
| 394 sync_data_list.push_back(CreatePrefSyncData( |
| 395 prefs::kLanguagePreferredLanguagesSyncable, |
| 396 base::StringValue("ar,fi,es,de,ar"))); |
| 397 sync_data_list.push_back(CreatePrefSyncData( |
| 398 prefs::kLanguagePreloadEnginesSyncable, |
| 399 base::StringValue("xkb-old:ru,xkb-old:ru,xkb-old:jp,xkb-old:jp"))); |
| 400 sync_data_list.push_back(CreatePrefSyncData( |
| 401 prefs::kLanguageEnabledExtensionImesSyncable, |
| 402 base::StringValue(""))); |
| 403 |
| 404 // Sync for the first time. |
| 405 syncer::SyncableService* sync = |
| 406 pref_service_->GetSyncableService(syncer::PREFERENCES); |
| 407 sync->MergeDataAndStartSyncing(syncer::PREFERENCES, |
| 408 sync_data_list, |
| 409 scoped_ptr<syncer::SyncChangeProcessor>( |
| 410 new syncer::FakeSyncChangeProcessor), |
| 411 scoped_ptr<syncer::SyncErrorFactory>( |
| 412 new syncer::SyncErrorFactoryMock)); |
| 413 { |
| 414 SCOPED_TRACE("Server values should have merged with local values."); |
| 415 ExpectLocalValues("en,es,jp,ar,fi,de", |
| 416 "xkb-old:es,xkb-old:jp,xkb-old:dv,xkb-old:ar,xkb-old:ru", |
| 417 "ime2,ime1,ime4"); |
| 418 } |
82 } | 419 } |
83 | 420 |
84 } // namespace chromeos | 421 } // namespace chromeos |
OLD | NEW |