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 "base/message_loop/message_loop_proxy.h" | 7 #include "base/thread_task_runner_handle.h" |
8 #include "components/sync_driver/generic_change_processor.h" | 8 #include "components/sync_driver/generic_change_processor.h" |
9 #include "components/sync_driver/generic_change_processor_factory.h" | 9 #include "components/sync_driver/generic_change_processor_factory.h" |
10 #include "components/sync_driver/sync_api_component_factory.h" | 10 #include "components/sync_driver/sync_api_component_factory.h" |
11 #include "sync/api/sync_change.h" | 11 #include "sync/api/sync_change.h" |
12 | 12 |
13 using base::AutoLock; | 13 using base::AutoLock; |
14 | 14 |
15 namespace syncer { | 15 namespace syncer { |
16 class AttachmentService; | 16 class AttachmentService; |
17 } | 17 } |
18 | 18 |
19 namespace sync_driver { | 19 namespace sync_driver { |
20 | 20 |
21 SharedChangeProcessor::SharedChangeProcessor() | 21 SharedChangeProcessor::SharedChangeProcessor() |
22 : disconnected_(false), | 22 : disconnected_(false), |
23 type_(syncer::UNSPECIFIED), | 23 type_(syncer::UNSPECIFIED), |
24 frontend_loop_(base::MessageLoopProxy::current()), | 24 frontend_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
25 generic_change_processor_(NULL), | 25 generic_change_processor_(NULL), |
26 error_handler_(NULL) { | 26 error_handler_(NULL) { |
27 } | 27 } |
28 | 28 |
29 SharedChangeProcessor::~SharedChangeProcessor() { | 29 SharedChangeProcessor::~SharedChangeProcessor() { |
30 // We can either be deleted when the DTC is destroyed (on UI | 30 // We can either be deleted when the DTC is destroyed (on UI |
31 // thread), or when the syncer::SyncableService stops syncing (datatype | 31 // thread), or when the syncer::SyncableService stops syncing (datatype |
32 // thread). |generic_change_processor_|, if non-NULL, must be | 32 // thread). |generic_change_processor_|, if non-NULL, must be |
33 // deleted on |backend_loop_|. | 33 // deleted on |backend_loop_|. |
34 if (backend_loop_.get()) { | 34 if (backend_task_runner_.get()) { |
35 if (backend_loop_->BelongsToCurrentThread()) { | 35 if (backend_task_runner_->BelongsToCurrentThread()) { |
36 delete generic_change_processor_; | 36 delete generic_change_processor_; |
37 } else { | 37 } else { |
38 DCHECK(frontend_loop_->BelongsToCurrentThread()); | 38 DCHECK(frontend_task_runner_->BelongsToCurrentThread()); |
39 if (!backend_loop_->DeleteSoon(FROM_HERE, generic_change_processor_)) { | 39 if (!backend_task_runner_->DeleteSoon(FROM_HERE, |
| 40 generic_change_processor_)) { |
40 NOTREACHED(); | 41 NOTREACHED(); |
41 } | 42 } |
42 } | 43 } |
43 } else { | 44 } else { |
44 DCHECK(!generic_change_processor_); | 45 DCHECK(!generic_change_processor_); |
45 } | 46 } |
46 } | 47 } |
47 | 48 |
48 base::WeakPtr<syncer::SyncableService> SharedChangeProcessor::Connect( | 49 base::WeakPtr<syncer::SyncableService> SharedChangeProcessor::Connect( |
49 SyncApiComponentFactory* sync_factory, | 50 SyncApiComponentFactory* sync_factory, |
50 GenericChangeProcessorFactory* processor_factory, | 51 GenericChangeProcessorFactory* processor_factory, |
51 syncer::UserShare* user_share, | 52 syncer::UserShare* user_share, |
52 DataTypeErrorHandler* error_handler, | 53 DataTypeErrorHandler* error_handler, |
53 syncer::ModelType type, | 54 syncer::ModelType type, |
54 const base::WeakPtr<syncer::SyncMergeResult>& merge_result) { | 55 const base::WeakPtr<syncer::SyncMergeResult>& merge_result) { |
55 DCHECK(sync_factory); | 56 DCHECK(sync_factory); |
56 DCHECK(error_handler); | 57 DCHECK(error_handler); |
57 DCHECK_NE(type, syncer::UNSPECIFIED); | 58 DCHECK_NE(type, syncer::UNSPECIFIED); |
58 backend_loop_ = base::MessageLoopProxy::current(); | 59 backend_task_runner_ = base::ThreadTaskRunnerHandle::Get(); |
59 AutoLock lock(monitor_lock_); | 60 AutoLock lock(monitor_lock_); |
60 if (disconnected_) | 61 if (disconnected_) |
61 return base::WeakPtr<syncer::SyncableService>(); | 62 return base::WeakPtr<syncer::SyncableService>(); |
62 type_ = type; | 63 type_ = type; |
63 error_handler_ = error_handler; | 64 error_handler_ = error_handler; |
64 base::WeakPtr<syncer::SyncableService> local_service = | 65 base::WeakPtr<syncer::SyncableService> local_service = |
65 sync_factory->GetSyncableServiceForType(type); | 66 sync_factory->GetSyncableServiceForType(type); |
66 if (!local_service.get()) { | 67 if (!local_service.get()) { |
67 LOG(WARNING) << "SyncableService destroyed before DTC was stopped."; | 68 LOG(WARNING) << "SyncableService destroyed before DTC was stopped."; |
68 disconnected_ = true; | 69 disconnected_ = true; |
(...skipping 24 matching lines...) Expand all Loading... |
93 disconnected_ = true; | 94 disconnected_ = true; |
94 error_handler_ = NULL; | 95 error_handler_ = NULL; |
95 return was_connected; | 96 return was_connected; |
96 } | 97 } |
97 | 98 |
98 ChangeProcessor* SharedChangeProcessor::generic_change_processor() { | 99 ChangeProcessor* SharedChangeProcessor::generic_change_processor() { |
99 return generic_change_processor_; | 100 return generic_change_processor_; |
100 } | 101 } |
101 | 102 |
102 int SharedChangeProcessor::GetSyncCount() { | 103 int SharedChangeProcessor::GetSyncCount() { |
103 DCHECK(backend_loop_.get()); | 104 DCHECK(backend_task_runner_.get()); |
104 DCHECK(backend_loop_->BelongsToCurrentThread()); | 105 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
105 AutoLock lock(monitor_lock_); | 106 AutoLock lock(monitor_lock_); |
106 if (disconnected_) { | 107 if (disconnected_) { |
107 LOG(ERROR) << "Change processor disconnected."; | 108 LOG(ERROR) << "Change processor disconnected."; |
108 return 0; | 109 return 0; |
109 } | 110 } |
110 return generic_change_processor_->GetSyncCount(); | 111 return generic_change_processor_->GetSyncCount(); |
111 } | 112 } |
112 | 113 |
113 syncer::SyncError SharedChangeProcessor::ProcessSyncChanges( | 114 syncer::SyncError SharedChangeProcessor::ProcessSyncChanges( |
114 const tracked_objects::Location& from_here, | 115 const tracked_objects::Location& from_here, |
115 const syncer::SyncChangeList& list_of_changes) { | 116 const syncer::SyncChangeList& list_of_changes) { |
116 DCHECK(backend_loop_.get()); | 117 DCHECK(backend_task_runner_.get()); |
117 DCHECK(backend_loop_->BelongsToCurrentThread()); | 118 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
118 AutoLock lock(monitor_lock_); | 119 AutoLock lock(monitor_lock_); |
119 if (disconnected_) { | 120 if (disconnected_) { |
120 // The DTC that disconnects us must ensure it posts a StopSyncing task. | 121 // The DTC that disconnects us must ensure it posts a StopSyncing task. |
121 // If we reach this, it means it just hasn't executed yet. | 122 // If we reach this, it means it just hasn't executed yet. |
122 syncer::SyncError error(FROM_HERE, | 123 syncer::SyncError error(FROM_HERE, |
123 syncer::SyncError::DATATYPE_ERROR, | 124 syncer::SyncError::DATATYPE_ERROR, |
124 "Change processor disconnected.", | 125 "Change processor disconnected.", |
125 type_); | 126 type_); |
126 return error; | 127 return error; |
127 } | 128 } |
128 return generic_change_processor_->ProcessSyncChanges( | 129 return generic_change_processor_->ProcessSyncChanges( |
129 from_here, list_of_changes); | 130 from_here, list_of_changes); |
130 } | 131 } |
131 | 132 |
132 syncer::SyncDataList SharedChangeProcessor::GetAllSyncData( | 133 syncer::SyncDataList SharedChangeProcessor::GetAllSyncData( |
133 syncer::ModelType type) const { | 134 syncer::ModelType type) const { |
134 syncer::SyncDataList data; | 135 syncer::SyncDataList data; |
135 GetAllSyncDataReturnError(type, &data); // Handles the disconnect case. | 136 GetAllSyncDataReturnError(type, &data); // Handles the disconnect case. |
136 return data; | 137 return data; |
137 } | 138 } |
138 | 139 |
139 syncer::SyncError SharedChangeProcessor::GetAllSyncDataReturnError( | 140 syncer::SyncError SharedChangeProcessor::GetAllSyncDataReturnError( |
140 syncer::ModelType type, | 141 syncer::ModelType type, |
141 syncer::SyncDataList* data) const { | 142 syncer::SyncDataList* data) const { |
142 DCHECK(backend_loop_.get()); | 143 DCHECK(backend_task_runner_.get()); |
143 DCHECK(backend_loop_->BelongsToCurrentThread()); | 144 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
144 AutoLock lock(monitor_lock_); | 145 AutoLock lock(monitor_lock_); |
145 if (disconnected_) { | 146 if (disconnected_) { |
146 syncer::SyncError error(FROM_HERE, | 147 syncer::SyncError error(FROM_HERE, |
147 syncer::SyncError::DATATYPE_ERROR, | 148 syncer::SyncError::DATATYPE_ERROR, |
148 "Change processor disconnected.", | 149 "Change processor disconnected.", |
149 type_); | 150 type_); |
150 return error; | 151 return error; |
151 } | 152 } |
152 return generic_change_processor_->GetAllSyncDataReturnError(data); | 153 return generic_change_processor_->GetAllSyncDataReturnError(data); |
153 } | 154 } |
154 | 155 |
155 syncer::SyncError SharedChangeProcessor::UpdateDataTypeContext( | 156 syncer::SyncError SharedChangeProcessor::UpdateDataTypeContext( |
156 syncer::ModelType type, | 157 syncer::ModelType type, |
157 syncer::SyncChangeProcessor::ContextRefreshStatus refresh_status, | 158 syncer::SyncChangeProcessor::ContextRefreshStatus refresh_status, |
158 const std::string& context) { | 159 const std::string& context) { |
159 DCHECK(backend_loop_.get()); | 160 DCHECK(backend_task_runner_.get()); |
160 DCHECK(backend_loop_->BelongsToCurrentThread()); | 161 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
161 AutoLock lock(monitor_lock_); | 162 AutoLock lock(monitor_lock_); |
162 if (disconnected_) { | 163 if (disconnected_) { |
163 syncer::SyncError error(FROM_HERE, | 164 syncer::SyncError error(FROM_HERE, |
164 syncer::SyncError::DATATYPE_ERROR, | 165 syncer::SyncError::DATATYPE_ERROR, |
165 "Change processor disconnected.", | 166 "Change processor disconnected.", |
166 type_); | 167 type_); |
167 return error; | 168 return error; |
168 } | 169 } |
169 return generic_change_processor_->UpdateDataTypeContext( | 170 return generic_change_processor_->UpdateDataTypeContext( |
170 type, refresh_status, context); | 171 type, refresh_status, context); |
171 } | 172 } |
172 | 173 |
173 bool SharedChangeProcessor::SyncModelHasUserCreatedNodes(bool* has_nodes) { | 174 bool SharedChangeProcessor::SyncModelHasUserCreatedNodes(bool* has_nodes) { |
174 DCHECK(backend_loop_.get()); | 175 DCHECK(backend_task_runner_.get()); |
175 DCHECK(backend_loop_->BelongsToCurrentThread()); | 176 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
176 AutoLock lock(monitor_lock_); | 177 AutoLock lock(monitor_lock_); |
177 if (disconnected_) { | 178 if (disconnected_) { |
178 LOG(ERROR) << "Change processor disconnected."; | 179 LOG(ERROR) << "Change processor disconnected."; |
179 return false; | 180 return false; |
180 } | 181 } |
181 return generic_change_processor_->SyncModelHasUserCreatedNodes(has_nodes); | 182 return generic_change_processor_->SyncModelHasUserCreatedNodes(has_nodes); |
182 } | 183 } |
183 | 184 |
184 bool SharedChangeProcessor::CryptoReadyIfNecessary() { | 185 bool SharedChangeProcessor::CryptoReadyIfNecessary() { |
185 DCHECK(backend_loop_.get()); | 186 DCHECK(backend_task_runner_.get()); |
186 DCHECK(backend_loop_->BelongsToCurrentThread()); | 187 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
187 AutoLock lock(monitor_lock_); | 188 AutoLock lock(monitor_lock_); |
188 if (disconnected_) { | 189 if (disconnected_) { |
189 LOG(ERROR) << "Change processor disconnected."; | 190 LOG(ERROR) << "Change processor disconnected."; |
190 return true; // Otherwise we get into infinite spin waiting. | 191 return true; // Otherwise we get into infinite spin waiting. |
191 } | 192 } |
192 return generic_change_processor_->CryptoReadyIfNecessary(); | 193 return generic_change_processor_->CryptoReadyIfNecessary(); |
193 } | 194 } |
194 | 195 |
195 bool SharedChangeProcessor::GetDataTypeContext(std::string* context) const { | 196 bool SharedChangeProcessor::GetDataTypeContext(std::string* context) const { |
196 DCHECK(backend_loop_.get()); | 197 DCHECK(backend_task_runner_.get()); |
197 DCHECK(backend_loop_->BelongsToCurrentThread()); | 198 DCHECK(backend_task_runner_->BelongsToCurrentThread()); |
198 AutoLock lock(monitor_lock_); | 199 AutoLock lock(monitor_lock_); |
199 if (disconnected_) { | 200 if (disconnected_) { |
200 LOG(ERROR) << "Change processor disconnected."; | 201 LOG(ERROR) << "Change processor disconnected."; |
201 return false; | 202 return false; |
202 } | 203 } |
203 return generic_change_processor_->GetDataTypeContext(context); | 204 return generic_change_processor_->GetDataTypeContext(context); |
204 } | 205 } |
205 | 206 |
206 syncer::SyncError SharedChangeProcessor::CreateAndUploadError( | 207 syncer::SyncError SharedChangeProcessor::CreateAndUploadError( |
207 const tracked_objects::Location& location, | 208 const tracked_objects::Location& location, |
208 const std::string& message) { | 209 const std::string& message) { |
209 AutoLock lock(monitor_lock_); | 210 AutoLock lock(monitor_lock_); |
210 if (!disconnected_) { | 211 if (!disconnected_) { |
211 return error_handler_->CreateAndUploadError(location, message, type_); | 212 return error_handler_->CreateAndUploadError(location, message, type_); |
212 } else { | 213 } else { |
213 return syncer::SyncError(location, | 214 return syncer::SyncError(location, |
214 syncer::SyncError::DATATYPE_ERROR, | 215 syncer::SyncError::DATATYPE_ERROR, |
215 message, | 216 message, |
216 type_); | 217 type_); |
217 } | 218 } |
218 } | 219 } |
219 | 220 |
220 } // namespace sync_driver | 221 } // namespace sync_driver |
OLD | NEW |