OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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/ui_model_type_controller.h" | 5 #include "components/sync/driver/ui_model_type_controller.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
11 #include "base/callback.h" | 11 #include "base/callback.h" |
12 #include "base/logging.h" | 12 #include "base/logging.h" |
13 #include "base/memory/ptr_util.h" | 13 #include "base/memory/ptr_util.h" |
14 #include "base/memory/ref_counted.h" | 14 #include "base/memory/ref_counted.h" |
15 #include "base/memory/weak_ptr.h" | 15 #include "base/memory/weak_ptr.h" |
16 #include "base/message_loop/message_loop.h" | 16 #include "base/message_loop/message_loop.h" |
17 #include "base/run_loop.h" | 17 #include "base/run_loop.h" |
18 #include "base/sequenced_task_runner.h" | 18 #include "base/sequenced_task_runner.h" |
19 #include "base/test/test_simple_task_runner.h" | 19 #include "base/test/test_simple_task_runner.h" |
20 #include "base/threading/thread.h" | 20 #include "base/threading/thread.h" |
21 #include "components/sync/api/stub_model_type_service.h" | 21 #include "components/sync/api/stub_model_type_service.h" |
22 #include "components/sync/core/activation_context.h" | 22 #include "components/sync/core/activation_context.h" |
23 #include "components/sync/core/shared_model_type_processor.h" | 23 #include "components/sync/core/shared_model_type_processor.h" |
24 #include "components/sync/driver/backend_data_type_configurer.h" | 24 #include "components/sync/driver/backend_data_type_configurer.h" |
25 #include "components/sync/driver/fake_sync_client.h" | 25 #include "components/sync/driver/fake_sync_client.h" |
26 #include "components/sync/engine/commit_queue.h" | 26 #include "components/sync/engine/commit_queue.h" |
27 #include "testing/gtest/include/gtest/gtest.h" | 27 #include "testing/gtest/include/gtest/gtest.h" |
28 | 28 |
29 namespace syncer { | 29 namespace sync_driver_v2 { |
30 | 30 |
31 namespace { | 31 namespace { |
32 | 32 |
33 // A no-op instance of CommitQueue. | 33 // A no-op instance of CommitQueue. |
34 class NullCommitQueue : public CommitQueue { | 34 class NullCommitQueue : public syncer_v2::CommitQueue { |
35 public: | 35 public: |
36 NullCommitQueue() {} | 36 NullCommitQueue() {} |
37 ~NullCommitQueue() override {} | 37 ~NullCommitQueue() override {} |
38 | 38 |
39 void EnqueueForCommit(const CommitRequestDataList& list) override { | 39 void EnqueueForCommit(const syncer_v2::CommitRequestDataList& list) override { |
40 NOTREACHED() << "Not implemented."; | 40 NOTREACHED() << "Not implemented."; |
41 } | 41 } |
42 }; | 42 }; |
43 | 43 |
44 // A class that pretends to be the sync backend. | 44 // A class that pretends to be the sync backend. |
45 class MockSyncBackend { | 45 class MockSyncBackend { |
46 public: | 46 public: |
47 void Connect(ModelType type, | 47 void Connect( |
48 std::unique_ptr<ActivationContext> activation_context) { | 48 syncer::ModelType type, |
| 49 std::unique_ptr<syncer_v2::ActivationContext> activation_context) { |
49 enabled_types_.Put(type); | 50 enabled_types_.Put(type); |
50 activation_context->type_processor->ConnectSync( | 51 activation_context->type_processor->ConnectSync( |
51 base::MakeUnique<NullCommitQueue>()); | 52 base::MakeUnique<NullCommitQueue>()); |
52 } | 53 } |
53 | 54 |
54 void Disconnect(ModelType type) { | 55 void Disconnect(syncer::ModelType type) { |
55 DCHECK(enabled_types_.Has(type)); | 56 DCHECK(enabled_types_.Has(type)); |
56 enabled_types_.Remove(type); | 57 enabled_types_.Remove(type); |
57 } | 58 } |
58 | 59 |
59 private: | 60 private: |
60 ModelTypeSet enabled_types_; | 61 syncer::ModelTypeSet enabled_types_; |
61 }; | 62 }; |
62 | 63 |
63 // Fake implementation of BackendDataTypeConfigurer that pretends to be Sync | 64 // Fake implementation of BackendDataTypeConfigurer that pretends to be Sync |
64 // backend. | 65 // backend. |
65 class MockBackendDataTypeConfigurer : public BackendDataTypeConfigurer { | 66 class MockBackendDataTypeConfigurer |
| 67 : public sync_driver::BackendDataTypeConfigurer { |
66 public: | 68 public: |
67 MockBackendDataTypeConfigurer( | 69 MockBackendDataTypeConfigurer( |
68 MockSyncBackend* backend, | 70 MockSyncBackend* backend, |
69 const scoped_refptr<base::TaskRunner>& sync_task_runner) | 71 const scoped_refptr<base::TaskRunner>& sync_task_runner) |
70 : backend_(backend), sync_task_runner_(sync_task_runner) {} | 72 : backend_(backend), sync_task_runner_(sync_task_runner) {} |
71 ~MockBackendDataTypeConfigurer() override {} | 73 ~MockBackendDataTypeConfigurer() override {} |
72 | 74 |
73 ModelTypeSet ConfigureDataTypes( | 75 syncer::ModelTypeSet ConfigureDataTypes( |
74 ConfigureReason reason, | 76 syncer::ConfigureReason reason, |
75 const DataTypeConfigStateMap& config_state_map, | 77 const DataTypeConfigStateMap& config_state_map, |
76 const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task, | 78 const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>& |
| 79 ready_task, |
77 const base::Callback<void()>& retry_callback) override { | 80 const base::Callback<void()>& retry_callback) override { |
78 NOTREACHED() << "Not implemented."; | 81 NOTREACHED() << "Not implemented."; |
79 return ModelTypeSet(); | 82 return syncer::ModelTypeSet(); |
80 } | 83 } |
81 | 84 |
82 void ActivateDirectoryDataType(ModelType type, | 85 void ActivateDirectoryDataType( |
83 ModelSafeGroup group, | 86 syncer::ModelType type, |
84 ChangeProcessor* change_processor) override { | 87 syncer::ModelSafeGroup group, |
| 88 sync_driver::ChangeProcessor* change_processor) override { |
85 NOTREACHED() << "Not implemented."; | 89 NOTREACHED() << "Not implemented."; |
86 } | 90 } |
87 | 91 |
88 void DeactivateDirectoryDataType(ModelType type) override { | 92 void DeactivateDirectoryDataType(syncer::ModelType type) override { |
89 NOTREACHED() << "Not implemented."; | 93 NOTREACHED() << "Not implemented."; |
90 } | 94 } |
91 | 95 |
92 void ActivateNonBlockingDataType( | 96 void ActivateNonBlockingDataType(syncer::ModelType type, |
93 ModelType type, | 97 std::unique_ptr<syncer_v2::ActivationContext> |
94 std::unique_ptr<ActivationContext> activation_context) override { | 98 activation_context) override { |
95 // Post on Sync thread just like the real implementation does. | 99 // Post on Sync thread just like the real implementation does. |
96 sync_task_runner_->PostTask( | 100 sync_task_runner_->PostTask( |
97 FROM_HERE, | 101 FROM_HERE, |
98 base::Bind(&MockSyncBackend::Connect, base::Unretained(backend_), type, | 102 base::Bind(&MockSyncBackend::Connect, base::Unretained(backend_), type, |
99 base::Passed(std::move(activation_context)))); | 103 base::Passed(std::move(activation_context)))); |
100 } | 104 } |
101 | 105 |
102 void DeactivateNonBlockingDataType(ModelType type) override { | 106 void DeactivateNonBlockingDataType(syncer::ModelType type) override { |
103 sync_task_runner_->PostTask(FROM_HERE, | 107 sync_task_runner_->PostTask(FROM_HERE, |
104 base::Bind(&MockSyncBackend::Disconnect, | 108 base::Bind(&MockSyncBackend::Disconnect, |
105 base::Unretained(backend_), type)); | 109 base::Unretained(backend_), type)); |
106 } | 110 } |
107 | 111 |
108 private: | 112 private: |
109 MockSyncBackend* backend_; | 113 MockSyncBackend* backend_; |
110 scoped_refptr<base::TaskRunner> sync_task_runner_; | 114 scoped_refptr<base::TaskRunner> sync_task_runner_; |
111 }; | 115 }; |
112 | 116 |
113 } // namespace | 117 } // namespace |
114 | 118 |
115 class UIModelTypeControllerTest : public testing::Test, public FakeSyncClient { | 119 class UIModelTypeControllerTest : public testing::Test, |
| 120 public sync_driver::FakeSyncClient { |
116 public: | 121 public: |
117 UIModelTypeControllerTest() | 122 UIModelTypeControllerTest() |
118 : auto_run_tasks_(true), | 123 : auto_run_tasks_(true), |
119 load_models_callback_called_(false), | 124 load_models_callback_called_(false), |
120 association_callback_called_(false), | 125 association_callback_called_(false), |
121 configurer_(&backend_, ui_loop_.task_runner()) {} | 126 configurer_(&backend_, ui_loop_.task_runner()) {} |
122 | 127 |
123 ~UIModelTypeControllerTest() override {} | 128 ~UIModelTypeControllerTest() override {} |
124 | 129 |
125 void SetUp() override { | 130 void SetUp() override { |
126 controller_ = base::MakeUnique<UIModelTypeController>( | 131 controller_ = base::MakeUnique<UIModelTypeController>( |
127 DEVICE_INFO, base::Closure(), this); | 132 syncer::DEVICE_INFO, base::Closure(), this); |
128 service_ = base::MakeUnique<StubModelTypeService>(base::Bind( | 133 service_ = base::MakeUnique<syncer_v2::StubModelTypeService>(base::Bind( |
129 &UIModelTypeControllerTest::CreateProcessor, base::Unretained(this))); | 134 &UIModelTypeControllerTest::CreateProcessor, base::Unretained(this))); |
130 } | 135 } |
131 | 136 |
132 void TearDown() override { | 137 void TearDown() override { |
133 controller_ = NULL; | 138 controller_ = NULL; |
134 RunAllTasks(); | 139 RunAllTasks(); |
135 } | 140 } |
136 | 141 |
137 base::WeakPtr<ModelTypeService> GetModelTypeServiceForType( | 142 base::WeakPtr<syncer_v2::ModelTypeService> GetModelTypeServiceForType( |
138 ModelType type) override { | 143 syncer::ModelType type) override { |
139 return service_->AsWeakPtr(); | 144 return service_->AsWeakPtr(); |
140 } | 145 } |
141 | 146 |
142 protected: | 147 protected: |
143 std::unique_ptr<ModelTypeChangeProcessor> CreateProcessor( | 148 std::unique_ptr<syncer_v2::ModelTypeChangeProcessor> CreateProcessor( |
144 ModelType type, | 149 syncer::ModelType type, |
145 ModelTypeService* service) { | 150 syncer_v2::ModelTypeService* service) { |
146 std::unique_ptr<SharedModelTypeProcessor> processor = | 151 std::unique_ptr<syncer_v2::SharedModelTypeProcessor> processor = |
147 base::MakeUnique<SharedModelTypeProcessor>(type, service); | 152 base::MakeUnique<syncer_v2::SharedModelTypeProcessor>(type, service); |
148 type_processor_ = processor.get(); | 153 type_processor_ = processor.get(); |
149 return std::move(processor); | 154 return std::move(processor); |
150 } | 155 } |
151 | 156 |
152 void ExpectProcessorConnected(bool isConnected) { | 157 void ExpectProcessorConnected(bool isConnected) { |
153 DCHECK(type_processor_); | 158 DCHECK(type_processor_); |
154 EXPECT_EQ(isConnected, type_processor_->IsConnected()); | 159 EXPECT_EQ(isConnected, type_processor_->IsConnected()); |
155 } | 160 } |
156 | 161 |
157 void LoadModels() { | 162 void LoadModels() { |
158 controller_->LoadModels(base::Bind( | 163 controller_->LoadModels(base::Bind( |
159 &UIModelTypeControllerTest::LoadModelsDone, base::Unretained(this))); | 164 &UIModelTypeControllerTest::LoadModelsDone, base::Unretained(this))); |
160 if (!type_processor_->IsAllowingChanges()) { | 165 if (!type_processor_->IsAllowingChanges()) { |
161 type_processor_->OnMetadataLoaded(SyncError(), | 166 type_processor_->OnMetadataLoaded( |
162 base::MakeUnique<MetadataBatch>()); | 167 syncer::SyncError(), base::MakeUnique<syncer_v2::MetadataBatch>()); |
163 } | 168 } |
164 | 169 |
165 if (auto_run_tasks_) { | 170 if (auto_run_tasks_) { |
166 RunAllTasks(); | 171 RunAllTasks(); |
167 } | 172 } |
168 } | 173 } |
169 | 174 |
170 void RegisterWithBackend() { | 175 void RegisterWithBackend() { |
171 controller_->RegisterWithBackend(&configurer_); | 176 controller_->RegisterWithBackend(&configurer_); |
172 if (auto_run_tasks_) { | 177 if (auto_run_tasks_) { |
(...skipping 16 matching lines...) Expand all Loading... |
189 } | 194 } |
190 } | 195 } |
191 | 196 |
192 // These threads can ping-pong for a bit so we run the UI thread twice. | 197 // These threads can ping-pong for a bit so we run the UI thread twice. |
193 void RunAllTasks() { base::RunLoop().RunUntilIdle(); } | 198 void RunAllTasks() { base::RunLoop().RunUntilIdle(); } |
194 | 199 |
195 void SetAutoRunTasks(bool auto_run_tasks) { | 200 void SetAutoRunTasks(bool auto_run_tasks) { |
196 auto_run_tasks_ = auto_run_tasks; | 201 auto_run_tasks_ = auto_run_tasks; |
197 } | 202 } |
198 | 203 |
199 void LoadModelsDone(ModelType type, const SyncError& error) { | 204 void LoadModelsDone(syncer::ModelType type, const syncer::SyncError& error) { |
200 load_models_callback_called_ = true; | 205 load_models_callback_called_ = true; |
201 load_models_error_ = error; | 206 load_models_error_ = error; |
202 } | 207 } |
203 | 208 |
204 void AssociationDone(DataTypeController::ConfigureResult result, | 209 void AssociationDone(sync_driver::DataTypeController::ConfigureResult result, |
205 const SyncMergeResult& local_merge_result, | 210 const syncer::SyncMergeResult& local_merge_result, |
206 const SyncMergeResult& syncer_merge_result) { | 211 const syncer::SyncMergeResult& syncer_merge_result) { |
207 EXPECT_EQ(DataTypeController::OK, result); | 212 EXPECT_EQ(sync_driver::DataTypeController::OK, result); |
208 association_callback_called_ = true; | 213 association_callback_called_ = true; |
209 } | 214 } |
210 | 215 |
211 SharedModelTypeProcessor* type_processor_; | 216 syncer_v2::SharedModelTypeProcessor* type_processor_; |
212 std::unique_ptr<UIModelTypeController> controller_; | 217 std::unique_ptr<UIModelTypeController> controller_; |
213 | 218 |
214 bool auto_run_tasks_; | 219 bool auto_run_tasks_; |
215 bool load_models_callback_called_; | 220 bool load_models_callback_called_; |
216 SyncError load_models_error_; | 221 syncer::SyncError load_models_error_; |
217 bool association_callback_called_; | 222 bool association_callback_called_; |
218 base::MessageLoopForUI ui_loop_; | 223 base::MessageLoopForUI ui_loop_; |
219 MockSyncBackend backend_; | 224 MockSyncBackend backend_; |
220 MockBackendDataTypeConfigurer configurer_; | 225 MockBackendDataTypeConfigurer configurer_; |
221 std::unique_ptr<StubModelTypeService> service_; | 226 std::unique_ptr<syncer_v2::StubModelTypeService> service_; |
222 }; | 227 }; |
223 | 228 |
224 TEST_F(UIModelTypeControllerTest, InitialState) { | 229 TEST_F(UIModelTypeControllerTest, InitialState) { |
225 EXPECT_EQ(DEVICE_INFO, controller_->type()); | 230 EXPECT_EQ(syncer::DEVICE_INFO, controller_->type()); |
226 EXPECT_EQ(DataTypeController::NOT_RUNNING, controller_->state()); | 231 EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING, controller_->state()); |
227 } | 232 } |
228 | 233 |
229 TEST_F(UIModelTypeControllerTest, LoadModelsOnUIThread) { | 234 TEST_F(UIModelTypeControllerTest, LoadModelsOnUIThread) { |
230 LoadModels(); | 235 LoadModels(); |
231 EXPECT_EQ(DataTypeController::MODEL_LOADED, controller_->state()); | 236 EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED, |
| 237 controller_->state()); |
232 EXPECT_TRUE(load_models_callback_called_); | 238 EXPECT_TRUE(load_models_callback_called_); |
233 EXPECT_FALSE(load_models_error_.IsSet()); | 239 EXPECT_FALSE(load_models_error_.IsSet()); |
234 ExpectProcessorConnected(false); | 240 ExpectProcessorConnected(false); |
235 } | 241 } |
236 | 242 |
237 TEST_F(UIModelTypeControllerTest, LoadModelsTwice) { | 243 TEST_F(UIModelTypeControllerTest, LoadModelsTwice) { |
238 LoadModels(); | 244 LoadModels(); |
239 SetAutoRunTasks(false); | 245 SetAutoRunTasks(false); |
240 LoadModels(); | 246 LoadModels(); |
241 EXPECT_EQ(DataTypeController::MODEL_LOADED, controller_->state()); | 247 EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED, |
| 248 controller_->state()); |
242 // The second LoadModels call should set the error. | 249 // The second LoadModels call should set the error. |
243 EXPECT_TRUE(load_models_error_.IsSet()); | 250 EXPECT_TRUE(load_models_error_.IsSet()); |
244 } | 251 } |
245 | 252 |
246 TEST_F(UIModelTypeControllerTest, ActivateDataTypeOnUIThread) { | 253 TEST_F(UIModelTypeControllerTest, ActivateDataTypeOnUIThread) { |
247 LoadModels(); | 254 LoadModels(); |
248 EXPECT_EQ(DataTypeController::MODEL_LOADED, controller_->state()); | 255 EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED, |
| 256 controller_->state()); |
249 RegisterWithBackend(); | 257 RegisterWithBackend(); |
250 ExpectProcessorConnected(true); | 258 ExpectProcessorConnected(true); |
251 | 259 |
252 StartAssociating(); | 260 StartAssociating(); |
253 EXPECT_EQ(DataTypeController::RUNNING, controller_->state()); | 261 EXPECT_EQ(sync_driver::DataTypeController::RUNNING, controller_->state()); |
254 } | 262 } |
255 | 263 |
256 TEST_F(UIModelTypeControllerTest, Stop) { | 264 TEST_F(UIModelTypeControllerTest, Stop) { |
257 LoadModels(); | 265 LoadModels(); |
258 RegisterWithBackend(); | 266 RegisterWithBackend(); |
259 ExpectProcessorConnected(true); | 267 ExpectProcessorConnected(true); |
260 StartAssociating(); | 268 StartAssociating(); |
261 | 269 |
262 DeactivateDataTypeAndStop(); | 270 DeactivateDataTypeAndStop(); |
263 EXPECT_EQ(DataTypeController::NOT_RUNNING, controller_->state()); | 271 EXPECT_EQ(sync_driver::DataTypeController::NOT_RUNNING, controller_->state()); |
264 } | 272 } |
265 | 273 |
266 } // namespace syncer | 274 } // namespace sync_driver_v2 |
OLD | NEW |