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/shared_change_processor.h" | 5 #include "components/sync/driver/shared_change_processor.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/threading/sequenced_task_runner_handle.h" | 9 #include "base/threading/sequenced_task_runner_handle.h" |
10 #include "base/threading/thread_task_runner_handle.h" | 10 #include "base/threading/thread_task_runner_handle.h" |
(...skipping 18 matching lines...) Expand all Loading... |
29 generic_change_processor_(nullptr) { | 29 generic_change_processor_(nullptr) { |
30 DCHECK_NE(type_, UNSPECIFIED); | 30 DCHECK_NE(type_, UNSPECIFIED); |
31 } | 31 } |
32 | 32 |
33 SharedChangeProcessor::~SharedChangeProcessor() { | 33 SharedChangeProcessor::~SharedChangeProcessor() { |
34 // We can either be deleted when the DTC is destroyed (on UI thread), or when | 34 // We can either be deleted when the DTC is destroyed (on UI thread), or when |
35 // the SyncableService stops syncing (on |backend_task_runner_|). | 35 // the SyncableService stops syncing (on |backend_task_runner_|). |
36 // |generic_change_processor_|, if non-null, must be deleted on | 36 // |generic_change_processor_|, if non-null, must be deleted on |
37 // |backend_task_runner_|. | 37 // |backend_task_runner_|. |
38 if (backend_task_runner_.get()) { | 38 if (backend_task_runner_.get()) { |
39 if (backend_task_runner_->RunsTasksOnCurrentThread()) { | 39 if (backend_task_runner_->RunsTasksInCurrentSequence()) { |
40 delete generic_change_processor_; | 40 delete generic_change_processor_; |
41 } else { | 41 } else { |
42 DCHECK(frontend_task_runner_->BelongsToCurrentThread()); | 42 DCHECK(frontend_task_runner_->BelongsToCurrentThread()); |
43 if (!backend_task_runner_->DeleteSoon(FROM_HERE, | 43 if (!backend_task_runner_->DeleteSoon(FROM_HERE, |
44 generic_change_processor_)) { | 44 generic_change_processor_)) { |
45 NOTREACHED(); | 45 NOTREACHED(); |
46 } | 46 } |
47 } | 47 } |
48 } else { | 48 } else { |
49 DCHECK(!generic_change_processor_); | 49 DCHECK(!generic_change_processor_); |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
182 error_handler_.reset(); | 182 error_handler_.reset(); |
183 return was_connected; | 183 return was_connected; |
184 } | 184 } |
185 | 185 |
186 ChangeProcessor* SharedChangeProcessor::generic_change_processor() { | 186 ChangeProcessor* SharedChangeProcessor::generic_change_processor() { |
187 return generic_change_processor_; | 187 return generic_change_processor_; |
188 } | 188 } |
189 | 189 |
190 int SharedChangeProcessor::GetSyncCount() { | 190 int SharedChangeProcessor::GetSyncCount() { |
191 DCHECK(backend_task_runner_.get()); | 191 DCHECK(backend_task_runner_.get()); |
192 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 192 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
193 AutoLock lock(monitor_lock_); | 193 AutoLock lock(monitor_lock_); |
194 if (disconnected_) { | 194 if (disconnected_) { |
195 LOG(ERROR) << "Change processor disconnected."; | 195 LOG(ERROR) << "Change processor disconnected."; |
196 return 0; | 196 return 0; |
197 } | 197 } |
198 return generic_change_processor_->GetSyncCount(); | 198 return generic_change_processor_->GetSyncCount(); |
199 } | 199 } |
200 | 200 |
201 SyncError SharedChangeProcessor::ProcessSyncChanges( | 201 SyncError SharedChangeProcessor::ProcessSyncChanges( |
202 const tracked_objects::Location& from_here, | 202 const tracked_objects::Location& from_here, |
203 const SyncChangeList& list_of_changes) { | 203 const SyncChangeList& list_of_changes) { |
204 DCHECK(backend_task_runner_.get()); | 204 DCHECK(backend_task_runner_.get()); |
205 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 205 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
206 AutoLock lock(monitor_lock_); | 206 AutoLock lock(monitor_lock_); |
207 if (disconnected_) { | 207 if (disconnected_) { |
208 // The DTC that disconnects us must ensure it posts a StopSyncing task. | 208 // The DTC that disconnects us must ensure it posts a StopSyncing task. |
209 // If we reach this, it means it just hasn't executed yet. | 209 // If we reach this, it means it just hasn't executed yet. |
210 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 210 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, |
211 "Change processor disconnected.", type_); | 211 "Change processor disconnected.", type_); |
212 return error; | 212 return error; |
213 } | 213 } |
214 return generic_change_processor_->ProcessSyncChanges(from_here, | 214 return generic_change_processor_->ProcessSyncChanges(from_here, |
215 list_of_changes); | 215 list_of_changes); |
216 } | 216 } |
217 | 217 |
218 SyncDataList SharedChangeProcessor::GetAllSyncData(ModelType type) const { | 218 SyncDataList SharedChangeProcessor::GetAllSyncData(ModelType type) const { |
219 SyncDataList data; | 219 SyncDataList data; |
220 GetAllSyncDataReturnError(type, &data); // Handles the disconnect case. | 220 GetAllSyncDataReturnError(type, &data); // Handles the disconnect case. |
221 return data; | 221 return data; |
222 } | 222 } |
223 | 223 |
224 SyncError SharedChangeProcessor::GetAllSyncDataReturnError( | 224 SyncError SharedChangeProcessor::GetAllSyncDataReturnError( |
225 ModelType type, | 225 ModelType type, |
226 SyncDataList* data) const { | 226 SyncDataList* data) const { |
227 DCHECK(backend_task_runner_.get()); | 227 DCHECK(backend_task_runner_.get()); |
228 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 228 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
229 AutoLock lock(monitor_lock_); | 229 AutoLock lock(monitor_lock_); |
230 if (disconnected_) { | 230 if (disconnected_) { |
231 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 231 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, |
232 "Change processor disconnected.", type_); | 232 "Change processor disconnected.", type_); |
233 return error; | 233 return error; |
234 } | 234 } |
235 return generic_change_processor_->GetAllSyncDataReturnError(data); | 235 return generic_change_processor_->GetAllSyncDataReturnError(data); |
236 } | 236 } |
237 | 237 |
238 SyncError SharedChangeProcessor::UpdateDataTypeContext( | 238 SyncError SharedChangeProcessor::UpdateDataTypeContext( |
239 ModelType type, | 239 ModelType type, |
240 SyncChangeProcessor::ContextRefreshStatus refresh_status, | 240 SyncChangeProcessor::ContextRefreshStatus refresh_status, |
241 const std::string& context) { | 241 const std::string& context) { |
242 DCHECK(backend_task_runner_.get()); | 242 DCHECK(backend_task_runner_.get()); |
243 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 243 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
244 AutoLock lock(monitor_lock_); | 244 AutoLock lock(monitor_lock_); |
245 if (disconnected_) { | 245 if (disconnected_) { |
246 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 246 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, |
247 "Change processor disconnected.", type_); | 247 "Change processor disconnected.", type_); |
248 return error; | 248 return error; |
249 } | 249 } |
250 return generic_change_processor_->UpdateDataTypeContext(type, refresh_status, | 250 return generic_change_processor_->UpdateDataTypeContext(type, refresh_status, |
251 context); | 251 context); |
252 } | 252 } |
253 | 253 |
254 void SharedChangeProcessor::AddLocalChangeObserver( | 254 void SharedChangeProcessor::AddLocalChangeObserver( |
255 LocalChangeObserver* observer) { | 255 LocalChangeObserver* observer) { |
256 DCHECK(backend_task_runner_.get()); | 256 DCHECK(backend_task_runner_.get()); |
257 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 257 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
258 | 258 |
259 generic_change_processor_->AddLocalChangeObserver(observer); | 259 generic_change_processor_->AddLocalChangeObserver(observer); |
260 } | 260 } |
261 | 261 |
262 void SharedChangeProcessor::RemoveLocalChangeObserver( | 262 void SharedChangeProcessor::RemoveLocalChangeObserver( |
263 LocalChangeObserver* observer) { | 263 LocalChangeObserver* observer) { |
264 DCHECK(backend_task_runner_.get()); | 264 DCHECK(backend_task_runner_.get()); |
265 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 265 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
266 | 266 |
267 generic_change_processor_->RemoveLocalChangeObserver(observer); | 267 generic_change_processor_->RemoveLocalChangeObserver(observer); |
268 } | 268 } |
269 | 269 |
270 bool SharedChangeProcessor::SyncModelHasUserCreatedNodes(bool* has_nodes) { | 270 bool SharedChangeProcessor::SyncModelHasUserCreatedNodes(bool* has_nodes) { |
271 DCHECK(backend_task_runner_.get()); | 271 DCHECK(backend_task_runner_.get()); |
272 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 272 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
273 AutoLock lock(monitor_lock_); | 273 AutoLock lock(monitor_lock_); |
274 if (disconnected_) { | 274 if (disconnected_) { |
275 LOG(ERROR) << "Change processor disconnected."; | 275 LOG(ERROR) << "Change processor disconnected."; |
276 return false; | 276 return false; |
277 } | 277 } |
278 return generic_change_processor_->SyncModelHasUserCreatedNodes(has_nodes); | 278 return generic_change_processor_->SyncModelHasUserCreatedNodes(has_nodes); |
279 } | 279 } |
280 | 280 |
281 bool SharedChangeProcessor::CryptoReadyIfNecessary() { | 281 bool SharedChangeProcessor::CryptoReadyIfNecessary() { |
282 DCHECK(backend_task_runner_.get()); | 282 DCHECK(backend_task_runner_.get()); |
283 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 283 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
284 AutoLock lock(monitor_lock_); | 284 AutoLock lock(monitor_lock_); |
285 if (disconnected_) { | 285 if (disconnected_) { |
286 LOG(ERROR) << "Change processor disconnected."; | 286 LOG(ERROR) << "Change processor disconnected."; |
287 return true; // Otherwise we get into infinite spin waiting. | 287 return true; // Otherwise we get into infinite spin waiting. |
288 } | 288 } |
289 return generic_change_processor_->CryptoReadyIfNecessary(); | 289 return generic_change_processor_->CryptoReadyIfNecessary(); |
290 } | 290 } |
291 | 291 |
292 bool SharedChangeProcessor::GetDataTypeContext(std::string* context) const { | 292 bool SharedChangeProcessor::GetDataTypeContext(std::string* context) const { |
293 DCHECK(backend_task_runner_.get()); | 293 DCHECK(backend_task_runner_.get()); |
294 DCHECK(backend_task_runner_->RunsTasksOnCurrentThread()); | 294 DCHECK(backend_task_runner_->RunsTasksInCurrentSequence()); |
295 AutoLock lock(monitor_lock_); | 295 AutoLock lock(monitor_lock_); |
296 if (disconnected_) { | 296 if (disconnected_) { |
297 LOG(ERROR) << "Change processor disconnected."; | 297 LOG(ERROR) << "Change processor disconnected."; |
298 return false; | 298 return false; |
299 } | 299 } |
300 return generic_change_processor_->GetDataTypeContext(context); | 300 return generic_change_processor_->GetDataTypeContext(context); |
301 } | 301 } |
302 | 302 |
303 SyncError SharedChangeProcessor::CreateAndUploadError( | 303 SyncError SharedChangeProcessor::CreateAndUploadError( |
304 const tracked_objects::Location& location, | 304 const tracked_objects::Location& location, |
(...skipping 13 matching lines...) Expand all Loading... |
318 #undef PER_DATA_TYPE_MACRO | 318 #undef PER_DATA_TYPE_MACRO |
319 } | 319 } |
320 | 320 |
321 void SharedChangeProcessor::StopLocalService() { | 321 void SharedChangeProcessor::StopLocalService() { |
322 if (local_service_.get()) | 322 if (local_service_.get()) |
323 local_service_->StopSyncing(type_); | 323 local_service_->StopSyncing(type_); |
324 local_service_.reset(); | 324 local_service_.reset(); |
325 } | 325 } |
326 | 326 |
327 } // namespace syncer | 327 } // namespace syncer |
OLD | NEW |