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/engine_impl/model_type_registry.h" | 5 #include "components/sync/engine_impl/model_type_registry.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
11 #include "base/bind.h" | 11 #include "base/bind.h" |
12 #include "base/memory/ptr_util.h" | 12 #include "base/memory/ptr_util.h" |
13 #include "base/observer_list.h" | 13 #include "base/observer_list.h" |
14 #include "base/threading/thread_task_runner_handle.h" | 14 #include "base/threading/thread_task_runner_handle.h" |
15 #include "components/sync/base/cryptographer.h" | 15 #include "components/sync/base/cryptographer.h" |
16 #include "components/sync/core/activation_context.h" | 16 #include "components/sync/core/activation_context.h" |
17 #include "components/sync/core/model_type_processor.h" | 17 #include "components/sync/core/model_type_processor.h" |
18 #include "components/sync/engine/commit_queue.h" | 18 #include "components/sync/engine/commit_queue.h" |
19 #include "components/sync/engine_impl/cycle/directory_type_debug_info_emitter.h" | 19 #include "components/sync/engine_impl/cycle/directory_type_debug_info_emitter.h" |
20 #include "components/sync/engine_impl/directory_commit_contributor.h" | 20 #include "components/sync/engine_impl/directory_commit_contributor.h" |
21 #include "components/sync/engine_impl/directory_update_handler.h" | 21 #include "components/sync/engine_impl/directory_update_handler.h" |
22 #include "components/sync/engine_impl/model_type_worker.h" | 22 #include "components/sync/engine_impl/model_type_worker.h" |
23 | 23 |
24 namespace syncer { | 24 namespace syncer { |
25 | 25 |
26 namespace { | 26 namespace { |
27 | 27 |
28 class CommitQueueProxy : public CommitQueue { | 28 class CommitQueueProxy : public syncer_v2::CommitQueue { |
29 public: | 29 public: |
30 CommitQueueProxy(const base::WeakPtr<ModelTypeWorker>& worker, | 30 CommitQueueProxy(const base::WeakPtr<syncer_v2::ModelTypeWorker>& worker, |
31 const scoped_refptr<base::SequencedTaskRunner>& sync_thread); | 31 const scoped_refptr<base::SequencedTaskRunner>& sync_thread); |
32 ~CommitQueueProxy() override; | 32 ~CommitQueueProxy() override; |
33 | 33 |
34 void EnqueueForCommit(const CommitRequestDataList& list) override; | 34 void EnqueueForCommit(const syncer_v2::CommitRequestDataList& list) override; |
35 | 35 |
36 private: | 36 private: |
37 base::WeakPtr<ModelTypeWorker> worker_; | 37 base::WeakPtr<syncer_v2::ModelTypeWorker> worker_; |
38 scoped_refptr<base::SequencedTaskRunner> sync_thread_; | 38 scoped_refptr<base::SequencedTaskRunner> sync_thread_; |
39 }; | 39 }; |
40 | 40 |
41 CommitQueueProxy::CommitQueueProxy( | 41 CommitQueueProxy::CommitQueueProxy( |
42 const base::WeakPtr<ModelTypeWorker>& worker, | 42 const base::WeakPtr<syncer_v2::ModelTypeWorker>& worker, |
43 const scoped_refptr<base::SequencedTaskRunner>& sync_thread) | 43 const scoped_refptr<base::SequencedTaskRunner>& sync_thread) |
44 : worker_(worker), sync_thread_(sync_thread) {} | 44 : worker_(worker), sync_thread_(sync_thread) {} |
45 | 45 |
46 CommitQueueProxy::~CommitQueueProxy() {} | 46 CommitQueueProxy::~CommitQueueProxy() {} |
47 | 47 |
48 void CommitQueueProxy::EnqueueForCommit(const CommitRequestDataList& list) { | 48 void CommitQueueProxy::EnqueueForCommit( |
| 49 const syncer_v2::CommitRequestDataList& list) { |
49 sync_thread_->PostTask( | 50 sync_thread_->PostTask( |
50 FROM_HERE, base::Bind(&ModelTypeWorker::EnqueueForCommit, worker_, list)); | 51 FROM_HERE, |
| 52 base::Bind(&syncer_v2::ModelTypeWorker::EnqueueForCommit, worker_, list)); |
51 } | 53 } |
52 | 54 |
53 } // namespace | 55 } // namespace |
54 | 56 |
55 ModelTypeRegistry::ModelTypeRegistry( | 57 ModelTypeRegistry::ModelTypeRegistry( |
56 const std::vector<scoped_refptr<ModelSafeWorker>>& workers, | 58 const std::vector<scoped_refptr<ModelSafeWorker>>& workers, |
57 syncable::Directory* directory, | 59 syncable::Directory* directory, |
58 NudgeHandler* nudge_handler) | 60 NudgeHandler* nudge_handler) |
59 : directory_(directory), | 61 : directory_(directory), |
60 nudge_handler_(nudge_handler), | 62 nudge_handler_(nudge_handler), |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
131 DCHECK(inserted2) << "Attempt to override existing type handler in map"; | 133 DCHECK(inserted2) << "Attempt to override existing type handler in map"; |
132 enabled_directory_types_.Put(type); | 134 enabled_directory_types_.Put(type); |
133 } | 135 } |
134 | 136 |
135 DCHECK(Intersection(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes()) | 137 DCHECK(Intersection(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes()) |
136 .Empty()); | 138 .Empty()); |
137 } | 139 } |
138 | 140 |
139 void ModelTypeRegistry::ConnectType( | 141 void ModelTypeRegistry::ConnectType( |
140 ModelType type, | 142 ModelType type, |
141 std::unique_ptr<ActivationContext> activation_context) { | 143 std::unique_ptr<syncer_v2::ActivationContext> activation_context) { |
142 DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type); | 144 DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type); |
143 | 145 |
144 // Initialize Worker -> Processor communication channel. | 146 // Initialize Worker -> Processor communication channel. |
145 ModelTypeProcessor* type_processor = activation_context->type_processor.get(); | 147 syncer_v2::ModelTypeProcessor* type_processor = |
| 148 activation_context->type_processor.get(); |
146 | 149 |
147 std::unique_ptr<Cryptographer> cryptographer_copy; | 150 std::unique_ptr<Cryptographer> cryptographer_copy; |
148 if (encrypted_types_.Has(type)) | 151 if (encrypted_types_.Has(type)) |
149 cryptographer_copy.reset(new Cryptographer(*cryptographer_)); | 152 cryptographer_copy.reset(new Cryptographer(*cryptographer_)); |
150 | 153 |
151 std::unique_ptr<ModelTypeWorker> worker(new ModelTypeWorker( | 154 std::unique_ptr<syncer_v2::ModelTypeWorker> worker( |
152 type, activation_context->data_type_state, std::move(cryptographer_copy), | 155 new syncer_v2::ModelTypeWorker( |
153 nudge_handler_, std::move(activation_context->type_processor))); | 156 type, activation_context->data_type_state, |
| 157 std::move(cryptographer_copy), nudge_handler_, |
| 158 std::move(activation_context->type_processor))); |
154 | 159 |
155 // Initialize Processor -> Worker communication channel. | 160 // Initialize Processor -> Worker communication channel. |
156 std::unique_ptr<CommitQueue> commit_queue_proxy(new CommitQueueProxy( | 161 std::unique_ptr<syncer_v2::CommitQueue> commit_queue_proxy( |
157 worker->AsWeakPtr(), scoped_refptr<base::SequencedTaskRunner>( | 162 new CommitQueueProxy(worker->AsWeakPtr(), |
| 163 scoped_refptr<base::SequencedTaskRunner>( |
158 base::ThreadTaskRunnerHandle::Get()))); | 164 base::ThreadTaskRunnerHandle::Get()))); |
159 | 165 |
160 type_processor->ConnectSync(std::move(commit_queue_proxy)); | 166 type_processor->ConnectSync(std::move(commit_queue_proxy)); |
161 | 167 |
162 DCHECK(update_handler_map_.find(type) == update_handler_map_.end()); | 168 DCHECK(update_handler_map_.find(type) == update_handler_map_.end()); |
163 DCHECK(commit_contributor_map_.find(type) == commit_contributor_map_.end()); | 169 DCHECK(commit_contributor_map_.find(type) == commit_contributor_map_.end()); |
164 | 170 |
165 update_handler_map_.insert(std::make_pair(type, worker.get())); | 171 update_handler_map_.insert(std::make_pair(type, worker.get())); |
166 commit_contributor_map_.insert(std::make_pair(type, worker.get())); | 172 commit_contributor_map_.insert(std::make_pair(type, worker.get())); |
167 | 173 |
168 // The container takes ownership. | 174 // The container takes ownership. |
169 model_type_workers_.push_back(std::move(worker)); | 175 model_type_workers_.push_back(std::move(worker)); |
170 | 176 |
171 DCHECK(Intersection(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes()) | 177 DCHECK(Intersection(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes()) |
172 .Empty()); | 178 .Empty()); |
173 } | 179 } |
174 | 180 |
175 void ModelTypeRegistry::DisconnectType(ModelType type) { | 181 void ModelTypeRegistry::DisconnectType(ModelType type) { |
176 DVLOG(1) << "Disabling an off-thread sync type: " << ModelTypeToString(type); | 182 DVLOG(1) << "Disabling an off-thread sync type: " << ModelTypeToString(type); |
177 DCHECK(update_handler_map_.find(type) != update_handler_map_.end()); | 183 DCHECK(update_handler_map_.find(type) != update_handler_map_.end()); |
178 DCHECK(commit_contributor_map_.find(type) != commit_contributor_map_.end()); | 184 DCHECK(commit_contributor_map_.find(type) != commit_contributor_map_.end()); |
179 | 185 |
180 size_t updaters_erased = update_handler_map_.erase(type); | 186 size_t updaters_erased = update_handler_map_.erase(type); |
181 size_t committers_erased = commit_contributor_map_.erase(type); | 187 size_t committers_erased = commit_contributor_map_.erase(type); |
182 | 188 |
183 DCHECK_EQ(1U, updaters_erased); | 189 DCHECK_EQ(1U, updaters_erased); |
184 DCHECK_EQ(1U, committers_erased); | 190 DCHECK_EQ(1U, committers_erased); |
185 | 191 |
186 // Remove from the ScopedVector, deleting the worker in the process. | 192 // Remove from the ScopedVector, deleting the worker in the process. |
187 for (ScopedVector<ModelTypeWorker>::iterator it = model_type_workers_.begin(); | 193 for (ScopedVector<syncer_v2::ModelTypeWorker>::iterator it = |
| 194 model_type_workers_.begin(); |
188 it != model_type_workers_.end(); ++it) { | 195 it != model_type_workers_.end(); ++it) { |
189 if ((*it)->GetModelType() == type) { | 196 if ((*it)->GetModelType() == type) { |
190 model_type_workers_.erase(it); | 197 model_type_workers_.erase(it); |
191 break; | 198 break; |
192 } | 199 } |
193 } | 200 } |
194 } | 201 } |
195 | 202 |
196 ModelTypeSet ModelTypeRegistry::GetEnabledTypes() const { | 203 ModelTypeSet ModelTypeRegistry::GetEnabledTypes() const { |
197 return Union(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes()); | 204 return Union(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes()); |
(...skipping 22 matching lines...) Expand all Loading... |
220 CommitContributorMap* ModelTypeRegistry::commit_contributor_map() { | 227 CommitContributorMap* ModelTypeRegistry::commit_contributor_map() { |
221 return &commit_contributor_map_; | 228 return &commit_contributor_map_; |
222 } | 229 } |
223 | 230 |
224 DirectoryTypeDebugInfoEmitterMap* | 231 DirectoryTypeDebugInfoEmitterMap* |
225 ModelTypeRegistry::directory_type_debug_info_emitter_map() { | 232 ModelTypeRegistry::directory_type_debug_info_emitter_map() { |
226 return &directory_type_debug_info_emitter_map_; | 233 return &directory_type_debug_info_emitter_map_; |
227 } | 234 } |
228 | 235 |
229 void ModelTypeRegistry::RegisterDirectoryTypeDebugInfoObserver( | 236 void ModelTypeRegistry::RegisterDirectoryTypeDebugInfoObserver( |
230 TypeDebugInfoObserver* observer) { | 237 syncer::TypeDebugInfoObserver* observer) { |
231 if (!type_debug_info_observers_.HasObserver(observer)) | 238 if (!type_debug_info_observers_.HasObserver(observer)) |
232 type_debug_info_observers_.AddObserver(observer); | 239 type_debug_info_observers_.AddObserver(observer); |
233 } | 240 } |
234 | 241 |
235 void ModelTypeRegistry::UnregisterDirectoryTypeDebugInfoObserver( | 242 void ModelTypeRegistry::UnregisterDirectoryTypeDebugInfoObserver( |
236 TypeDebugInfoObserver* observer) { | 243 syncer::TypeDebugInfoObserver* observer) { |
237 type_debug_info_observers_.RemoveObserver(observer); | 244 type_debug_info_observers_.RemoveObserver(observer); |
238 } | 245 } |
239 | 246 |
240 bool ModelTypeRegistry::HasDirectoryTypeDebugInfoObserver( | 247 bool ModelTypeRegistry::HasDirectoryTypeDebugInfoObserver( |
241 const TypeDebugInfoObserver* observer) const { | 248 const syncer::TypeDebugInfoObserver* observer) const { |
242 return type_debug_info_observers_.HasObserver(observer); | 249 return type_debug_info_observers_.HasObserver(observer); |
243 } | 250 } |
244 | 251 |
245 void ModelTypeRegistry::RequestEmitDebugInfo() { | 252 void ModelTypeRegistry::RequestEmitDebugInfo() { |
246 for (DirectoryTypeDebugInfoEmitterMap::iterator it = | 253 for (DirectoryTypeDebugInfoEmitterMap::iterator it = |
247 directory_type_debug_info_emitter_map_.begin(); | 254 directory_type_debug_info_emitter_map_.begin(); |
248 it != directory_type_debug_info_emitter_map_.end(); ++it) { | 255 it != directory_type_debug_info_emitter_map_.end(); ++it) { |
249 it->second->EmitCommitCountersUpdate(); | 256 it->second->EmitCommitCountersUpdate(); |
250 it->second->EmitUpdateCountersUpdate(); | 257 it->second->EmitUpdateCountersUpdate(); |
251 it->second->EmitStatusCountersUpdate(); | 258 it->second->EmitStatusCountersUpdate(); |
252 } | 259 } |
253 } | 260 } |
254 | 261 |
255 base::WeakPtr<ModelTypeConnector> ModelTypeRegistry::AsWeakPtr() { | 262 base::WeakPtr<syncer_v2::ModelTypeConnector> ModelTypeRegistry::AsWeakPtr() { |
256 return weak_ptr_factory_.GetWeakPtr(); | 263 return weak_ptr_factory_.GetWeakPtr(); |
257 } | 264 } |
258 | 265 |
259 void ModelTypeRegistry::OnPassphraseRequired( | 266 void ModelTypeRegistry::OnPassphraseRequired( |
260 PassphraseRequiredReason reason, | 267 PassphraseRequiredReason reason, |
261 const sync_pb::EncryptedData& pending_keys) {} | 268 const sync_pb::EncryptedData& pending_keys) {} |
262 | 269 |
263 void ModelTypeRegistry::OnPassphraseAccepted() {} | 270 void ModelTypeRegistry::OnPassphraseAccepted() {} |
264 | 271 |
265 void ModelTypeRegistry::OnBootstrapTokenUpdated( | 272 void ModelTypeRegistry::OnBootstrapTokenUpdated( |
(...skipping 18 matching lines...) Expand all Loading... |
284 base::Time passphrase_time) {} | 291 base::Time passphrase_time) {} |
285 | 292 |
286 void ModelTypeRegistry::OnLocalSetPassphraseEncryption( | 293 void ModelTypeRegistry::OnLocalSetPassphraseEncryption( |
287 const SyncEncryptionHandler::NigoriState& nigori_state) {} | 294 const SyncEncryptionHandler::NigoriState& nigori_state) {} |
288 | 295 |
289 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const { | 296 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const { |
290 return enabled_directory_types_; | 297 return enabled_directory_types_; |
291 } | 298 } |
292 | 299 |
293 void ModelTypeRegistry::OnEncryptionStateChanged() { | 300 void ModelTypeRegistry::OnEncryptionStateChanged() { |
294 for (ScopedVector<ModelTypeWorker>::iterator it = model_type_workers_.begin(); | 301 for (ScopedVector<syncer_v2::ModelTypeWorker>::iterator it = |
| 302 model_type_workers_.begin(); |
295 it != model_type_workers_.end(); ++it) { | 303 it != model_type_workers_.end(); ++it) { |
296 if (encrypted_types_.Has((*it)->GetModelType())) { | 304 if (encrypted_types_.Has((*it)->GetModelType())) { |
297 (*it)->UpdateCryptographer( | 305 (*it)->UpdateCryptographer( |
298 base::MakeUnique<Cryptographer>(*cryptographer_)); | 306 base::MakeUnique<Cryptographer>(*cryptographer_)); |
299 } | 307 } |
300 } | 308 } |
301 } | 309 } |
302 | 310 |
303 ModelTypeSet ModelTypeRegistry::GetEnabledNonBlockingTypes() const { | 311 ModelTypeSet ModelTypeRegistry::GetEnabledNonBlockingTypes() const { |
304 ModelTypeSet enabled_non_blocking_types; | 312 ModelTypeSet enabled_non_blocking_types; |
305 for (ScopedVector<ModelTypeWorker>::const_iterator it = | 313 for (ScopedVector<syncer_v2::ModelTypeWorker>::const_iterator it = |
306 model_type_workers_.begin(); | 314 model_type_workers_.begin(); |
307 it != model_type_workers_.end(); ++it) { | 315 it != model_type_workers_.end(); ++it) { |
308 enabled_non_blocking_types.Put((*it)->GetModelType()); | 316 enabled_non_blocking_types.Put((*it)->GetModelType()); |
309 } | 317 } |
310 return enabled_non_blocking_types; | 318 return enabled_non_blocking_types; |
311 } | 319 } |
312 | 320 |
313 } // namespace syncer | 321 } // namespace syncer |
OLD | NEW |