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 "testing/gtest/include/gtest/gtest.h" | 5 #include "testing/gtest/include/gtest/gtest.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 &service_, | 128 &service_, |
129 dtc_mock_.get()); | 129 dtc_mock_.get()); |
130 } | 130 } |
131 | 131 |
132 virtual void TearDown() { | 132 virtual void TearDown() { |
133 db_thread_.Stop(); | 133 db_thread_.Stop(); |
134 } | 134 } |
135 | 135 |
136 protected: | 136 protected: |
137 void SetStartExpectations() { | 137 void SetStartExpectations() { |
138 EXPECT_CALL(*dtc_mock_, StartModels()).WillOnce(Return(true)); | 138 EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true)); |
139 EXPECT_CALL(model_load_callback_, Run(_, _)); | 139 EXPECT_CALL(model_load_callback_, Run(_, _)); |
140 model_associator_ = new ModelAssociatorMock(); | 140 model_associator_ = new ModelAssociatorMock(); |
141 change_processor_ = new ChangeProcessorMock(); | 141 change_processor_ = new ChangeProcessorMock(); |
142 EXPECT_CALL(*profile_sync_factory_, CreateBookmarkSyncComponents(_, _)). | 142 EXPECT_CALL(*profile_sync_factory_, CreateBookmarkSyncComponents(_, _)). |
143 WillOnce(Return(ProfileSyncComponentsFactory::SyncComponents( | 143 WillOnce(Return(ProfileSyncComponentsFactory::SyncComponents( |
144 model_associator_, change_processor_))); | 144 model_associator_, change_processor_))); |
145 } | 145 } |
146 | 146 |
147 void SetAssociateExpectations() { | 147 void SetAssociateExpectations() { |
148 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). | 148 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). |
149 WillOnce(Return(true)); | 149 WillOnce(Return(true)); |
150 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). | 150 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). |
151 WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); | 151 WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); |
152 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). | 152 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). |
153 WillOnce(Return(syncer::SyncError())); | 153 WillOnce(Return(syncer::SyncError())); |
154 EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_)); | 154 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
155 } | 155 } |
156 | 156 |
157 void SetActivateExpectations(DataTypeController::StartResult result) { | 157 void SetActivateExpectations(DataTypeController::StartResult result) { |
158 EXPECT_CALL(service_, ActivateDataType(_, _, _)); | 158 EXPECT_CALL(service_, ActivateDataType(_, _, _)); |
159 EXPECT_CALL(start_callback_, Run(result, _, _)); | 159 EXPECT_CALL(start_callback_, Run(result, _, _)); |
160 } | 160 } |
161 | 161 |
162 void SetStopExpectations() { | 162 void SetStopExpectations() { |
163 EXPECT_CALL(*dtc_mock_, StopModels()); | 163 EXPECT_CALL(*dtc_mock_.get(), StopModels()); |
164 EXPECT_CALL(service_, DeactivateDataType(_)); | 164 EXPECT_CALL(service_, DeactivateDataType(_)); |
165 EXPECT_CALL(*model_associator_, DisassociateModels()). | 165 EXPECT_CALL(*model_associator_, DisassociateModels()). |
166 WillOnce(Return(syncer::SyncError())); | 166 WillOnce(Return(syncer::SyncError())); |
167 } | 167 } |
168 | 168 |
169 void SetStartFailExpectations(DataTypeController::StartResult result) { | 169 void SetStartFailExpectations(DataTypeController::StartResult result) { |
170 EXPECT_CALL(*dtc_mock_, StopModels()); | 170 EXPECT_CALL(*dtc_mock_.get(), StopModels()); |
171 if (DataTypeController::IsUnrecoverableResult(result)) | 171 if (DataTypeController::IsUnrecoverableResult(result)) |
172 EXPECT_CALL(*dtc_mock_, RecordUnrecoverableError(_, _)); | 172 EXPECT_CALL(*dtc_mock_.get(), RecordUnrecoverableError(_, _)); |
173 if (model_associator_) { | 173 if (model_associator_) { |
174 EXPECT_CALL(*model_associator_, DisassociateModels()). | 174 EXPECT_CALL(*model_associator_, DisassociateModels()). |
175 WillOnce(Return(syncer::SyncError())); | 175 WillOnce(Return(syncer::SyncError())); |
176 } | 176 } |
177 EXPECT_CALL(*dtc_mock_, RecordStartFailure(result)); | 177 EXPECT_CALL(*dtc_mock_.get(), RecordStartFailure(result)); |
178 EXPECT_CALL(start_callback_, Run(result, _, _)); | 178 EXPECT_CALL(start_callback_, Run(result, _, _)); |
179 } | 179 } |
180 | 180 |
181 static void SignalDone(WaitableEvent* done) { | 181 static void SignalDone(WaitableEvent* done) { |
182 done->Signal(); | 182 done->Signal(); |
183 } | 183 } |
184 | 184 |
185 void WaitForDTC() { | 185 void WaitForDTC() { |
186 WaitableEvent done(true, false); | 186 WaitableEvent done(true, false); |
187 BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, | 187 BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
227 } | 227 } |
228 | 228 |
229 TEST_F(SyncNonFrontendDataTypeControllerTest, StartFirstRun) { | 229 TEST_F(SyncNonFrontendDataTypeControllerTest, StartFirstRun) { |
230 SetStartExpectations(); | 230 SetStartExpectations(); |
231 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). | 231 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). |
232 WillOnce(Return(true)); | 232 WillOnce(Return(true)); |
233 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). | 233 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). |
234 WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true))); | 234 WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true))); |
235 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). | 235 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). |
236 WillOnce(Return(syncer::SyncError())); | 236 WillOnce(Return(syncer::SyncError())); |
237 EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_)); | 237 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
238 SetActivateExpectations(DataTypeController::OK_FIRST_RUN); | 238 SetActivateExpectations(DataTypeController::OK_FIRST_RUN); |
239 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 239 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
240 Start(); | 240 Start(); |
241 WaitForDTC(); | 241 WaitForDTC(); |
242 EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state()); | 242 EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state()); |
243 } | 243 } |
244 | 244 |
245 TEST_F(SyncNonFrontendDataTypeControllerTest, StartAssociationFailed) { | 245 TEST_F(SyncNonFrontendDataTypeControllerTest, StartAssociationFailed) { |
246 SetStartExpectations(); | 246 SetStartExpectations(); |
247 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). | 247 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). |
248 WillOnce(Return(true)); | 248 WillOnce(Return(true)); |
249 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). | 249 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). |
250 WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); | 250 WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); |
251 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). | 251 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). |
252 WillOnce( | 252 WillOnce( |
253 Return(syncer::SyncError(FROM_HERE, "Error", syncer::BOOKMARKS))); | 253 Return(syncer::SyncError(FROM_HERE, "Error", syncer::BOOKMARKS))); |
254 EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_)); | 254 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
255 SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED); | 255 SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED); |
256 // Set up association to fail with an association failed error. | 256 // Set up association to fail with an association failed error. |
257 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 257 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
258 Start(); | 258 Start(); |
259 WaitForDTC(); | 259 WaitForDTC(); |
260 EXPECT_EQ(DataTypeController::DISABLED, non_frontend_dtc_->state()); | 260 EXPECT_EQ(DataTypeController::DISABLED, non_frontend_dtc_->state()); |
261 } | 261 } |
262 | 262 |
263 TEST_F(SyncNonFrontendDataTypeControllerTest, | 263 TEST_F(SyncNonFrontendDataTypeControllerTest, |
264 StartAssociationTriggersUnrecoverableError) { | 264 StartAssociationTriggersUnrecoverableError) { |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). | 299 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). |
300 WillOnce(DoAll( | 300 WillOnce(DoAll( |
301 SignalEvent(&wait_for_db_thread_pause), | 301 SignalEvent(&wait_for_db_thread_pause), |
302 WaitOnEvent(&pause_db_thread), | 302 WaitOnEvent(&pause_db_thread), |
303 SetArgumentPointee<0>(true), | 303 SetArgumentPointee<0>(true), |
304 Return(true))); | 304 Return(true))); |
305 EXPECT_CALL(*model_associator_, AbortAssociation()).WillOnce( | 305 EXPECT_CALL(*model_associator_, AbortAssociation()).WillOnce( |
306 SignalEvent(&pause_db_thread)); | 306 SignalEvent(&pause_db_thread)); |
307 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). | 307 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). |
308 WillOnce(Return(syncer::SyncError())); | 308 WillOnce(Return(syncer::SyncError())); |
309 EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_)); | 309 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
310 EXPECT_CALL(service_, ActivateDataType(_, _, _)); | 310 EXPECT_CALL(service_, ActivateDataType(_, _, _)); |
311 EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED,_,_)); | 311 EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED,_,_)); |
312 EXPECT_CALL(*dtc_mock_, RecordStartFailure(DataTypeController::ABORTED)); | 312 EXPECT_CALL(*dtc_mock_.get(), |
| 313 RecordStartFailure(DataTypeController::ABORTED)); |
313 SetStopExpectations(); | 314 SetStopExpectations(); |
314 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 315 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
315 Start(); | 316 Start(); |
316 wait_for_db_thread_pause.Wait(); | 317 wait_for_db_thread_pause.Wait(); |
317 non_frontend_dtc_->Stop(); | 318 non_frontend_dtc_->Stop(); |
318 WaitForDTC(); | 319 WaitForDTC(); |
319 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 320 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
320 } | 321 } |
321 | 322 |
322 // Same as above but abort during the Activate call. | 323 // Same as above but abort during the Activate call. |
323 TEST_F(SyncNonFrontendDataTypeControllerTest, AbortDuringAssociationActivated) { | 324 TEST_F(SyncNonFrontendDataTypeControllerTest, AbortDuringAssociationActivated) { |
324 WaitableEvent wait_for_db_thread_pause(false, false); | 325 WaitableEvent wait_for_db_thread_pause(false, false); |
325 WaitableEvent pause_db_thread(false, false); | 326 WaitableEvent pause_db_thread(false, false); |
326 | 327 |
327 SetStartExpectations(); | 328 SetStartExpectations(); |
328 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). | 329 EXPECT_CALL(*model_associator_, CryptoReadyIfNecessary()). |
329 WillOnce(Return(true)); | 330 WillOnce(Return(true)); |
330 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). | 331 EXPECT_CALL(*model_associator_, SyncModelHasUserCreatedNodes(_)). |
331 WillOnce(DoAll( | 332 WillOnce(DoAll( |
332 SetArgumentPointee<0>(true), | 333 SetArgumentPointee<0>(true), |
333 Return(true))); | 334 Return(true))); |
334 EXPECT_CALL(*model_associator_, AbortAssociation()).WillOnce( | 335 EXPECT_CALL(*model_associator_, AbortAssociation()).WillOnce( |
335 SignalEvent(&pause_db_thread)); | 336 SignalEvent(&pause_db_thread)); |
336 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). | 337 EXPECT_CALL(*model_associator_, AssociateModels(_, _)). |
337 WillOnce(Return(syncer::SyncError())); | 338 WillOnce(Return(syncer::SyncError())); |
338 EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_)); | 339 EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_)); |
339 EXPECT_CALL(service_, ActivateDataType(_, _, _)).WillOnce(DoAll( | 340 EXPECT_CALL(service_, ActivateDataType(_, _, _)).WillOnce(DoAll( |
340 SignalEvent(&wait_for_db_thread_pause), | 341 SignalEvent(&wait_for_db_thread_pause), WaitOnEvent(&pause_db_thread))); |
341 WaitOnEvent(&pause_db_thread))); | |
342 EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED,_,_)); | 342 EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED,_,_)); |
343 EXPECT_CALL(*dtc_mock_, RecordStartFailure(DataTypeController::ABORTED)); | 343 EXPECT_CALL(*dtc_mock_.get(), |
| 344 RecordStartFailure(DataTypeController::ABORTED)); |
344 SetStopExpectations(); | 345 SetStopExpectations(); |
345 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 346 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
346 Start(); | 347 Start(); |
347 wait_for_db_thread_pause.Wait(); | 348 wait_for_db_thread_pause.Wait(); |
348 non_frontend_dtc_->Stop(); | 349 non_frontend_dtc_->Stop(); |
349 WaitForDTC(); | 350 WaitForDTC(); |
350 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 351 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
351 } | 352 } |
352 | 353 |
353 TEST_F(SyncNonFrontendDataTypeControllerTest, Stop) { | 354 TEST_F(SyncNonFrontendDataTypeControllerTest, Stop) { |
354 SetStartExpectations(); | 355 SetStartExpectations(); |
355 SetAssociateExpectations(); | 356 SetAssociateExpectations(); |
356 SetActivateExpectations(DataTypeController::OK); | 357 SetActivateExpectations(DataTypeController::OK); |
357 SetStopExpectations(); | 358 SetStopExpectations(); |
358 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 359 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
359 Start(); | 360 Start(); |
360 WaitForDTC(); | 361 WaitForDTC(); |
361 EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state()); | 362 EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state()); |
362 non_frontend_dtc_->Stop(); | 363 non_frontend_dtc_->Stop(); |
363 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 364 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
364 } | 365 } |
365 | 366 |
366 TEST_F(SyncNonFrontendDataTypeControllerTest, | 367 TEST_F(SyncNonFrontendDataTypeControllerTest, |
367 OnSingleDatatypeUnrecoverableError) { | 368 OnSingleDatatypeUnrecoverableError) { |
368 SetStartExpectations(); | 369 SetStartExpectations(); |
369 SetAssociateExpectations(); | 370 SetAssociateExpectations(); |
370 SetActivateExpectations(DataTypeController::OK); | 371 SetActivateExpectations(DataTypeController::OK); |
371 EXPECT_CALL(*dtc_mock_, RecordUnrecoverableError(_, "Test")); | 372 EXPECT_CALL(*dtc_mock_.get(), RecordUnrecoverableError(_, "Test")); |
372 EXPECT_CALL(service_, DisableBrokenDatatype(_,_,_)).WillOnce( | 373 EXPECT_CALL(service_, DisableBrokenDatatype(_, _, _)) |
373 InvokeWithoutArgs(non_frontend_dtc_.get(), | 374 .WillOnce(InvokeWithoutArgs(non_frontend_dtc_.get(), |
374 &NonFrontendDataTypeController::Stop)); | 375 &NonFrontendDataTypeController::Stop)); |
375 SetStopExpectations(); | 376 SetStopExpectations(); |
376 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 377 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
377 Start(); | 378 Start(); |
378 WaitForDTC(); | 379 WaitForDTC(); |
379 EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state()); | 380 EXPECT_EQ(DataTypeController::RUNNING, non_frontend_dtc_->state()); |
380 // This should cause non_frontend_dtc_->Stop() to be called. | 381 // This should cause non_frontend_dtc_->Stop() to be called. |
381 BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, base::Bind( | 382 BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, base::Bind( |
382 &NonFrontendDataTypeControllerFake::OnSingleDatatypeUnrecoverableError, | 383 &NonFrontendDataTypeControllerFake::OnSingleDatatypeUnrecoverableError, |
383 non_frontend_dtc_.get(), | 384 non_frontend_dtc_.get(), |
384 FROM_HERE, | 385 FROM_HERE, |
385 std::string("Test"))); | 386 std::string("Test"))); |
386 WaitForDTC(); | 387 WaitForDTC(); |
387 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); | 388 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_frontend_dtc_->state()); |
388 } | 389 } |
OLD | NEW |