OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "components/browser_sync/browser/profile_sync_components_factory_impl.h
" | |
6 | |
7 #include <utility> | |
8 | |
9 #include "base/command_line.h" | |
10 #include "base/feature_list.h" | |
11 #include "base/memory/ptr_util.h" | |
12 #include "base/memory/ref_counted.h" | |
13 #include "build/build_config.h" | |
14 #include "components/autofill/core/browser/autofill_wallet_data_type_controller.
h" | |
15 #include "components/autofill/core/browser/webdata/autofill_data_type_controller
.h" | |
16 #include "components/autofill/core/browser/webdata/autofill_profile_data_type_co
ntroller.h" | |
17 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h" | |
18 #include "components/autofill/core/common/autofill_pref_names.h" | |
19 #include "components/autofill/core/common/autofill_switches.h" | |
20 #include "components/browser_sync/browser/profile_sync_service.h" | |
21 #include "components/browser_sync/common/browser_sync_switches.h" | |
22 #include "components/dom_distiller/core/dom_distiller_features.h" | |
23 #include "components/history/core/browser/history_delete_directives_data_type_co
ntroller.h" | |
24 #include "components/history/core/browser/typed_url_data_type_controller.h" | |
25 #include "components/password_manager/core/browser/password_store.h" | |
26 #include "components/password_manager/sync/browser/password_data_type_controller
.h" | |
27 #include "components/prefs/pref_service.h" | |
28 #include "components/sync/core/attachments/attachment_downloader.h" | |
29 #include "components/sync/core/attachments/attachment_service.h" | |
30 #include "components/sync/core/attachments/attachment_service_impl.h" | |
31 #include "components/sync/core/attachments/attachment_uploader_impl.h" | |
32 #include "components/sync/device_info/device_info_data_type_controller.h" | |
33 #include "components/sync/device_info/local_device_info_provider_impl.h" | |
34 #include "components/sync/driver/data_type_manager_impl.h" | |
35 #include "components/sync/driver/glue/chrome_report_unrecoverable_error.h" | |
36 #include "components/sync/driver/glue/sync_backend_host.h" | |
37 #include "components/sync/driver/glue/sync_backend_host_impl.h" | |
38 #include "components/sync/driver/proxy_data_type_controller.h" | |
39 #include "components/sync/driver/sync_client.h" | |
40 #include "components/sync/driver/sync_driver_switches.h" | |
41 #include "components/sync/driver/ui_data_type_controller.h" | |
42 #include "components/sync/driver/ui_model_type_controller.h" | |
43 #include "components/sync_bookmarks/bookmark_change_processor.h" | |
44 #include "components/sync_bookmarks/bookmark_data_type_controller.h" | |
45 #include "components/sync_bookmarks/bookmark_model_associator.h" | |
46 #include "components/sync_sessions/session_data_type_controller.h" | |
47 #include "google_apis/gaia/oauth2_token_service.h" | |
48 #include "google_apis/gaia/oauth2_token_service_request.h" | |
49 #include "net/url_request/url_request_context_getter.h" | |
50 | |
51 using bookmarks::BookmarkModel; | |
52 using browser_sync::AutofillDataTypeController; | |
53 using browser_sync::AutofillProfileDataTypeController; | |
54 using browser_sync::ChromeReportUnrecoverableError; | |
55 using browser_sync::HistoryDeleteDirectivesDataTypeController; | |
56 using browser_sync::PasswordDataTypeController; | |
57 using browser_sync::SyncBackendHost; | |
58 using browser_sync::TypedUrlDataTypeController; | |
59 using sync_bookmarks::BookmarkChangeProcessor; | |
60 using sync_bookmarks::BookmarkDataTypeController; | |
61 using sync_bookmarks::BookmarkModelAssociator; | |
62 using sync_driver::DataTypeController; | |
63 using sync_driver::DataTypeManager; | |
64 using sync_driver::DataTypeManagerImpl; | |
65 using sync_driver::DataTypeManagerObserver; | |
66 using sync_driver::DeviceInfoDataTypeController; | |
67 using sync_driver::ProxyDataTypeController; | |
68 using sync_driver::UIDataTypeController; | |
69 using sync_driver_v2::UIModelTypeController; | |
70 using sync_sessions::SessionDataTypeController; | |
71 | |
72 namespace { | |
73 | |
74 syncer::ModelTypeSet GetDisabledTypesFromCommandLine( | |
75 const base::CommandLine& command_line) { | |
76 syncer::ModelTypeSet disabled_types; | |
77 std::string disabled_types_str = | |
78 command_line.GetSwitchValueASCII(switches::kDisableSyncTypes); | |
79 | |
80 disabled_types = syncer::ModelTypeSetFromString(disabled_types_str); | |
81 return disabled_types; | |
82 } | |
83 | |
84 syncer::ModelTypeSet GetEnabledTypesFromCommandLine( | |
85 const base::CommandLine& command_line) { | |
86 return syncer::ModelTypeSet(); | |
87 } | |
88 | |
89 // Used to gate syncing preferences, see crbug.com/374865 for more information. | |
90 // Has always been on for desktop/ChromeOS, so default to on. This feature is | |
91 // mainly to give us a kill switch should something go wrong with starting to | |
92 // sync prefs on mobile. | |
93 const base::Feature kSyncPreferencesFeature{"SyncPreferences", | |
94 base::FEATURE_ENABLED_BY_DEFAULT}; | |
95 | |
96 } // namespace | |
97 | |
98 ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl( | |
99 sync_driver::SyncClient* sync_client, | |
100 version_info::Channel channel, | |
101 const std::string& version, | |
102 bool is_tablet, | |
103 const base::CommandLine& command_line, | |
104 const char* history_disabled_pref, | |
105 const GURL& sync_service_url, | |
106 const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread, | |
107 const scoped_refptr<base::SingleThreadTaskRunner>& db_thread, | |
108 OAuth2TokenService* token_service, | |
109 net::URLRequestContextGetter* url_request_context_getter, | |
110 const scoped_refptr<autofill::AutofillWebDataService>& web_data_service, | |
111 const scoped_refptr<password_manager::PasswordStore>& password_store) | |
112 : sync_client_(sync_client), | |
113 channel_(channel), | |
114 version_(version), | |
115 is_tablet_(is_tablet), | |
116 command_line_(command_line), | |
117 history_disabled_pref_(history_disabled_pref), | |
118 sync_service_url_(sync_service_url), | |
119 ui_thread_(ui_thread), | |
120 db_thread_(db_thread), | |
121 token_service_(token_service), | |
122 url_request_context_getter_(url_request_context_getter), | |
123 web_data_service_(web_data_service), | |
124 password_store_(password_store), | |
125 weak_factory_(this) { | |
126 DCHECK(token_service_); | |
127 DCHECK(url_request_context_getter_); | |
128 } | |
129 | |
130 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {} | |
131 | |
132 void ProfileSyncComponentsFactoryImpl::RegisterDataTypes( | |
133 sync_driver::SyncService* sync_service, | |
134 const RegisterDataTypesMethod& register_platform_types_method) { | |
135 syncer::ModelTypeSet disabled_types = | |
136 GetDisabledTypesFromCommandLine(command_line_); | |
137 syncer::ModelTypeSet enabled_types = | |
138 GetEnabledTypesFromCommandLine(command_line_); | |
139 RegisterCommonDataTypes(sync_service, disabled_types, enabled_types); | |
140 if (!register_platform_types_method.is_null()) | |
141 register_platform_types_method.Run(sync_service, disabled_types, | |
142 enabled_types); | |
143 } | |
144 | |
145 void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes( | |
146 sync_driver::SyncService* sync_service, | |
147 syncer::ModelTypeSet disabled_types, | |
148 syncer::ModelTypeSet enabled_types) { | |
149 base::Closure error_callback = | |
150 base::Bind(&ChromeReportUnrecoverableError, channel_); | |
151 | |
152 // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes? | |
153 if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) { | |
154 sync_service->RegisterDataTypeController( | |
155 base::MakeUnique<UIModelTypeController>(syncer::DEVICE_INFO, | |
156 error_callback, sync_client_)); | |
157 } else { | |
158 sync_service->RegisterDataTypeController( | |
159 base::MakeUnique<DeviceInfoDataTypeController>( | |
160 error_callback, sync_client_, | |
161 sync_service->GetLocalDeviceInfoProvider())); | |
162 } | |
163 | |
164 // Autofill sync is enabled by default. Register unless explicitly | |
165 // disabled. | |
166 if (!disabled_types.Has(syncer::AUTOFILL)) { | |
167 sync_service->RegisterDataTypeController( | |
168 base::MakeUnique<AutofillDataTypeController>( | |
169 db_thread_, error_callback, sync_client_, web_data_service_)); | |
170 } | |
171 | |
172 // Autofill profile sync is enabled by default. Register unless explicitly | |
173 // disabled. | |
174 if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) { | |
175 sync_service->RegisterDataTypeController( | |
176 base::MakeUnique<AutofillProfileDataTypeController>( | |
177 db_thread_, error_callback, sync_client_, web_data_service_)); | |
178 } | |
179 | |
180 // Wallet data sync is enabled by default, but behind a syncer experiment | |
181 // enforced by the datatype controller. Register unless explicitly disabled. | |
182 bool wallet_disabled = disabled_types.Has(syncer::AUTOFILL_WALLET_DATA); | |
183 if (!wallet_disabled) { | |
184 sync_service->RegisterDataTypeController( | |
185 base::MakeUnique<browser_sync::AutofillWalletDataTypeController>( | |
186 syncer::AUTOFILL_WALLET_DATA, db_thread_, error_callback, | |
187 sync_client_, web_data_service_)); | |
188 } | |
189 | |
190 // Wallet metadata sync depends on Wallet data sync. Register if Wallet data | |
191 // is syncing and metadata sync is not explicitly disabled. | |
192 if (!wallet_disabled && | |
193 !disabled_types.Has(syncer::AUTOFILL_WALLET_METADATA)) { | |
194 sync_service->RegisterDataTypeController( | |
195 base::MakeUnique<browser_sync::AutofillWalletDataTypeController>( | |
196 syncer::AUTOFILL_WALLET_METADATA, db_thread_, error_callback, | |
197 sync_client_, web_data_service_)); | |
198 } | |
199 | |
200 // Bookmark sync is enabled by default. Register unless explicitly | |
201 // disabled. | |
202 if (!disabled_types.Has(syncer::BOOKMARKS)) { | |
203 sync_service->RegisterDataTypeController( | |
204 base::MakeUnique<BookmarkDataTypeController>(error_callback, | |
205 sync_client_)); | |
206 } | |
207 | |
208 const bool history_disabled = | |
209 sync_client_->GetPrefService()->GetBoolean(history_disabled_pref_); | |
210 // TypedUrl sync is enabled by default. Register unless explicitly disabled, | |
211 // or if saving history is disabled. | |
212 if (!disabled_types.Has(syncer::TYPED_URLS) && !history_disabled) { | |
213 sync_service->RegisterDataTypeController( | |
214 base::MakeUnique<TypedUrlDataTypeController>( | |
215 error_callback, sync_client_, history_disabled_pref_)); | |
216 } | |
217 | |
218 // Delete directive sync is enabled by default. Register unless full history | |
219 // sync is disabled. | |
220 if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES) && | |
221 !history_disabled) { | |
222 sync_service->RegisterDataTypeController( | |
223 base::MakeUnique<HistoryDeleteDirectivesDataTypeController>( | |
224 error_callback, sync_client_)); | |
225 } | |
226 | |
227 // Session sync is enabled by default. Register unless explicitly disabled. | |
228 // This is also disabled if the browser history is disabled, because the | |
229 // tab sync data is added to the web history on the server. | |
230 if (!disabled_types.Has(syncer::PROXY_TABS) && !history_disabled) { | |
231 sync_service->RegisterDataTypeController( | |
232 base::MakeUnique<ProxyDataTypeController>(syncer::PROXY_TABS)); | |
233 sync_service->RegisterDataTypeController( | |
234 base::MakeUnique<SessionDataTypeController>( | |
235 error_callback, sync_client_, | |
236 sync_service->GetLocalDeviceInfoProvider(), | |
237 history_disabled_pref_)); | |
238 } | |
239 | |
240 // Favicon sync is enabled by default. Register unless explicitly disabled. | |
241 if (!disabled_types.Has(syncer::FAVICON_IMAGES) && | |
242 !disabled_types.Has(syncer::FAVICON_TRACKING) && !history_disabled) { | |
243 // crbug/384552. We disable error uploading for this data types for now. | |
244 sync_service->RegisterDataTypeController( | |
245 base::MakeUnique<UIDataTypeController>(syncer::FAVICON_IMAGES, | |
246 base::Closure(), sync_client_)); | |
247 sync_service->RegisterDataTypeController( | |
248 base::MakeUnique<UIDataTypeController>(syncer::FAVICON_TRACKING, | |
249 base::Closure(), sync_client_)); | |
250 } | |
251 | |
252 // Password sync is enabled by default. Register unless explicitly | |
253 // disabled. | |
254 if (!disabled_types.Has(syncer::PASSWORDS)) { | |
255 sync_service->RegisterDataTypeController( | |
256 base::MakeUnique<PasswordDataTypeController>( | |
257 error_callback, sync_client_, | |
258 sync_client_->GetPasswordStateChangedCallback(), password_store_)); | |
259 } | |
260 | |
261 if (!disabled_types.Has(syncer::PREFERENCES) && | |
262 base::FeatureList::IsEnabled(kSyncPreferencesFeature)) { | |
263 if (!override_prefs_controller_to_uss_for_test_) { | |
264 sync_service->RegisterDataTypeController( | |
265 base::MakeUnique<UIDataTypeController>(syncer::PREFERENCES, | |
266 error_callback, sync_client_)); | |
267 } else { | |
268 sync_service->RegisterDataTypeController( | |
269 base::MakeUnique<UIModelTypeController>( | |
270 syncer::PREFERENCES, error_callback, sync_client_)); | |
271 } | |
272 } | |
273 | |
274 if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) { | |
275 sync_service->RegisterDataTypeController( | |
276 base::MakeUnique<UIDataTypeController>(syncer::PRIORITY_PREFERENCES, | |
277 error_callback, sync_client_)); | |
278 } | |
279 | |
280 // Article sync is disabled by default. Register only if explicitly enabled. | |
281 if (dom_distiller::IsEnableSyncArticlesSet()) { | |
282 sync_service->RegisterDataTypeController( | |
283 base::MakeUnique<UIDataTypeController>(syncer::ARTICLES, error_callback, | |
284 sync_client_)); | |
285 } | |
286 } | |
287 | |
288 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager( | |
289 const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>& | |
290 debug_info_listener, | |
291 const DataTypeController::TypeMap* controllers, | |
292 const sync_driver::DataTypeEncryptionHandler* encryption_handler, | |
293 SyncBackendHost* backend, | |
294 DataTypeManagerObserver* observer) { | |
295 return new DataTypeManagerImpl(debug_info_listener, controllers, | |
296 encryption_handler, backend, observer); | |
297 } | |
298 | |
299 browser_sync::SyncBackendHost* | |
300 ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost( | |
301 const std::string& name, | |
302 invalidation::InvalidationService* invalidator, | |
303 const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs, | |
304 const base::FilePath& sync_folder) { | |
305 return new browser_sync::SyncBackendHostImpl( | |
306 name, sync_client_, ui_thread_, invalidator, sync_prefs, sync_folder); | |
307 } | |
308 | |
309 std::unique_ptr<sync_driver::LocalDeviceInfoProvider> | |
310 ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() { | |
311 return base::MakeUnique<browser_sync::LocalDeviceInfoProviderImpl>( | |
312 channel_, version_, is_tablet_); | |
313 } | |
314 | |
315 class TokenServiceProvider | |
316 : public OAuth2TokenServiceRequest::TokenServiceProvider { | |
317 public: | |
318 TokenServiceProvider( | |
319 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, | |
320 OAuth2TokenService* token_service); | |
321 | |
322 // OAuth2TokenServiceRequest::TokenServiceProvider implementation. | |
323 scoped_refptr<base::SingleThreadTaskRunner> GetTokenServiceTaskRunner() | |
324 override; | |
325 OAuth2TokenService* GetTokenService() override; | |
326 | |
327 private: | |
328 ~TokenServiceProvider() override; | |
329 | |
330 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | |
331 OAuth2TokenService* token_service_; | |
332 }; | |
333 | |
334 TokenServiceProvider::TokenServiceProvider( | |
335 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, | |
336 OAuth2TokenService* token_service) | |
337 : task_runner_(task_runner), token_service_(token_service) {} | |
338 | |
339 TokenServiceProvider::~TokenServiceProvider() {} | |
340 | |
341 scoped_refptr<base::SingleThreadTaskRunner> | |
342 TokenServiceProvider::GetTokenServiceTaskRunner() { | |
343 return task_runner_; | |
344 } | |
345 | |
346 OAuth2TokenService* TokenServiceProvider::GetTokenService() { | |
347 return token_service_; | |
348 } | |
349 | |
350 std::unique_ptr<syncer::AttachmentService> | |
351 ProfileSyncComponentsFactoryImpl::CreateAttachmentService( | |
352 std::unique_ptr<syncer::AttachmentStoreForSync> attachment_store, | |
353 const syncer::UserShare& user_share, | |
354 const std::string& store_birthday, | |
355 syncer::ModelType model_type, | |
356 syncer::AttachmentService::Delegate* delegate) { | |
357 std::unique_ptr<syncer::AttachmentUploader> attachment_uploader; | |
358 std::unique_ptr<syncer::AttachmentDownloader> attachment_downloader; | |
359 // Only construct an AttachmentUploader and AttachmentDownload if we have sync | |
360 // credentials. We may not have sync credentials because there may not be a | |
361 // signed in sync user. | |
362 if (!user_share.sync_credentials.account_id.empty() && | |
363 !user_share.sync_credentials.scope_set.empty()) { | |
364 scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider> | |
365 token_service_provider( | |
366 new TokenServiceProvider(ui_thread_, token_service_)); | |
367 // TODO(maniscalco): Use shared (one per profile) thread-safe instances of | |
368 // AttachmentUploader and AttachmentDownloader instead of creating a new one | |
369 // per AttachmentService (bug 369536). | |
370 attachment_uploader.reset(new syncer::AttachmentUploaderImpl( | |
371 sync_service_url_, url_request_context_getter_, | |
372 user_share.sync_credentials.account_id, | |
373 user_share.sync_credentials.scope_set, token_service_provider, | |
374 store_birthday, model_type)); | |
375 | |
376 token_service_provider = | |
377 new TokenServiceProvider(ui_thread_, token_service_); | |
378 attachment_downloader = syncer::AttachmentDownloader::Create( | |
379 sync_service_url_, url_request_context_getter_, | |
380 user_share.sync_credentials.account_id, | |
381 user_share.sync_credentials.scope_set, token_service_provider, | |
382 store_birthday, model_type); | |
383 } | |
384 | |
385 // It is important that the initial backoff delay is relatively large. For | |
386 // whatever reason, the server may fail all requests for a short period of | |
387 // time. When this happens we don't want to overwhelm the server with | |
388 // requests so we use a large initial backoff. | |
389 const base::TimeDelta initial_backoff_delay = | |
390 base::TimeDelta::FromMinutes(30); | |
391 const base::TimeDelta max_backoff_delay = base::TimeDelta::FromHours(4); | |
392 std::unique_ptr<syncer::AttachmentService> attachment_service( | |
393 new syncer::AttachmentServiceImpl( | |
394 std::move(attachment_store), std::move(attachment_uploader), | |
395 std::move(attachment_downloader), delegate, initial_backoff_delay, | |
396 max_backoff_delay)); | |
397 return attachment_service; | |
398 } | |
399 | |
400 sync_driver::SyncApiComponentFactory::SyncComponents | |
401 ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents( | |
402 sync_driver::SyncService* sync_service, | |
403 std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) { | |
404 BookmarkModel* bookmark_model = | |
405 sync_service->GetSyncClient()->GetBookmarkModel(); | |
406 syncer::UserShare* user_share = sync_service->GetUserShare(); | |
407 // TODO(akalin): We may want to propagate this switch up eventually. | |
408 #if defined(OS_ANDROID) || defined(OS_IOS) | |
409 const bool kExpectMobileBookmarksFolder = true; | |
410 #else | |
411 const bool kExpectMobileBookmarksFolder = false; | |
412 #endif | |
413 BookmarkModelAssociator* model_associator = new BookmarkModelAssociator( | |
414 bookmark_model, sync_service->GetSyncClient(), user_share, | |
415 error_handler->Copy(), kExpectMobileBookmarksFolder); | |
416 BookmarkChangeProcessor* change_processor = | |
417 new BookmarkChangeProcessor(sync_service->GetSyncClient(), | |
418 model_associator, std::move(error_handler)); | |
419 return SyncComponents(model_associator, change_processor); | |
420 } | |
421 | |
422 // static | |
423 void ProfileSyncComponentsFactoryImpl::OverridePrefsForUssTest(bool use_uss) { | |
424 override_prefs_controller_to_uss_for_test_ = use_uss; | |
425 } | |
426 | |
427 bool ProfileSyncComponentsFactoryImpl:: | |
428 override_prefs_controller_to_uss_for_test_ = false; | |
OLD | NEW |