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