OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "components/sync/driver/non_ui_data_type_controller.h" | 5 #include "components/sync/driver/non_ui_data_type_controller.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 13 matching lines...) Expand all Loading... |
24 #include "components/sync/api/fake_syncable_service.h" | 24 #include "components/sync/api/fake_syncable_service.h" |
25 #include "components/sync/api/sync_change.h" | 25 #include "components/sync/api/sync_change.h" |
26 #include "components/sync/driver/data_type_controller_mock.h" | 26 #include "components/sync/driver/data_type_controller_mock.h" |
27 #include "components/sync/driver/fake_sync_client.h" | 27 #include "components/sync/driver/fake_sync_client.h" |
28 #include "components/sync/driver/generic_change_processor_factory.h" | 28 #include "components/sync/driver/generic_change_processor_factory.h" |
29 #include "components/sync/driver/non_ui_data_type_controller_mock.h" | 29 #include "components/sync/driver/non_ui_data_type_controller_mock.h" |
30 #include "components/sync/engine/model_safe_worker.h" | 30 #include "components/sync/engine/model_safe_worker.h" |
31 #include "testing/gmock/include/gmock/gmock.h" | 31 #include "testing/gmock/include/gmock/gmock.h" |
32 #include "testing/gtest/include/gtest/gtest.h" | 32 #include "testing/gtest/include/gtest/gtest.h" |
33 | 33 |
34 namespace sync_driver { | 34 namespace syncer { |
35 | 35 |
36 class SyncClient; | 36 class SyncClient; |
37 | 37 |
38 namespace { | 38 namespace { |
39 | 39 |
40 using base::WaitableEvent; | 40 using base::WaitableEvent; |
41 using syncer::AUTOFILL_PROFILE; | |
42 using testing::_; | 41 using testing::_; |
43 using testing::AtLeast; | 42 using testing::AtLeast; |
44 using testing::DoAll; | 43 using testing::DoAll; |
45 using testing::InvokeWithoutArgs; | 44 using testing::InvokeWithoutArgs; |
46 using testing::Mock; | 45 using testing::Mock; |
47 using testing::Return; | 46 using testing::Return; |
48 using testing::SetArgumentPointee; | 47 using testing::SetArgumentPointee; |
49 using testing::StrictMock; | 48 using testing::StrictMock; |
50 | 49 |
51 const syncer::ModelType kType = AUTOFILL_PROFILE; | 50 const ModelType kType = AUTOFILL_PROFILE; |
52 | 51 |
53 ACTION_P(WaitOnEvent, event) { | 52 ACTION_P(WaitOnEvent, event) { |
54 event->Wait(); | 53 event->Wait(); |
55 } | 54 } |
56 | 55 |
57 ACTION_P(SignalEvent, event) { | 56 ACTION_P(SignalEvent, event) { |
58 event->Signal(); | 57 event->Signal(); |
59 } | 58 } |
60 | 59 |
61 ACTION_P(SaveChangeProcessor, scoped_change_processor) { | 60 ACTION_P(SaveChangeProcessor, scoped_change_processor) { |
62 scoped_change_processor->reset(arg2); | 61 scoped_change_processor->reset(arg2); |
63 } | 62 } |
64 | 63 |
65 class SharedChangeProcessorMock : public SharedChangeProcessor { | 64 class SharedChangeProcessorMock : public SharedChangeProcessor { |
66 public: | 65 public: |
67 explicit SharedChangeProcessorMock(syncer::ModelType type) | 66 explicit SharedChangeProcessorMock(ModelType type) |
68 : SharedChangeProcessor(type) {} | 67 : SharedChangeProcessor(type) {} |
69 | 68 |
70 base::WeakPtr<syncer::SyncableService> Connect( | 69 base::WeakPtr<SyncableService> Connect( |
71 SyncClient*, | 70 SyncClient*, |
72 GenericChangeProcessorFactory*, | 71 GenericChangeProcessorFactory*, |
73 syncer::UserShare*, | 72 UserShare*, |
74 std::unique_ptr<syncer::DataTypeErrorHandler>, | 73 std::unique_ptr<DataTypeErrorHandler>, |
75 const base::WeakPtr<syncer::SyncMergeResult>&) { | 74 const base::WeakPtr<SyncMergeResult>&) { |
76 return std::move(connect_return_); | 75 return std::move(connect_return_); |
77 } | 76 } |
78 MOCK_METHOD0(Disconnect, bool()); | 77 MOCK_METHOD0(Disconnect, bool()); |
79 MOCK_METHOD2(ProcessSyncChanges, | 78 MOCK_METHOD2(ProcessSyncChanges, |
80 syncer::SyncError(const tracked_objects::Location&, | 79 SyncError(const tracked_objects::Location&, |
81 const syncer::SyncChangeList&)); | 80 const SyncChangeList&)); |
82 MOCK_CONST_METHOD2(GetAllSyncDataReturnError, | 81 MOCK_CONST_METHOD2(GetAllSyncDataReturnError, |
83 syncer::SyncError(syncer::ModelType, | 82 SyncError(ModelType, SyncDataList*)); |
84 syncer::SyncDataList*)); | |
85 MOCK_METHOD0(GetSyncCount, int()); | 83 MOCK_METHOD0(GetSyncCount, int()); |
86 MOCK_METHOD1(SyncModelHasUserCreatedNodes, bool(bool*)); | 84 MOCK_METHOD1(SyncModelHasUserCreatedNodes, bool(bool*)); |
87 MOCK_METHOD0(CryptoReadyIfNecessary, bool()); | 85 MOCK_METHOD0(CryptoReadyIfNecessary, bool()); |
88 MOCK_CONST_METHOD1(GetDataTypeContext, bool(std::string*)); | 86 MOCK_CONST_METHOD1(GetDataTypeContext, bool(std::string*)); |
89 MOCK_METHOD1(RecordAssociationTime, void(base::TimeDelta time)); | 87 MOCK_METHOD1(RecordAssociationTime, void(base::TimeDelta time)); |
90 | 88 |
91 void SetConnectReturn(base::WeakPtr<syncer::SyncableService> service) { | 89 void SetConnectReturn(base::WeakPtr<SyncableService> service) { |
92 connect_return_ = service; | 90 connect_return_ = service; |
93 } | 91 } |
94 | 92 |
95 protected: | 93 protected: |
96 virtual ~SharedChangeProcessorMock() { DCHECK(!connect_return_); } | 94 virtual ~SharedChangeProcessorMock() { DCHECK(!connect_return_); } |
97 MOCK_METHOD2(OnUnrecoverableError, | 95 MOCK_METHOD2(OnUnrecoverableError, |
98 void(const tracked_objects::Location&, const std::string&)); | 96 void(const tracked_objects::Location&, const std::string&)); |
99 | 97 |
100 private: | 98 private: |
101 base::WeakPtr<syncer::SyncableService> connect_return_; | 99 base::WeakPtr<SyncableService> connect_return_; |
102 DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessorMock); | 100 DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessorMock); |
103 }; | 101 }; |
104 | 102 |
105 class NonUIDataTypeControllerFake : public NonUIDataTypeController { | 103 class NonUIDataTypeControllerFake : public NonUIDataTypeController { |
106 public: | 104 public: |
107 NonUIDataTypeControllerFake( | 105 NonUIDataTypeControllerFake( |
108 SyncClient* sync_client, | 106 SyncClient* sync_client, |
109 NonUIDataTypeControllerMock* mock, | 107 NonUIDataTypeControllerMock* mock, |
110 SharedChangeProcessor* change_processor, | 108 SharedChangeProcessor* change_processor, |
111 scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner) | 109 scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner) |
112 : NonUIDataTypeController(kType, base::Closure(), sync_client), | 110 : NonUIDataTypeController(kType, base::Closure(), sync_client), |
113 blocked_(false), | 111 blocked_(false), |
114 mock_(mock), | 112 mock_(mock), |
115 change_processor_(change_processor), | 113 change_processor_(change_processor), |
116 backend_task_runner_(backend_task_runner) {} | 114 backend_task_runner_(backend_task_runner) {} |
117 ~NonUIDataTypeControllerFake() override {} | 115 ~NonUIDataTypeControllerFake() override {} |
118 | 116 |
119 syncer::ModelSafeGroup model_safe_group() const override { | 117 ModelSafeGroup model_safe_group() const override { return GROUP_DB; } |
120 return syncer::GROUP_DB; | |
121 } | |
122 | 118 |
123 // Prevent tasks from being posted on the backend thread until | 119 // Prevent tasks from being posted on the backend thread until |
124 // UnblockBackendTasks() is called. | 120 // UnblockBackendTasks() is called. |
125 void BlockBackendTasks() { blocked_ = true; } | 121 void BlockBackendTasks() { blocked_ = true; } |
126 | 122 |
127 // Post pending tasks on the backend thread and start allowing tasks | 123 // Post pending tasks on the backend thread and start allowing tasks |
128 // to be posted on the backend thread again. | 124 // to be posted on the backend thread again. |
129 void UnblockBackendTasks() { | 125 void UnblockBackendTasks() { |
130 blocked_ = false; | 126 blocked_ = false; |
131 for (std::vector<PendingTask>::const_iterator it = pending_tasks_.begin(); | 127 for (std::vector<PendingTask>::const_iterator it = pending_tasks_.begin(); |
132 it != pending_tasks_.end(); ++it) { | 128 it != pending_tasks_.end(); ++it) { |
133 PostTaskOnBackendThread(it->from_here, it->task); | 129 PostTaskOnBackendThread(it->from_here, it->task); |
134 } | 130 } |
135 pending_tasks_.clear(); | 131 pending_tasks_.clear(); |
136 } | 132 } |
137 | 133 |
138 SharedChangeProcessor* CreateSharedChangeProcessor() override { | 134 SharedChangeProcessor* CreateSharedChangeProcessor() override { |
139 return change_processor_.get(); | 135 return change_processor_.get(); |
140 } | 136 } |
141 | 137 |
142 std::unique_ptr<syncer::DataTypeErrorHandler> CreateErrorHandler() override { | 138 std::unique_ptr<DataTypeErrorHandler> CreateErrorHandler() override { |
143 return NonUIDataTypeController::CreateErrorHandler(); | 139 return NonUIDataTypeController::CreateErrorHandler(); |
144 } | 140 } |
145 | 141 |
146 protected: | 142 protected: |
147 bool PostTaskOnBackendThread(const tracked_objects::Location& from_here, | 143 bool PostTaskOnBackendThread(const tracked_objects::Location& from_here, |
148 const base::Closure& task) override { | 144 const base::Closure& task) override { |
149 if (blocked_) { | 145 if (blocked_) { |
150 pending_tasks_.push_back(PendingTask(from_here, task)); | 146 pending_tasks_.push_back(PendingTask(from_here, task)); |
151 return true; | 147 return true; |
152 } else { | 148 } else { |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
223 EXPECT_CALL(model_load_callback_, Run(_, _)); | 219 EXPECT_CALL(model_load_callback_, Run(_, _)); |
224 } | 220 } |
225 | 221 |
226 void SetAssociateExpectations() { | 222 void SetAssociateExpectations() { |
227 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); | 223 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); |
228 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) | 224 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) |
229 .WillOnce(Return(true)); | 225 .WillOnce(Return(true)); |
230 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) | 226 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) |
231 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); | 227 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); |
232 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) | 228 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) |
233 .WillOnce(Return(syncer::SyncError())); | 229 .WillOnce(Return(SyncError())); |
234 EXPECT_CALL(*change_processor_.get(), GetSyncCount()).WillOnce(Return(0)); | 230 EXPECT_CALL(*change_processor_.get(), GetSyncCount()).WillOnce(Return(0)); |
235 EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_)); | 231 EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_)); |
236 } | 232 } |
237 | 233 |
238 void SetActivateExpectations(DataTypeController::ConfigureResult result) { | 234 void SetActivateExpectations(DataTypeController::ConfigureResult result) { |
239 EXPECT_CALL(start_callback_, Run(result, _, _)); | 235 EXPECT_CALL(start_callback_, Run(result, _, _)); |
240 } | 236 } |
241 | 237 |
242 void SetStopExpectations() { | 238 void SetStopExpectations() { |
243 EXPECT_CALL(*dtc_mock_.get(), StopModels()); | 239 EXPECT_CALL(*dtc_mock_.get(), StopModels()); |
(...skipping 14 matching lines...) Expand all Loading... |
258 } | 254 } |
259 | 255 |
260 static void SignalDone(WaitableEvent* done) { done->Signal(); } | 256 static void SignalDone(WaitableEvent* done) { done->Signal(); } |
261 | 257 |
262 base::MessageLoopForUI message_loop_; | 258 base::MessageLoopForUI message_loop_; |
263 base::Thread backend_thread_; | 259 base::Thread backend_thread_; |
264 | 260 |
265 StartCallbackMock start_callback_; | 261 StartCallbackMock start_callback_; |
266 ModelLoadCallbackMock model_load_callback_; | 262 ModelLoadCallbackMock model_load_callback_; |
267 // Must be destroyed after non_ui_dtc_. | 263 // Must be destroyed after non_ui_dtc_. |
268 syncer::FakeSyncableService syncable_service_; | 264 FakeSyncableService syncable_service_; |
269 std::unique_ptr<NonUIDataTypeControllerFake> non_ui_dtc_; | 265 std::unique_ptr<NonUIDataTypeControllerFake> non_ui_dtc_; |
270 std::unique_ptr<NonUIDataTypeControllerMock> dtc_mock_; | 266 std::unique_ptr<NonUIDataTypeControllerMock> dtc_mock_; |
271 scoped_refptr<SharedChangeProcessorMock> change_processor_; | 267 scoped_refptr<SharedChangeProcessorMock> change_processor_; |
272 std::unique_ptr<syncer::SyncChangeProcessor> saved_change_processor_; | 268 std::unique_ptr<SyncChangeProcessor> saved_change_processor_; |
273 }; | 269 }; |
274 | 270 |
275 TEST_F(SyncNonUIDataTypeControllerTest, StartOk) { | 271 TEST_F(SyncNonUIDataTypeControllerTest, StartOk) { |
276 SetStartExpectations(); | 272 SetStartExpectations(); |
277 SetAssociateExpectations(); | 273 SetAssociateExpectations(); |
278 SetActivateExpectations(DataTypeController::OK); | 274 SetActivateExpectations(DataTypeController::OK); |
279 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 275 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
280 Start(); | 276 Start(); |
281 WaitForDTC(); | 277 WaitForDTC(); |
282 EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state()); | 278 EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state()); |
283 } | 279 } |
284 | 280 |
285 TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) { | 281 TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) { |
286 SetStartExpectations(); | 282 SetStartExpectations(); |
287 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); | 283 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); |
288 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) | 284 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) |
289 .WillOnce(Return(true)); | 285 .WillOnce(Return(true)); |
290 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) | 286 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) |
291 .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true))); | 287 .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true))); |
292 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) | 288 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) |
293 .WillOnce(Return(syncer::SyncError())); | 289 .WillOnce(Return(SyncError())); |
294 EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_)); | 290 EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_)); |
295 SetActivateExpectations(DataTypeController::OK_FIRST_RUN); | 291 SetActivateExpectations(DataTypeController::OK_FIRST_RUN); |
296 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 292 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
297 Start(); | 293 Start(); |
298 WaitForDTC(); | 294 WaitForDTC(); |
299 EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state()); | 295 EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state()); |
300 } | 296 } |
301 | 297 |
302 // Start the DTC and have StartModels() return false. Then, stop the | 298 // Start the DTC and have StartModels() return false. Then, stop the |
303 // DTC without finishing model startup. It should stop cleanly. | 299 // DTC without finishing model startup. It should stop cleanly. |
(...skipping 13 matching lines...) Expand all Loading... |
317 // The DTC should become disabled, and the DTC should still stop | 313 // The DTC should become disabled, and the DTC should still stop |
318 // cleanly. | 314 // cleanly. |
319 TEST_F(SyncNonUIDataTypeControllerTest, StartAssociationFailed) { | 315 TEST_F(SyncNonUIDataTypeControllerTest, StartAssociationFailed) { |
320 SetStartExpectations(); | 316 SetStartExpectations(); |
321 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); | 317 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); |
322 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) | 318 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) |
323 .WillOnce(Return(true)); | 319 .WillOnce(Return(true)); |
324 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) | 320 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) |
325 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); | 321 .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true))); |
326 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) | 322 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) |
327 .WillOnce(Return(syncer::SyncError())); | 323 .WillOnce(Return(SyncError())); |
328 EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_)); | 324 EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_)); |
329 SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED); | 325 SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED); |
330 // Set up association to fail with an association failed error. | 326 // Set up association to fail with an association failed error. |
331 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 327 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
332 syncable_service_.set_merge_data_and_start_syncing_error( | 328 syncable_service_.set_merge_data_and_start_syncing_error(SyncError( |
333 syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, | 329 FROM_HERE, SyncError::DATATYPE_ERROR, "Sync Error", non_ui_dtc_->type())); |
334 "Sync Error", non_ui_dtc_->type())); | |
335 Start(); | 330 Start(); |
336 WaitForDTC(); | 331 WaitForDTC(); |
337 EXPECT_EQ(DataTypeController::DISABLED, non_ui_dtc_->state()); | 332 EXPECT_EQ(DataTypeController::DISABLED, non_ui_dtc_->state()); |
338 non_ui_dtc_->Stop(); | 333 non_ui_dtc_->Stop(); |
339 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 334 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
340 } | 335 } |
341 | 336 |
342 TEST_F(SyncNonUIDataTypeControllerTest, | 337 TEST_F(SyncNonUIDataTypeControllerTest, |
343 StartAssociationTriggersUnrecoverableError) { | 338 StartAssociationTriggersUnrecoverableError) { |
344 SetStartExpectations(); | 339 SetStartExpectations(); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
380 | 375 |
381 SetStartExpectations(); | 376 SetStartExpectations(); |
382 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); | 377 change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr()); |
383 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) | 378 EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary()) |
384 .WillOnce(Return(true)); | 379 .WillOnce(Return(true)); |
385 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) | 380 EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_)) |
386 .WillOnce(DoAll(SignalEvent(&wait_for_db_thread_pause), | 381 .WillOnce(DoAll(SignalEvent(&wait_for_db_thread_pause), |
387 WaitOnEvent(&pause_db_thread), | 382 WaitOnEvent(&pause_db_thread), |
388 SetArgumentPointee<0>(true), Return(true))); | 383 SetArgumentPointee<0>(true), Return(true))); |
389 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) | 384 EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _)) |
390 .WillOnce( | 385 .WillOnce(Return(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR, |
391 Return(syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, | 386 "Disconnected.", kType))); |
392 "Disconnected.", kType))); | |
393 EXPECT_CALL(*dtc_mock_.get(), StopModels()); | 387 EXPECT_CALL(*dtc_mock_.get(), StopModels()); |
394 EXPECT_CALL(*change_processor_.get(), Disconnect()) | 388 EXPECT_CALL(*change_processor_.get(), Disconnect()) |
395 .WillOnce(DoAll(SignalEvent(&pause_db_thread), Return(true))); | 389 .WillOnce(DoAll(SignalEvent(&pause_db_thread), Return(true))); |
396 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 390 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
397 Start(); | 391 Start(); |
398 wait_for_db_thread_pause.Wait(); | 392 wait_for_db_thread_pause.Wait(); |
399 non_ui_dtc_->Stop(); | 393 non_ui_dtc_->Stop(); |
400 WaitForDTC(); | 394 WaitForDTC(); |
401 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 395 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
402 } | 396 } |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
465 SetStartExpectations(); | 459 SetStartExpectations(); |
466 SetAssociateExpectations(); | 460 SetAssociateExpectations(); |
467 SetActivateExpectations(DataTypeController::OK); | 461 SetActivateExpectations(DataTypeController::OK); |
468 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); | 462 EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state()); |
469 Start(); | 463 Start(); |
470 WaitForDTC(); | 464 WaitForDTC(); |
471 EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state()); | 465 EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state()); |
472 | 466 |
473 testing::Mock::VerifyAndClearExpectations(&start_callback_); | 467 testing::Mock::VerifyAndClearExpectations(&start_callback_); |
474 EXPECT_CALL(model_load_callback_, Run(_, _)); | 468 EXPECT_CALL(model_load_callback_, Run(_, _)); |
475 syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, "error", | 469 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, "error", |
476 non_ui_dtc_->type()); | 470 non_ui_dtc_->type()); |
477 backend_thread_.task_runner()->PostTask( | 471 backend_thread_.task_runner()->PostTask( |
478 FROM_HERE, | 472 FROM_HERE, |
479 base::Bind(&syncer::DataTypeErrorHandler::OnUnrecoverableError, | 473 base::Bind(&DataTypeErrorHandler::OnUnrecoverableError, |
480 base::Passed(non_ui_dtc_->CreateErrorHandler()), error)); | 474 base::Passed(non_ui_dtc_->CreateErrorHandler()), error)); |
481 WaitForDTC(); | 475 WaitForDTC(); |
482 } | 476 } |
483 | 477 |
484 } // namespace | 478 } // namespace |
485 | 479 |
486 } // namespace sync_driver | 480 } // namespace syncer |
OLD | NEW |