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 <memory> | 5 #include <memory> |
6 #include <utility> | 6 #include <utility> |
7 | 7 |
8 #include "base/files/file_util.h" | 8 #include "base/files/file_util.h" |
9 #include "base/strings/utf_string_conversions.h" | 9 #include "base/strings/utf_string_conversions.h" |
10 #include "base/threading/thread_task_runner_handle.h" | 10 #include "base/threading/thread_task_runner_handle.h" |
(...skipping 15 matching lines...) Expand all Loading... |
26 #include "components/sync/driver/sync_prefs.h" | 26 #include "components/sync/driver/sync_prefs.h" |
27 #include "components/sync/driver/sync_service_observer.h" | 27 #include "components/sync/driver/sync_service_observer.h" |
28 #include "components/syncable_prefs/pref_service_syncable.h" | 28 #include "components/syncable_prefs/pref_service_syncable.h" |
29 #include "google_apis/gaia/gaia_auth_consumer.h" | 29 #include "google_apis/gaia/gaia_auth_consumer.h" |
30 #include "google_apis/gaia/gaia_constants.h" | 30 #include "google_apis/gaia/gaia_constants.h" |
31 #include "google_apis/gaia/oauth2_token_service.h" | 31 #include "google_apis/gaia/oauth2_token_service.h" |
32 #include "net/url_request/url_request_test_util.h" | 32 #include "net/url_request/url_request_test_util.h" |
33 #include "testing/gmock/include/gmock/gmock.h" | 33 #include "testing/gmock/include/gmock/gmock.h" |
34 #include "testing/gtest/include/gtest/gtest.h" | 34 #include "testing/gtest/include/gtest/gtest.h" |
35 | 35 |
36 using syncer::DataTypeManager; | 36 using sync_driver::DataTypeManager; |
37 using syncer::DataTypeManagerMock; | 37 using sync_driver::DataTypeManagerMock; |
38 using syncer::SyncBackendHostMock; | |
39 using testing::_; | 38 using testing::_; |
40 using testing::AnyNumber; | 39 using testing::AnyNumber; |
41 using testing::DoAll; | 40 using testing::DoAll; |
42 using testing::Mock; | 41 using testing::Mock; |
43 using testing::Return; | 42 using testing::Return; |
44 | 43 |
45 namespace browser_sync { | 44 namespace browser_sync { |
46 | 45 |
47 namespace { | 46 namespace { |
48 | 47 |
49 const char kGaiaId[] = "12345"; | 48 const char kGaiaId[] = "12345"; |
50 const char kEmail[] = "test_user@gmail.com"; | 49 const char kEmail[] = "test_user@gmail.com"; |
51 const char kDummyPassword[] = ""; | 50 const char kDummyPassword[] = ""; |
52 | 51 |
53 class SyncServiceObserverMock : public syncer::SyncServiceObserver { | 52 class SyncServiceObserverMock : public sync_driver::SyncServiceObserver { |
54 public: | 53 public: |
55 SyncServiceObserverMock(); | 54 SyncServiceObserverMock(); |
56 virtual ~SyncServiceObserverMock(); | 55 virtual ~SyncServiceObserverMock(); |
57 | 56 |
58 MOCK_METHOD0(OnStateChanged, void()); | 57 MOCK_METHOD0(OnStateChanged, void()); |
59 }; | 58 }; |
60 | 59 |
61 SyncServiceObserverMock::SyncServiceObserverMock() {} | 60 SyncServiceObserverMock::SyncServiceObserverMock() {} |
62 | 61 |
63 SyncServiceObserverMock::~SyncServiceObserverMock() {} | 62 SyncServiceObserverMock::~SyncServiceObserverMock() {} |
64 | 63 |
65 } // namespace | 64 } // namespace |
66 | 65 |
67 ACTION_P(InvokeOnConfigureStart, sync_service) { | 66 ACTION_P(InvokeOnConfigureStart, sync_service) { |
68 sync_service->OnConfigureStart(); | 67 sync_service->OnConfigureStart(); |
69 } | 68 } |
70 | 69 |
71 ACTION_P3(InvokeOnConfigureDone, sync_service, error_callback, result) { | 70 ACTION_P3(InvokeOnConfigureDone, sync_service, error_callback, result) { |
72 DataTypeManager::ConfigureResult configure_result = | 71 DataTypeManager::ConfigureResult configure_result = |
73 static_cast<DataTypeManager::ConfigureResult>(result); | 72 static_cast<DataTypeManager::ConfigureResult>(result); |
74 if (result.status == syncer::DataTypeManager::ABORTED) | 73 if (result.status == sync_driver::DataTypeManager::ABORTED) |
75 error_callback.Run(&configure_result); | 74 error_callback.Run(&configure_result); |
76 sync_service->OnConfigureDone(configure_result); | 75 sync_service->OnConfigureDone(configure_result); |
77 } | 76 } |
78 | 77 |
79 class ProfileSyncServiceStartupTest : public testing::Test { | 78 class ProfileSyncServiceStartupTest : public testing::Test { |
80 public: | 79 public: |
81 ProfileSyncServiceStartupTest() { | 80 ProfileSyncServiceStartupTest() { |
82 profile_sync_service_bundle_.auth_service() | 81 profile_sync_service_bundle_.auth_service() |
83 ->set_auto_post_fetch_response_on_message_loop(true); | 82 ->set_auto_post_fetch_response_on_message_loop(true); |
84 } | 83 } |
85 | 84 |
86 ~ProfileSyncServiceStartupTest() override { | 85 ~ProfileSyncServiceStartupTest() override { |
87 sync_service_->RemoveObserver(&observer_); | 86 sync_service_->RemoveObserver(&observer_); |
88 sync_service_->Shutdown(); | 87 sync_service_->Shutdown(); |
89 } | 88 } |
90 | 89 |
91 void CreateSyncService(ProfileSyncService::StartBehavior start_behavior) { | 90 void CreateSyncService(ProfileSyncService::StartBehavior start_behavior) { |
92 component_factory_ = profile_sync_service_bundle_.component_factory(); | 91 component_factory_ = profile_sync_service_bundle_.component_factory(); |
93 ProfileSyncServiceBundle::SyncClientBuilder builder( | 92 ProfileSyncServiceBundle::SyncClientBuilder builder( |
94 &profile_sync_service_bundle_); | 93 &profile_sync_service_bundle_); |
95 ProfileSyncService::InitParams init_params = | 94 ProfileSyncService::InitParams init_params = |
96 profile_sync_service_bundle_.CreateBasicInitParams(start_behavior, | 95 profile_sync_service_bundle_.CreateBasicInitParams(start_behavior, |
97 builder.Build()); | 96 builder.Build()); |
98 | 97 |
99 sync_service_.reset(new ProfileSyncService(std::move(init_params))); | 98 sync_service_.reset(new ProfileSyncService(std::move(init_params))); |
100 sync_service_->RegisterDataTypeController( | 99 sync_service_->RegisterDataTypeController( |
101 base::MakeUnique<syncer::FakeDataTypeController>(syncer::BOOKMARKS)); | 100 base::MakeUnique<sync_driver::FakeDataTypeController>( |
| 101 syncer::BOOKMARKS)); |
102 sync_service_->AddObserver(&observer_); | 102 sync_service_->AddObserver(&observer_); |
103 } | 103 } |
104 | 104 |
105 void IssueTestTokens(const std::string& account_id) { | 105 void IssueTestTokens(const std::string& account_id) { |
106 profile_sync_service_bundle_.auth_service()->UpdateCredentials( | 106 profile_sync_service_bundle_.auth_service()->UpdateCredentials( |
107 account_id, "oauth2_login_token"); | 107 account_id, "oauth2_login_token"); |
108 } | 108 } |
109 | 109 |
110 void SetError(DataTypeManager::ConfigureResult* result) { | 110 void SetError(DataTypeManager::ConfigureResult* result) { |
111 syncer::DataTypeStatusTable::TypeErrorMap errors; | 111 sync_driver::DataTypeStatusTable::TypeErrorMap errors; |
112 errors[syncer::BOOKMARKS] = | 112 errors[syncer::BOOKMARKS] = |
113 syncer::SyncError(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR, | 113 syncer::SyncError(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR, |
114 "Error", syncer::BOOKMARKS); | 114 "Error", syncer::BOOKMARKS); |
115 result->data_type_status_table.UpdateFailedDataTypes(errors); | 115 result->data_type_status_table.UpdateFailedDataTypes(errors); |
116 } | 116 } |
117 | 117 |
118 protected: | 118 protected: |
119 std::string SimulateTestUserSignin(ProfileSyncService* sync_service) { | 119 std::string SimulateTestUserSignin(ProfileSyncService* sync_service) { |
120 std::string account_id = | 120 std::string account_id = |
121 profile_sync_service_bundle_.account_tracker()->SeedAccountInfo(kGaiaId, | 121 profile_sync_service_bundle_.account_tracker()->SeedAccountInfo(kGaiaId, |
(...skipping 26 matching lines...) Expand all Loading... |
148 } | 148 } |
149 | 149 |
150 PrefService* pref_service() { | 150 PrefService* pref_service() { |
151 return profile_sync_service_bundle_.pref_service(); | 151 return profile_sync_service_bundle_.pref_service(); |
152 } | 152 } |
153 | 153 |
154 base::MessageLoop message_loop_; | 154 base::MessageLoop message_loop_; |
155 ProfileSyncServiceBundle profile_sync_service_bundle_; | 155 ProfileSyncServiceBundle profile_sync_service_bundle_; |
156 std::unique_ptr<ProfileSyncService> sync_service_; | 156 std::unique_ptr<ProfileSyncService> sync_service_; |
157 SyncServiceObserverMock observer_; | 157 SyncServiceObserverMock observer_; |
158 syncer::DataTypeStatusTable data_type_status_table_; | 158 sync_driver::DataTypeStatusTable data_type_status_table_; |
159 syncer::SyncApiComponentFactoryMock* component_factory_ = nullptr; | 159 SyncApiComponentFactoryMock* component_factory_ = nullptr; |
160 }; | 160 }; |
161 | 161 |
162 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest { | 162 class ProfileSyncServiceStartupCrosTest : public ProfileSyncServiceStartupTest { |
163 public: | 163 public: |
164 ProfileSyncServiceStartupCrosTest() { | 164 ProfileSyncServiceStartupCrosTest() { |
165 CreateSyncService(ProfileSyncService::AUTO_START); | 165 CreateSyncService(ProfileSyncService::AUTO_START); |
166 SimulateTestUserSignin(nullptr); | 166 SimulateTestUserSignin(nullptr); |
167 EXPECT_TRUE( | 167 EXPECT_TRUE( |
168 profile_sync_service_bundle_.signin_manager()->IsAuthenticated()); | 168 profile_sync_service_bundle_.signin_manager()->IsAuthenticated()); |
169 } | 169 } |
170 }; | 170 }; |
171 | 171 |
172 TEST_F(ProfileSyncServiceStartupTest, StartFirstTime) { | 172 TEST_F(ProfileSyncServiceStartupTest, StartFirstTime) { |
173 // We've never completed startup. | 173 // We've never completed startup. |
174 pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete); | 174 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); |
175 CreateSyncService(ProfileSyncService::MANUAL_START); | 175 CreateSyncService(ProfileSyncService::MANUAL_START); |
176 SetUpSyncBackendHost(); | 176 SetUpSyncBackendHost(); |
177 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | 177 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); |
178 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); | 178 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(0); |
179 | 179 |
180 // Should not actually start, rather just clean things up and wait | 180 // Should not actually start, rather just clean things up and wait |
181 // to be enabled. | 181 // to be enabled. |
182 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 182 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
183 sync_service_->Initialize(); | 183 sync_service_->Initialize(); |
184 | 184 |
185 // Preferences should be back to defaults. | 185 // Preferences should be back to defaults. |
186 EXPECT_EQ(0, pref_service()->GetInt64(syncer::prefs::kSyncLastSyncedTime)); | 186 EXPECT_EQ(0, |
| 187 pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); |
187 EXPECT_FALSE( | 188 EXPECT_FALSE( |
188 pref_service()->GetBoolean(syncer::prefs::kSyncFirstSetupComplete)); | 189 pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete)); |
189 Mock::VerifyAndClearExpectations(data_type_manager); | 190 Mock::VerifyAndClearExpectations(data_type_manager); |
190 | 191 |
191 // Then start things up. | 192 // Then start things up. |
192 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(1); | 193 EXPECT_CALL(*data_type_manager, Configure(_, _)).Times(1); |
193 EXPECT_CALL(*data_type_manager, state()) | 194 EXPECT_CALL(*data_type_manager, state()) |
194 .WillOnce(Return(DataTypeManager::CONFIGURED)) | 195 .WillOnce(Return(DataTypeManager::CONFIGURED)) |
195 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 196 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
196 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | 197 EXPECT_CALL(*data_type_manager, Stop()).Times(1); |
197 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 198 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
198 | 199 |
199 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | 200 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); |
200 | 201 |
201 // Simulate successful signin as test_user. | 202 // Simulate successful signin as test_user. |
202 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 203 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
203 // Create some tokens in the token service. | 204 // Create some tokens in the token service. |
204 IssueTestTokens(account_id); | 205 IssueTestTokens(account_id); |
205 | 206 |
206 // Simulate the UI telling sync it has finished setting up. | 207 // Simulate the UI telling sync it has finished setting up. |
207 sync_blocker.reset(); | 208 sync_blocker.reset(); |
208 sync_service_->SetFirstSetupComplete(); | 209 sync_service_->SetFirstSetupComplete(); |
209 EXPECT_TRUE(sync_service_->IsSyncActive()); | 210 EXPECT_TRUE(sync_service_->IsSyncActive()); |
210 } | 211 } |
211 | 212 |
212 // TODO(pavely): Reenable test once android is switched to oauth2. | 213 // TODO(pavely): Reenable test once android is switched to oauth2. |
213 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) { | 214 TEST_F(ProfileSyncServiceStartupTest, DISABLED_StartNoCredentials) { |
214 // We've never completed startup. | 215 // We've never completed startup. |
215 pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete); | 216 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); |
216 CreateSyncService(ProfileSyncService::MANUAL_START); | 217 CreateSyncService(ProfileSyncService::MANUAL_START); |
217 | 218 |
218 // Should not actually start, rather just clean things up and wait | 219 // Should not actually start, rather just clean things up and wait |
219 // to be enabled. | 220 // to be enabled. |
220 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | 221 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) |
221 .Times(0); | 222 .Times(0); |
222 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 223 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
223 sync_service_->Initialize(); | 224 sync_service_->Initialize(); |
224 | 225 |
225 // Preferences should be back to defaults. | 226 // Preferences should be back to defaults. |
226 EXPECT_EQ(0, pref_service()->GetInt64(syncer::prefs::kSyncLastSyncedTime)); | 227 EXPECT_EQ(0, |
| 228 pref_service()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime)); |
227 EXPECT_FALSE( | 229 EXPECT_FALSE( |
228 pref_service()->GetBoolean(syncer::prefs::kSyncFirstSetupComplete)); | 230 pref_service()->GetBoolean(sync_driver::prefs::kSyncFirstSetupComplete)); |
229 | 231 |
230 // Then start things up. | 232 // Then start things up. |
231 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | 233 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); |
232 | 234 |
233 // Simulate successful signin as test_user. | 235 // Simulate successful signin as test_user. |
234 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 236 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
235 | 237 |
236 profile_sync_service_bundle_.auth_service()->LoadCredentials(account_id); | 238 profile_sync_service_bundle_.auth_service()->LoadCredentials(account_id); |
237 | 239 |
238 sync_blocker.reset(); | 240 sync_blocker.reset(); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
275 sync_blocker.reset(); | 277 sync_blocker.reset(); |
276 | 278 |
277 // Verify we successfully finish startup and configuration. | 279 // Verify we successfully finish startup and configuration. |
278 EXPECT_TRUE(sync_service_->IsSyncActive()); | 280 EXPECT_TRUE(sync_service_->IsSyncActive()); |
279 } | 281 } |
280 | 282 |
281 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) { | 283 TEST_F(ProfileSyncServiceStartupCrosTest, StartCrosNoCredentials) { |
282 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | 284 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) |
283 .Times(0); | 285 .Times(0); |
284 EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)).Times(0); | 286 EXPECT_CALL(*component_factory_, CreateSyncBackendHost(_, _, _, _)).Times(0); |
285 pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete); | 287 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); |
286 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 288 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
287 | 289 |
288 sync_service_->Initialize(); | 290 sync_service_->Initialize(); |
289 // Sync should not start because there are no tokens yet. | 291 // Sync should not start because there are no tokens yet. |
290 EXPECT_FALSE(sync_service_->IsSyncActive()); | 292 EXPECT_FALSE(sync_service_->IsSyncActive()); |
291 sync_service_->SetFirstSetupComplete(); | 293 sync_service_->SetFirstSetupComplete(); |
292 | 294 |
293 // Sync should not start because there are still no tokens. | 295 // Sync should not start because there are still no tokens. |
294 EXPECT_FALSE(sync_service_->IsSyncActive()); | 296 EXPECT_FALSE(sync_service_->IsSyncActive()); |
295 } | 297 } |
296 | 298 |
297 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) { | 299 TEST_F(ProfileSyncServiceStartupCrosTest, StartFirstTime) { |
298 SetUpSyncBackendHost(); | 300 SetUpSyncBackendHost(); |
299 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | 301 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); |
300 pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete); | 302 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); |
301 EXPECT_CALL(*data_type_manager, Configure(_, _)); | 303 EXPECT_CALL(*data_type_manager, Configure(_, _)); |
302 EXPECT_CALL(*data_type_manager, state()) | 304 EXPECT_CALL(*data_type_manager, state()) |
303 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | 305 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); |
304 EXPECT_CALL(*data_type_manager, Stop()); | 306 EXPECT_CALL(*data_type_manager, Stop()); |
305 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 307 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
306 | 308 |
307 IssueTestTokens( | 309 IssueTestTokens( |
308 profile_sync_service_bundle_.account_tracker()->PickAccountIdForAccount( | 310 profile_sync_service_bundle_.account_tracker()->PickAccountIdForAccount( |
309 "12345", kEmail)); | 311 "12345", kEmail)); |
310 sync_service_->Initialize(); | 312 sync_service_->Initialize(); |
(...skipping 16 matching lines...) Expand all Loading... |
327 IssueTestTokens(account_id); | 329 IssueTestTokens(account_id); |
328 | 330 |
329 sync_service_->Initialize(); | 331 sync_service_->Initialize(); |
330 } | 332 } |
331 | 333 |
332 // Test that we can recover from a case where a bug in the code resulted in | 334 // Test that we can recover from a case where a bug in the code resulted in |
333 // OnUserChoseDatatypes not being properly called and datatype preferences | 335 // OnUserChoseDatatypes not being properly called and datatype preferences |
334 // therefore being left unset. | 336 // therefore being left unset. |
335 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) { | 337 TEST_F(ProfileSyncServiceStartupTest, StartRecoverDatatypePrefs) { |
336 // Clear the datatype preference fields (simulating bug 154940). | 338 // Clear the datatype preference fields (simulating bug 154940). |
337 pref_service()->ClearPref(syncer::prefs::kSyncKeepEverythingSynced); | 339 pref_service()->ClearPref(sync_driver::prefs::kSyncKeepEverythingSynced); |
338 syncer::ModelTypeSet user_types = syncer::UserTypes(); | 340 syncer::ModelTypeSet user_types = syncer::UserTypes(); |
339 for (syncer::ModelTypeSet::Iterator iter = user_types.First(); iter.Good(); | 341 for (syncer::ModelTypeSet::Iterator iter = user_types.First(); iter.Good(); |
340 iter.Inc()) { | 342 iter.Inc()) { |
341 pref_service()->ClearPref( | 343 pref_service()->ClearPref( |
342 syncer::SyncPrefs::GetPrefNameForDataType(iter.Get())); | 344 sync_driver::SyncPrefs::GetPrefNameForDataType(iter.Get())); |
343 } | 345 } |
344 | 346 |
345 // Pre load the tokens | 347 // Pre load the tokens |
346 CreateSyncService(ProfileSyncService::MANUAL_START); | 348 CreateSyncService(ProfileSyncService::MANUAL_START); |
347 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 349 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
348 sync_service_->SetFirstSetupComplete(); | 350 sync_service_->SetFirstSetupComplete(); |
349 SetUpSyncBackendHost(); | 351 SetUpSyncBackendHost(); |
350 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | 352 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); |
351 EXPECT_CALL(*data_type_manager, Configure(_, _)); | 353 EXPECT_CALL(*data_type_manager, Configure(_, _)); |
352 EXPECT_CALL(*data_type_manager, state()) | 354 EXPECT_CALL(*data_type_manager, state()) |
353 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | 355 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); |
354 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | 356 EXPECT_CALL(*data_type_manager, Stop()).Times(1); |
355 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 357 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
356 | 358 |
357 IssueTestTokens(account_id); | 359 IssueTestTokens(account_id); |
358 sync_service_->Initialize(); | 360 sync_service_->Initialize(); |
359 | 361 |
360 EXPECT_TRUE( | 362 EXPECT_TRUE(pref_service()->GetBoolean( |
361 pref_service()->GetBoolean(syncer::prefs::kSyncKeepEverythingSynced)); | 363 sync_driver::prefs::kSyncKeepEverythingSynced)); |
362 } | 364 } |
363 | 365 |
364 // Verify that the recovery of datatype preferences doesn't overwrite a valid | 366 // Verify that the recovery of datatype preferences doesn't overwrite a valid |
365 // case where only bookmarks are enabled. | 367 // case where only bookmarks are enabled. |
366 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) { | 368 TEST_F(ProfileSyncServiceStartupTest, StartDontRecoverDatatypePrefs) { |
367 // Explicitly set Keep Everything Synced to false and have only bookmarks | 369 // Explicitly set Keep Everything Synced to false and have only bookmarks |
368 // enabled. | 370 // enabled. |
369 pref_service()->SetBoolean(syncer::prefs::kSyncKeepEverythingSynced, false); | 371 pref_service()->SetBoolean(sync_driver::prefs::kSyncKeepEverythingSynced, |
| 372 false); |
370 | 373 |
371 // Pre load the tokens | 374 // Pre load the tokens |
372 CreateSyncService(ProfileSyncService::MANUAL_START); | 375 CreateSyncService(ProfileSyncService::MANUAL_START); |
373 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 376 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
374 sync_service_->SetFirstSetupComplete(); | 377 sync_service_->SetFirstSetupComplete(); |
375 SetUpSyncBackendHost(); | 378 SetUpSyncBackendHost(); |
376 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | 379 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); |
377 EXPECT_CALL(*data_type_manager, Configure(_, _)); | 380 EXPECT_CALL(*data_type_manager, Configure(_, _)); |
378 EXPECT_CALL(*data_type_manager, state()) | 381 EXPECT_CALL(*data_type_manager, state()) |
379 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | 382 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); |
380 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | 383 EXPECT_CALL(*data_type_manager, Stop()).Times(1); |
381 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 384 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
382 IssueTestTokens(account_id); | 385 IssueTestTokens(account_id); |
383 sync_service_->Initialize(); | 386 sync_service_->Initialize(); |
384 | 387 |
385 EXPECT_FALSE( | 388 EXPECT_FALSE(pref_service()->GetBoolean( |
386 pref_service()->GetBoolean(syncer::prefs::kSyncKeepEverythingSynced)); | 389 sync_driver::prefs::kSyncKeepEverythingSynced)); |
387 } | 390 } |
388 | 391 |
389 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) { | 392 TEST_F(ProfileSyncServiceStartupTest, ManagedStartup) { |
390 // Service should not be started by Initialize() since it's managed. | 393 // Service should not be started by Initialize() since it's managed. |
391 pref_service()->SetString(prefs::kGoogleServicesAccountId, kEmail); | 394 pref_service()->SetString(prefs::kGoogleServicesAccountId, kEmail); |
392 CreateSyncService(ProfileSyncService::MANUAL_START); | 395 CreateSyncService(ProfileSyncService::MANUAL_START); |
393 | 396 |
394 // Disable sync through policy. | 397 // Disable sync through policy. |
395 pref_service()->SetBoolean(syncer::prefs::kSyncManaged, true); | 398 pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true); |
396 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | 399 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) |
397 .Times(0); | 400 .Times(0); |
398 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 401 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
399 | 402 |
400 sync_service_->Initialize(); | 403 sync_service_->Initialize(); |
401 } | 404 } |
402 | 405 |
403 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) { | 406 TEST_F(ProfileSyncServiceStartupTest, SwitchManaged) { |
404 CreateSyncService(ProfileSyncService::MANUAL_START); | 407 CreateSyncService(ProfileSyncService::MANUAL_START); |
405 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 408 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
406 sync_service_->SetFirstSetupComplete(); | 409 sync_service_->SetFirstSetupComplete(); |
407 SetUpSyncBackendHost(); | 410 SetUpSyncBackendHost(); |
408 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | 411 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); |
409 EXPECT_CALL(*data_type_manager, Configure(_, _)); | 412 EXPECT_CALL(*data_type_manager, Configure(_, _)); |
410 EXPECT_CALL(*data_type_manager, state()) | 413 EXPECT_CALL(*data_type_manager, state()) |
411 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); | 414 .WillRepeatedly(Return(DataTypeManager::CONFIGURED)); |
412 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 415 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
413 IssueTestTokens(account_id); | 416 IssueTestTokens(account_id); |
414 sync_service_->Initialize(); | 417 sync_service_->Initialize(); |
415 EXPECT_TRUE(sync_service_->IsBackendInitialized()); | 418 EXPECT_TRUE(sync_service_->IsBackendInitialized()); |
416 EXPECT_TRUE(sync_service_->IsSyncActive()); | 419 EXPECT_TRUE(sync_service_->IsSyncActive()); |
417 | 420 |
418 // The service should stop when switching to managed mode. | 421 // The service should stop when switching to managed mode. |
419 Mock::VerifyAndClearExpectations(data_type_manager); | 422 Mock::VerifyAndClearExpectations(data_type_manager); |
420 EXPECT_CALL(*data_type_manager, state()) | 423 EXPECT_CALL(*data_type_manager, state()) |
421 .WillOnce(Return(DataTypeManager::CONFIGURED)); | 424 .WillOnce(Return(DataTypeManager::CONFIGURED)); |
422 EXPECT_CALL(*data_type_manager, Stop()).Times(1); | 425 EXPECT_CALL(*data_type_manager, Stop()).Times(1); |
423 pref_service()->SetBoolean(syncer::prefs::kSyncManaged, true); | 426 pref_service()->SetBoolean(sync_driver::prefs::kSyncManaged, true); |
424 EXPECT_FALSE(sync_service_->IsBackendInitialized()); | 427 EXPECT_FALSE(sync_service_->IsBackendInitialized()); |
425 // Note that PSS no longer references |data_type_manager| after stopping. | 428 // Note that PSS no longer references |data_type_manager| after stopping. |
426 | 429 |
427 // When switching back to unmanaged, the state should change but sync should | 430 // When switching back to unmanaged, the state should change but sync should |
428 // not start automatically because IsFirstSetupComplete() will be false. | 431 // not start automatically because IsFirstSetupComplete() will be false. |
429 // A new DataTypeManager should not be created. | 432 // A new DataTypeManager should not be created. |
430 Mock::VerifyAndClearExpectations(data_type_manager); | 433 Mock::VerifyAndClearExpectations(data_type_manager); |
431 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) | 434 EXPECT_CALL(*component_factory_, CreateDataTypeManager(_, _, _, _, _)) |
432 .Times(0); | 435 .Times(0); |
433 pref_service()->ClearPref(syncer::prefs::kSyncManaged); | 436 pref_service()->ClearPref(sync_driver::prefs::kSyncManaged); |
434 EXPECT_FALSE(sync_service_->IsBackendInitialized()); | 437 EXPECT_FALSE(sync_service_->IsBackendInitialized()); |
435 EXPECT_FALSE(sync_service_->IsSyncActive()); | 438 EXPECT_FALSE(sync_service_->IsSyncActive()); |
436 } | 439 } |
437 | 440 |
438 TEST_F(ProfileSyncServiceStartupTest, StartFailure) { | 441 TEST_F(ProfileSyncServiceStartupTest, StartFailure) { |
439 CreateSyncService(ProfileSyncService::MANUAL_START); | 442 CreateSyncService(ProfileSyncService::MANUAL_START); |
440 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 443 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
441 sync_service_->SetFirstSetupComplete(); | 444 sync_service_->SetFirstSetupComplete(); |
442 SetUpSyncBackendHost(); | 445 SetUpSyncBackendHost(); |
443 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); | 446 DataTypeManagerMock* data_type_manager = SetUpDataTypeManager(); |
(...skipping 15 matching lines...) Expand all Loading... |
459 EXPECT_TRUE(sync_service_->HasUnrecoverableError()); | 462 EXPECT_TRUE(sync_service_->HasUnrecoverableError()); |
460 } | 463 } |
461 | 464 |
462 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) { | 465 TEST_F(ProfileSyncServiceStartupTest, StartDownloadFailed) { |
463 // Pre load the tokens | 466 // Pre load the tokens |
464 CreateSyncService(ProfileSyncService::MANUAL_START); | 467 CreateSyncService(ProfileSyncService::MANUAL_START); |
465 std::string account_id = SimulateTestUserSignin(sync_service_.get()); | 468 std::string account_id = SimulateTestUserSignin(sync_service_.get()); |
466 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); | 469 SyncBackendHostMock* mock_sbh = SetUpSyncBackendHost(); |
467 mock_sbh->set_fail_initial_download(true); | 470 mock_sbh->set_fail_initial_download(true); |
468 | 471 |
469 pref_service()->ClearPref(syncer::prefs::kSyncFirstSetupComplete); | 472 pref_service()->ClearPref(sync_driver::prefs::kSyncFirstSetupComplete); |
470 | 473 |
471 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); | 474 EXPECT_CALL(observer_, OnStateChanged()).Times(AnyNumber()); |
472 sync_service_->Initialize(); | 475 sync_service_->Initialize(); |
473 | 476 |
474 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); | 477 auto sync_blocker = sync_service_->GetSetupInProgressHandle(); |
475 IssueTestTokens(account_id); | 478 IssueTestTokens(account_id); |
476 sync_blocker.reset(); | 479 sync_blocker.reset(); |
477 EXPECT_FALSE(sync_service_->IsSyncActive()); | 480 EXPECT_FALSE(sync_service_->IsSyncActive()); |
478 } | 481 } |
479 | 482 |
480 } // namespace browser_sync | 483 } // namespace browser_sync |
OLD | NEW |