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/thread_task_runner_handle.h" | 9 #include "base/threading/thread_task_runner_handle.h" |
10 #include "components/sync/api/sync_change.h" | 10 #include "components/sync/api/sync_change.h" |
11 #include "components/sync/api/syncable_service.h" | 11 #include "components/sync/api/syncable_service.h" |
12 #include "components/sync/base/data_type_histogram.h" | 12 #include "components/sync/base/data_type_histogram.h" |
13 #include "components/sync/driver/generic_change_processor.h" | 13 #include "components/sync/driver/generic_change_processor.h" |
14 #include "components/sync/driver/generic_change_processor_factory.h" | 14 #include "components/sync/driver/generic_change_processor_factory.h" |
15 #include "components/sync/driver/shared_change_processor_ref.h" | 15 #include "components/sync/driver/shared_change_processor_ref.h" |
16 #include "components/sync/driver/sync_client.h" | 16 #include "components/sync/driver/sync_client.h" |
17 | 17 |
18 using base::AutoLock; | 18 using base::AutoLock; |
19 | 19 |
20 namespace syncer { | 20 namespace syncer { |
21 class AttachmentService; | 21 class AttachmentService; |
22 } // namespace syncer | 22 } // namespace syncer |
23 | 23 |
24 namespace syncer { | 24 namespace sync_driver { |
25 | 25 |
26 SharedChangeProcessor::SharedChangeProcessor(ModelType type) | 26 SharedChangeProcessor::SharedChangeProcessor(syncer::ModelType type) |
27 : disconnected_(false), | 27 : disconnected_(false), |
28 type_(type), | 28 type_(type), |
29 frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()), | 29 frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
30 generic_change_processor_(NULL) { | 30 generic_change_processor_(NULL) { |
31 DCHECK_NE(type_, UNSPECIFIED); | 31 DCHECK_NE(type_, syncer::UNSPECIFIED); |
32 } | 32 } |
33 | 33 |
34 SharedChangeProcessor::~SharedChangeProcessor() { | 34 SharedChangeProcessor::~SharedChangeProcessor() { |
35 // We can either be deleted when the DTC is destroyed (on UI | 35 // We can either be deleted when the DTC is destroyed (on UI |
36 // thread), or when the SyncableService stops syncing (datatype | 36 // thread), or when the syncer::SyncableService stops syncing (datatype |
37 // thread). |generic_change_processor_|, if non-NULL, must be | 37 // thread). |generic_change_processor_|, if non-NULL, must be |
38 // deleted on |backend_loop_|. | 38 // deleted on |backend_loop_|. |
39 if (backend_task_runner_.get()) { | 39 if (backend_task_runner_.get()) { |
40 if (backend_task_runner_->BelongsToCurrentThread()) { | 40 if (backend_task_runner_->BelongsToCurrentThread()) { |
41 delete generic_change_processor_; | 41 delete generic_change_processor_; |
42 } else { | 42 } else { |
43 DCHECK(frontend_task_runner_->BelongsToCurrentThread()); | 43 DCHECK(frontend_task_runner_->BelongsToCurrentThread()); |
44 if (!backend_task_runner_->DeleteSoon(FROM_HERE, | 44 if (!backend_task_runner_->DeleteSoon(FROM_HERE, |
45 generic_change_processor_)) { | 45 generic_change_processor_)) { |
46 NOTREACHED(); | 46 NOTREACHED(); |
47 } | 47 } |
48 } | 48 } |
49 } else { | 49 } else { |
50 DCHECK(!generic_change_processor_); | 50 DCHECK(!generic_change_processor_); |
51 } | 51 } |
52 } | 52 } |
53 | 53 |
54 void SharedChangeProcessor::StartAssociation( | 54 void SharedChangeProcessor::StartAssociation( |
55 StartDoneCallback start_done, | 55 StartDoneCallback start_done, |
56 SyncClient* const sync_client, | 56 SyncClient* const sync_client, |
57 UserShare* user_share, | 57 syncer::UserShare* user_share, |
58 std::unique_ptr<DataTypeErrorHandler> error_handler) { | 58 std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) { |
59 DCHECK(user_share); | 59 DCHECK(user_share); |
60 SyncMergeResult local_merge_result(type_); | 60 syncer::SyncMergeResult local_merge_result(type_); |
61 SyncMergeResult syncer_merge_result(type_); | 61 syncer::SyncMergeResult syncer_merge_result(type_); |
62 base::WeakPtrFactory<SyncMergeResult> weak_ptr_factory(&syncer_merge_result); | 62 base::WeakPtrFactory<syncer::SyncMergeResult> weak_ptr_factory( |
| 63 &syncer_merge_result); |
63 | 64 |
64 // Connect |shared_change_processor| to the syncer and get the | 65 // Connect |shared_change_processor| to the syncer and get the |
65 // SyncableService associated with type_. | 66 // syncer::SyncableService associated with type_. |
66 // Note that it's possible the shared_change_processor has already been | 67 // Note that it's possible the shared_change_processor has already been |
67 // disconnected at this point, so all our accesses to the syncer from this | 68 // disconnected at this point, so all our accesses to the syncer from this |
68 // point on are through it. | 69 // point on are through it. |
69 GenericChangeProcessorFactory factory; | 70 GenericChangeProcessorFactory factory; |
70 local_service_ = | 71 local_service_ = |
71 Connect(sync_client, &factory, user_share, std::move(error_handler), | 72 Connect(sync_client, &factory, user_share, std::move(error_handler), |
72 weak_ptr_factory.GetWeakPtr()); | 73 weak_ptr_factory.GetWeakPtr()); |
73 if (!local_service_.get()) { | 74 if (!local_service_.get()) { |
74 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 75 syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
75 "Failed to connect to syncer.", type_); | 76 "Failed to connect to syncer.", type_); |
76 local_merge_result.set_error(error); | 77 local_merge_result.set_error(error); |
77 start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result, | 78 start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result, |
78 syncer_merge_result); | 79 syncer_merge_result); |
79 return; | 80 return; |
80 } | 81 } |
81 | 82 |
82 if (!CryptoReadyIfNecessary()) { | 83 if (!CryptoReadyIfNecessary()) { |
83 SyncError error(FROM_HERE, SyncError::CRYPTO_ERROR, "", type_); | 84 syncer::SyncError error(FROM_HERE, syncer::SyncError::CRYPTO_ERROR, "", |
| 85 type_); |
84 local_merge_result.set_error(error); | 86 local_merge_result.set_error(error); |
85 start_done.Run(DataTypeController::NEEDS_CRYPTO, local_merge_result, | 87 start_done.Run(DataTypeController::NEEDS_CRYPTO, local_merge_result, |
86 syncer_merge_result); | 88 syncer_merge_result); |
87 return; | 89 return; |
88 } | 90 } |
89 | 91 |
90 bool sync_has_nodes = false; | 92 bool sync_has_nodes = false; |
91 if (!SyncModelHasUserCreatedNodes(&sync_has_nodes)) { | 93 if (!SyncModelHasUserCreatedNodes(&sync_has_nodes)) { |
92 SyncError error(FROM_HERE, SyncError::UNRECOVERABLE_ERROR, | 94 syncer::SyncError error(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR, |
93 "Failed to load sync nodes", type_); | 95 "Failed to load sync nodes", type_); |
94 local_merge_result.set_error(error); | 96 local_merge_result.set_error(error); |
95 start_done.Run(DataTypeController::UNRECOVERABLE_ERROR, local_merge_result, | 97 start_done.Run(DataTypeController::UNRECOVERABLE_ERROR, local_merge_result, |
96 syncer_merge_result); | 98 syncer_merge_result); |
97 return; | 99 return; |
98 } | 100 } |
99 | 101 |
100 // Scope for |initial_sync_data| which might be expensive, so we don't want | 102 // Scope for |initial_sync_data| which might be expensive, so we don't want |
101 // to keep it in memory longer than necessary. | 103 // to keep it in memory longer than necessary. |
102 { | 104 { |
103 SyncDataList initial_sync_data; | 105 syncer::SyncDataList initial_sync_data; |
104 | 106 |
105 base::TimeTicks start_time = base::TimeTicks::Now(); | 107 base::TimeTicks start_time = base::TimeTicks::Now(); |
106 SyncError error = GetAllSyncDataReturnError(type_, &initial_sync_data); | 108 syncer::SyncError error = |
| 109 GetAllSyncDataReturnError(type_, &initial_sync_data); |
107 if (error.IsSet()) { | 110 if (error.IsSet()) { |
108 local_merge_result.set_error(error); | 111 local_merge_result.set_error(error); |
109 start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result, | 112 start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result, |
110 syncer_merge_result); | 113 syncer_merge_result); |
111 return; | 114 return; |
112 } | 115 } |
113 | 116 |
114 std::string datatype_context; | 117 std::string datatype_context; |
115 if (GetDataTypeContext(&datatype_context)) { | 118 if (GetDataTypeContext(&datatype_context)) { |
116 local_service_->UpdateDataTypeContext( | 119 local_service_->UpdateDataTypeContext( |
117 type_, SyncChangeProcessor::NO_REFRESH, datatype_context); | 120 type_, syncer::SyncChangeProcessor::NO_REFRESH, datatype_context); |
118 } | 121 } |
119 | 122 |
120 syncer_merge_result.set_num_items_before_association( | 123 syncer_merge_result.set_num_items_before_association( |
121 initial_sync_data.size()); | 124 initial_sync_data.size()); |
122 // Passes a reference to |shared_change_processor|. | 125 // Passes a reference to |shared_change_processor|. |
123 local_merge_result = local_service_->MergeDataAndStartSyncing( | 126 local_merge_result = local_service_->MergeDataAndStartSyncing( |
124 type_, initial_sync_data, std::unique_ptr<SyncChangeProcessor>( | 127 type_, initial_sync_data, std::unique_ptr<syncer::SyncChangeProcessor>( |
125 new SharedChangeProcessorRef(this)), | 128 new SharedChangeProcessorRef(this)), |
126 std::unique_ptr<SyncErrorFactory>(new SharedChangeProcessorRef(this))); | 129 std::unique_ptr<syncer::SyncErrorFactory>( |
| 130 new SharedChangeProcessorRef(this))); |
127 RecordAssociationTime(base::TimeTicks::Now() - start_time); | 131 RecordAssociationTime(base::TimeTicks::Now() - start_time); |
128 if (local_merge_result.error().IsSet()) { | 132 if (local_merge_result.error().IsSet()) { |
129 start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result, | 133 start_done.Run(DataTypeController::ASSOCIATION_FAILED, local_merge_result, |
130 syncer_merge_result); | 134 syncer_merge_result); |
131 return; | 135 return; |
132 } | 136 } |
133 } | 137 } |
134 | 138 |
135 syncer_merge_result.set_num_items_after_association(GetSyncCount()); | 139 syncer_merge_result.set_num_items_after_association(GetSyncCount()); |
136 | 140 |
137 start_done.Run(!sync_has_nodes ? DataTypeController::OK_FIRST_RUN | 141 start_done.Run(!sync_has_nodes ? DataTypeController::OK_FIRST_RUN |
138 : DataTypeController::OK, | 142 : DataTypeController::OK, |
139 local_merge_result, syncer_merge_result); | 143 local_merge_result, syncer_merge_result); |
140 } | 144 } |
141 | 145 |
142 base::WeakPtr<SyncableService> SharedChangeProcessor::Connect( | 146 base::WeakPtr<syncer::SyncableService> SharedChangeProcessor::Connect( |
143 SyncClient* sync_client, | 147 SyncClient* sync_client, |
144 GenericChangeProcessorFactory* processor_factory, | 148 GenericChangeProcessorFactory* processor_factory, |
145 UserShare* user_share, | 149 syncer::UserShare* user_share, |
146 std::unique_ptr<DataTypeErrorHandler> error_handler, | 150 std::unique_ptr<syncer::DataTypeErrorHandler> error_handler, |
147 const base::WeakPtr<SyncMergeResult>& merge_result) { | 151 const base::WeakPtr<syncer::SyncMergeResult>& merge_result) { |
148 DCHECK(sync_client); | 152 DCHECK(sync_client); |
149 DCHECK(error_handler); | 153 DCHECK(error_handler); |
150 backend_task_runner_ = base::ThreadTaskRunnerHandle::Get(); | 154 backend_task_runner_ = base::ThreadTaskRunnerHandle::Get(); |
151 AutoLock lock(monitor_lock_); | 155 AutoLock lock(monitor_lock_); |
152 if (disconnected_) | 156 if (disconnected_) |
153 return base::WeakPtr<SyncableService>(); | 157 return base::WeakPtr<syncer::SyncableService>(); |
154 error_handler_ = std::move(error_handler); | 158 error_handler_ = std::move(error_handler); |
155 base::WeakPtr<SyncableService> local_service = | 159 base::WeakPtr<syncer::SyncableService> local_service = |
156 sync_client->GetSyncableServiceForType(type_); | 160 sync_client->GetSyncableServiceForType(type_); |
157 if (!local_service.get()) { | 161 if (!local_service.get()) { |
158 LOG(WARNING) << "SyncableService destroyed before DTC was stopped."; | 162 LOG(WARNING) << "SyncableService destroyed before DTC was stopped."; |
159 disconnected_ = true; | 163 disconnected_ = true; |
160 return base::WeakPtr<SyncableService>(); | 164 return base::WeakPtr<syncer::SyncableService>(); |
161 } | 165 } |
162 | 166 |
163 generic_change_processor_ = processor_factory | 167 generic_change_processor_ = processor_factory |
164 ->CreateGenericChangeProcessor( | 168 ->CreateGenericChangeProcessor( |
165 type_, user_share, error_handler_->Copy(), | 169 type_, user_share, error_handler_->Copy(), |
166 local_service, merge_result, sync_client) | 170 local_service, merge_result, sync_client) |
167 .release(); | 171 .release(); |
168 // If available, propagate attachment service to the syncable service. | 172 // If available, propagate attachment service to the syncable service. |
169 std::unique_ptr<AttachmentService> attachment_service = | 173 std::unique_ptr<syncer::AttachmentService> attachment_service = |
170 generic_change_processor_->GetAttachmentService(); | 174 generic_change_processor_->GetAttachmentService(); |
171 if (attachment_service) { | 175 if (attachment_service) { |
172 local_service->SetAttachmentService(std::move(attachment_service)); | 176 local_service->SetAttachmentService(std::move(attachment_service)); |
173 } | 177 } |
174 return local_service; | 178 return local_service; |
175 } | 179 } |
176 | 180 |
177 bool SharedChangeProcessor::Disconnect() { | 181 bool SharedChangeProcessor::Disconnect() { |
178 // May be called from any thread. | 182 // May be called from any thread. |
179 DVLOG(1) << "Disconnecting change processor."; | 183 DVLOG(1) << "Disconnecting change processor."; |
(...skipping 12 matching lines...) Expand all Loading... |
192 DCHECK(backend_task_runner_.get()); | 196 DCHECK(backend_task_runner_.get()); |
193 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 197 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
194 AutoLock lock(monitor_lock_); | 198 AutoLock lock(monitor_lock_); |
195 if (disconnected_) { | 199 if (disconnected_) { |
196 LOG(ERROR) << "Change processor disconnected."; | 200 LOG(ERROR) << "Change processor disconnected."; |
197 return 0; | 201 return 0; |
198 } | 202 } |
199 return generic_change_processor_->GetSyncCount(); | 203 return generic_change_processor_->GetSyncCount(); |
200 } | 204 } |
201 | 205 |
202 SyncError SharedChangeProcessor::ProcessSyncChanges( | 206 syncer::SyncError SharedChangeProcessor::ProcessSyncChanges( |
203 const tracked_objects::Location& from_here, | 207 const tracked_objects::Location& from_here, |
204 const SyncChangeList& list_of_changes) { | 208 const syncer::SyncChangeList& list_of_changes) { |
205 DCHECK(backend_task_runner_.get()); | 209 DCHECK(backend_task_runner_.get()); |
206 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 210 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
207 AutoLock lock(monitor_lock_); | 211 AutoLock lock(monitor_lock_); |
208 if (disconnected_) { | 212 if (disconnected_) { |
209 // The DTC that disconnects us must ensure it posts a StopSyncing task. | 213 // The DTC that disconnects us must ensure it posts a StopSyncing task. |
210 // If we reach this, it means it just hasn't executed yet. | 214 // If we reach this, it means it just hasn't executed yet. |
211 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 215 syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
212 "Change processor disconnected.", type_); | 216 "Change processor disconnected.", type_); |
213 return error; | 217 return error; |
214 } | 218 } |
215 return generic_change_processor_->ProcessSyncChanges(from_here, | 219 return generic_change_processor_->ProcessSyncChanges(from_here, |
216 list_of_changes); | 220 list_of_changes); |
217 } | 221 } |
218 | 222 |
219 SyncDataList SharedChangeProcessor::GetAllSyncData(ModelType type) const { | 223 syncer::SyncDataList SharedChangeProcessor::GetAllSyncData( |
220 SyncDataList data; | 224 syncer::ModelType type) const { |
| 225 syncer::SyncDataList data; |
221 GetAllSyncDataReturnError(type, &data); // Handles the disconnect case. | 226 GetAllSyncDataReturnError(type, &data); // Handles the disconnect case. |
222 return data; | 227 return data; |
223 } | 228 } |
224 | 229 |
225 SyncError SharedChangeProcessor::GetAllSyncDataReturnError( | 230 syncer::SyncError SharedChangeProcessor::GetAllSyncDataReturnError( |
226 ModelType type, | 231 syncer::ModelType type, |
227 SyncDataList* data) const { | 232 syncer::SyncDataList* data) const { |
228 DCHECK(backend_task_runner_.get()); | 233 DCHECK(backend_task_runner_.get()); |
229 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 234 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
230 AutoLock lock(monitor_lock_); | 235 AutoLock lock(monitor_lock_); |
231 if (disconnected_) { | 236 if (disconnected_) { |
232 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 237 syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
233 "Change processor disconnected.", type_); | 238 "Change processor disconnected.", type_); |
234 return error; | 239 return error; |
235 } | 240 } |
236 return generic_change_processor_->GetAllSyncDataReturnError(data); | 241 return generic_change_processor_->GetAllSyncDataReturnError(data); |
237 } | 242 } |
238 | 243 |
239 SyncError SharedChangeProcessor::UpdateDataTypeContext( | 244 syncer::SyncError SharedChangeProcessor::UpdateDataTypeContext( |
240 ModelType type, | 245 syncer::ModelType type, |
241 SyncChangeProcessor::ContextRefreshStatus refresh_status, | 246 syncer::SyncChangeProcessor::ContextRefreshStatus refresh_status, |
242 const std::string& context) { | 247 const std::string& context) { |
243 DCHECK(backend_task_runner_.get()); | 248 DCHECK(backend_task_runner_.get()); |
244 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 249 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
245 AutoLock lock(monitor_lock_); | 250 AutoLock lock(monitor_lock_); |
246 if (disconnected_) { | 251 if (disconnected_) { |
247 SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, | 252 syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, |
248 "Change processor disconnected.", type_); | 253 "Change processor disconnected.", type_); |
249 return error; | 254 return error; |
250 } | 255 } |
251 return generic_change_processor_->UpdateDataTypeContext(type, refresh_status, | 256 return generic_change_processor_->UpdateDataTypeContext(type, refresh_status, |
252 context); | 257 context); |
253 } | 258 } |
254 | 259 |
255 void SharedChangeProcessor::AddLocalChangeObserver( | 260 void SharedChangeProcessor::AddLocalChangeObserver( |
256 LocalChangeObserver* observer) { | 261 syncer::LocalChangeObserver* observer) { |
257 DCHECK(backend_task_runner_.get()); | 262 DCHECK(backend_task_runner_.get()); |
258 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 263 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
259 | 264 |
260 generic_change_processor_->AddLocalChangeObserver(observer); | 265 generic_change_processor_->AddLocalChangeObserver(observer); |
261 } | 266 } |
262 | 267 |
263 void SharedChangeProcessor::RemoveLocalChangeObserver( | 268 void SharedChangeProcessor::RemoveLocalChangeObserver( |
264 LocalChangeObserver* observer) { | 269 syncer::LocalChangeObserver* observer) { |
265 DCHECK(backend_task_runner_.get()); | 270 DCHECK(backend_task_runner_.get()); |
266 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 271 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
267 | 272 |
268 generic_change_processor_->RemoveLocalChangeObserver(observer); | 273 generic_change_processor_->RemoveLocalChangeObserver(observer); |
269 } | 274 } |
270 | 275 |
271 bool SharedChangeProcessor::SyncModelHasUserCreatedNodes(bool* has_nodes) { | 276 bool SharedChangeProcessor::SyncModelHasUserCreatedNodes(bool* has_nodes) { |
272 DCHECK(backend_task_runner_.get()); | 277 DCHECK(backend_task_runner_.get()); |
273 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 278 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
274 AutoLock lock(monitor_lock_); | 279 AutoLock lock(monitor_lock_); |
(...skipping 19 matching lines...) Expand all Loading... |
294 DCHECK(backend_task_runner_.get()); | 299 DCHECK(backend_task_runner_.get()); |
295 DCHECK(backend_task_runner_->BelongsToCurrentThread()); | 300 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
296 AutoLock lock(monitor_lock_); | 301 AutoLock lock(monitor_lock_); |
297 if (disconnected_) { | 302 if (disconnected_) { |
298 LOG(ERROR) << "Change processor disconnected."; | 303 LOG(ERROR) << "Change processor disconnected."; |
299 return false; | 304 return false; |
300 } | 305 } |
301 return generic_change_processor_->GetDataTypeContext(context); | 306 return generic_change_processor_->GetDataTypeContext(context); |
302 } | 307 } |
303 | 308 |
304 SyncError SharedChangeProcessor::CreateAndUploadError( | 309 syncer::SyncError SharedChangeProcessor::CreateAndUploadError( |
305 const tracked_objects::Location& location, | 310 const tracked_objects::Location& location, |
306 const std::string& message) { | 311 const std::string& message) { |
307 AutoLock lock(monitor_lock_); | 312 AutoLock lock(monitor_lock_); |
308 if (!disconnected_) { | 313 if (!disconnected_) { |
309 return error_handler_->CreateAndUploadError(location, message, type_); | 314 return error_handler_->CreateAndUploadError(location, message, type_); |
310 } else { | 315 } else { |
311 return SyncError(location, SyncError::DATATYPE_ERROR, message, type_); | 316 return syncer::SyncError(location, syncer::SyncError::DATATYPE_ERROR, |
| 317 message, type_); |
312 } | 318 } |
313 } | 319 } |
314 | 320 |
315 void SharedChangeProcessor::RecordAssociationTime(base::TimeDelta time) { | 321 void SharedChangeProcessor::RecordAssociationTime(base::TimeDelta time) { |
316 #define PER_DATA_TYPE_MACRO(type_str) \ | 322 #define PER_DATA_TYPE_MACRO(type_str) \ |
317 UMA_HISTOGRAM_TIMES("Sync." type_str "AssociationTime", time); | 323 UMA_HISTOGRAM_TIMES("Sync." type_str "AssociationTime", time); |
318 SYNC_DATA_TYPE_HISTOGRAM(type_); | 324 SYNC_DATA_TYPE_HISTOGRAM(type_); |
319 #undef PER_DATA_TYPE_MACRO | 325 #undef PER_DATA_TYPE_MACRO |
320 } | 326 } |
321 | 327 |
322 void SharedChangeProcessor::StopLocalService() { | 328 void SharedChangeProcessor::StopLocalService() { |
323 if (local_service_.get()) | 329 if (local_service_.get()) |
324 local_service_->StopSyncing(type_); | 330 local_service_->StopSyncing(type_); |
325 local_service_.reset(); | 331 local_service_.reset(); |
326 } | 332 } |
327 | 333 |
328 } // namespace syncer | 334 } // namespace sync_driver |
OLD | NEW |