| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/browser_sync/profile_sync_components_factory_impl.h" |
| |
| #include <utility> |
| |
| #include "base/feature_list.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/single_thread_task_runner.h" |
| #include "build/build_config.h" |
| #include "components/autofill/core/browser/autofill_wallet_data_type_controller.h" |
| #include "components/autofill/core/browser/webdata/autocomplete_sync_bridge.h" |
| #include "components/autofill/core/browser/webdata/autofill_data_type_controller.h" |
| #include "components/autofill/core/browser/webdata/autofill_profile_data_type_controller.h" |
| #include "components/autofill/core/browser/webdata/autofill_webdata_service.h" |
| #include "components/autofill/core/browser/webdata/web_data_model_type_controller.h" |
| #include "components/autofill/core/common/autofill_pref_names.h" |
| #include "components/autofill/core/common/autofill_switches.h" |
| #include "components/browser_sync/browser_sync_switches.h" |
| #include "components/browser_sync/profile_sync_service.h" |
| #include "components/dom_distiller/core/dom_distiller_features.h" |
| #include "components/history/core/browser/history_delete_directives_data_type_controller.h" |
| #include "components/history/core/browser/typed_url_data_type_controller.h" |
| #include "components/history/core/browser/typed_url_model_type_controller.h" |
| #include "components/password_manager/core/browser/password_store.h" |
| #include "components/password_manager/sync/browser/password_data_type_controller.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/reading_list/features/reading_list_switches.h" |
| #include "components/sync/base/report_unrecoverable_error.h" |
| #include "components/sync/device_info/local_device_info_provider_impl.h" |
| #include "components/sync/driver/async_directory_type_controller.h" |
| #include "components/sync/driver/data_type_manager_impl.h" |
| #include "components/sync/driver/glue/sync_backend_host_impl.h" |
| #include "components/sync/driver/model_type_controller.h" |
| #include "components/sync/driver/proxy_data_type_controller.h" |
| #include "components/sync/driver/sync_client.h" |
| #include "components/sync/driver/sync_driver_switches.h" |
| #include "components/sync/engine/attachments/attachment_downloader.h" |
| #include "components/sync/engine/attachments/attachment_uploader.h" |
| #include "components/sync/engine/sync_engine.h" |
| #include "components/sync/model/attachments/attachment_service.h" |
| #include "components/sync_bookmarks/bookmark_change_processor.h" |
| #include "components/sync_bookmarks/bookmark_data_type_controller.h" |
| #include "components/sync_bookmarks/bookmark_model_associator.h" |
| #include "components/sync_bookmarks/bookmark_model_type_controller.h" |
| #include "components/sync_sessions/session_data_type_controller.h" |
| #include "google_apis/gaia/oauth2_token_service.h" |
| #include "google_apis/gaia/oauth2_token_service_request.h" |
| #include "net/url_request/url_request_context_getter.h" |
| |
| using base::FeatureList; |
| using bookmarks::BookmarkModel; |
| using sync_bookmarks::BookmarkChangeProcessor; |
| using sync_bookmarks::BookmarkDataTypeController; |
| using sync_bookmarks::BookmarkModelAssociator; |
| using sync_sessions::SessionDataTypeController; |
| using syncer::AsyncDirectoryTypeController; |
| using syncer::DataTypeController; |
| using syncer::DataTypeManager; |
| using syncer::DataTypeManagerImpl; |
| using syncer::DataTypeManagerObserver; |
| using syncer::ModelTypeController; |
| using syncer::ProxyDataTypeController; |
| |
| namespace browser_sync { |
| |
| namespace { |
| |
| syncer::ModelTypeSet GetDisabledTypesFromCommandLine( |
| const base::CommandLine& command_line) { |
| syncer::ModelTypeSet disabled_types; |
| std::string disabled_types_str = |
| command_line.GetSwitchValueASCII(switches::kDisableSyncTypes); |
| |
| disabled_types = syncer::ModelTypeSetFromString(disabled_types_str); |
| return disabled_types; |
| } |
| |
| syncer::ModelTypeSet GetEnabledTypesFromCommandLine( |
| const base::CommandLine& command_line) { |
| return syncer::ModelTypeSet(); |
| } |
| |
| } // namespace |
| |
| ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl( |
| syncer::SyncClient* sync_client, |
| version_info::Channel channel, |
| const std::string& version, |
| bool is_tablet, |
| const base::CommandLine& command_line, |
| const char* history_disabled_pref, |
| const GURL& sync_service_url, |
| const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread, |
| const scoped_refptr<base::SingleThreadTaskRunner>& db_thread, |
| OAuth2TokenService* token_service, |
| net::URLRequestContextGetter* url_request_context_getter, |
| const scoped_refptr<autofill::AutofillWebDataService>& web_data_service, |
| const scoped_refptr<password_manager::PasswordStore>& password_store) |
| : sync_client_(sync_client), |
| channel_(channel), |
| version_(version), |
| is_tablet_(is_tablet), |
| command_line_(command_line), |
| history_disabled_pref_(history_disabled_pref), |
| sync_service_url_(sync_service_url), |
| ui_thread_(ui_thread), |
| db_thread_(db_thread), |
| token_service_(token_service), |
| url_request_context_getter_(url_request_context_getter), |
| web_data_service_(web_data_service), |
| password_store_(password_store), |
| weak_factory_(this) { |
| DCHECK(token_service_); |
| DCHECK(url_request_context_getter_); |
| } |
| |
| ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {} |
| |
| void ProfileSyncComponentsFactoryImpl::RegisterDataTypes( |
| syncer::SyncService* sync_service, |
| const RegisterDataTypesMethod& register_platform_types_method) { |
| syncer::ModelTypeSet disabled_types = |
| GetDisabledTypesFromCommandLine(command_line_); |
| syncer::ModelTypeSet enabled_types = |
| GetEnabledTypesFromCommandLine(command_line_); |
| RegisterCommonDataTypes(sync_service, disabled_types, enabled_types); |
| if (!register_platform_types_method.is_null()) |
| register_platform_types_method.Run(sync_service, disabled_types, |
| enabled_types); |
| } |
| |
| void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes( |
| syncer::SyncService* sync_service, |
| syncer::ModelTypeSet disabled_types, |
| syncer::ModelTypeSet enabled_types) { |
| base::Closure error_callback = |
| base::Bind(&syncer::ReportUnrecoverableError, channel_); |
| |
| // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes? |
| // Use an error callback that always uploads a stacktrace if it can to help |
| // get USS as stable as possible. |
| sync_service->RegisterDataTypeController( |
| std::make_unique<ModelTypeController>(syncer::DEVICE_INFO, sync_client_, |
| ui_thread_)); |
| // These features are enabled only if there's a DB thread to post tasks to. |
| if (db_thread_) { |
| // Autocomplete sync is enabled by default. Register unless explicitly |
| // disabled. |
| if (!disabled_types.Has(syncer::AUTOFILL)) { |
| if (FeatureList::IsEnabled(switches::kSyncUSSAutocomplete)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<autofill::WebDataModelTypeController>( |
| syncer::AUTOFILL, sync_client_, db_thread_, web_data_service_, |
| base::Bind( |
| &autofill::AutocompleteSyncBridge::FromWebDataService))); |
| } else { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AutofillDataTypeController>( |
| db_thread_, error_callback, sync_client_, web_data_service_)); |
| } |
| } |
| |
| // Autofill sync is enabled by default. Register unless explicitly |
| // disabled. |
| if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AutofillProfileDataTypeController>( |
| db_thread_, error_callback, sync_client_, web_data_service_)); |
| } |
| |
| // Wallet data sync is enabled by default, but behind a syncer experiment |
| // enforced by the datatype controller. Register unless explicitly disabled. |
| bool wallet_disabled = disabled_types.Has(syncer::AUTOFILL_WALLET_DATA); |
| if (!wallet_disabled) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AutofillWalletDataTypeController>( |
| syncer::AUTOFILL_WALLET_DATA, db_thread_, error_callback, |
| sync_client_, web_data_service_)); |
| } |
| |
| // Wallet metadata sync depends on Wallet data sync. Register if Wallet data |
| // is syncing and metadata sync is not explicitly disabled. |
| if (!wallet_disabled && |
| !disabled_types.Has(syncer::AUTOFILL_WALLET_METADATA)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AutofillWalletDataTypeController>( |
| syncer::AUTOFILL_WALLET_METADATA, db_thread_, error_callback, |
| sync_client_, web_data_service_)); |
| } |
| } |
| |
| // Bookmark sync is enabled by default. Register unless explicitly |
| // disabled. |
| if (!disabled_types.Has(syncer::BOOKMARKS)) { |
| if (FeatureList::IsEnabled(switches::kSyncUSSBookmarks)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<sync_bookmarks::BookmarkModelTypeController>( |
| sync_client_)); |
| } else { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<BookmarkDataTypeController>(error_callback, |
| sync_client_)); |
| } |
| } |
| |
| // These features are enabled only if history is not disabled. |
| if (!sync_client_->GetPrefService()->GetBoolean(history_disabled_pref_)) { |
| // TypedUrl sync is enabled by default. Register unless explicitly |
| // disabled. |
| if (!disabled_types.Has(syncer::TYPED_URLS)) { |
| if (base::FeatureList::IsEnabled(switches::kSyncUSSTypedURL)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<history::TypedURLModelTypeController>( |
| sync_client_, history_disabled_pref_)); |
| } else { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<TypedUrlDataTypeController>( |
| error_callback, sync_client_, history_disabled_pref_)); |
| } |
| } |
| |
| // Delete directive sync is enabled by default. |
| if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<HistoryDeleteDirectivesDataTypeController>( |
| error_callback, sync_client_)); |
| } |
| |
| // Session sync is enabled by default. This is disabled if history is |
| // disabled because the tab sync data is added to the web history on the |
| // server. |
| if (!disabled_types.Has(syncer::PROXY_TABS)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<ProxyDataTypeController>(syncer::PROXY_TABS)); |
| sync_service->RegisterDataTypeController( |
| std::make_unique<SessionDataTypeController>( |
| error_callback, sync_client_, |
| sync_service->GetLocalDeviceInfoProvider(), |
| history_disabled_pref_)); |
| } |
| |
| // Favicon sync is enabled by default. Register unless explicitly disabled. |
| if (!disabled_types.Has(syncer::FAVICON_IMAGES) && |
| !disabled_types.Has(syncer::FAVICON_TRACKING)) { |
| // crbug/384552. We disable error uploading for this data types for now. |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AsyncDirectoryTypeController>( |
| syncer::FAVICON_IMAGES, base::Closure(), sync_client_, |
| syncer::GROUP_UI, ui_thread_)); |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AsyncDirectoryTypeController>( |
| syncer::FAVICON_TRACKING, base::Closure(), sync_client_, |
| syncer::GROUP_UI, ui_thread_)); |
| } |
| } |
| |
| // Password sync is enabled by default. Register unless explicitly |
| // disabled. |
| if (!disabled_types.Has(syncer::PASSWORDS)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<PasswordDataTypeController>( |
| error_callback, sync_client_, |
| sync_client_->GetPasswordStateChangedCallback(), password_store_)); |
| } |
| |
| if (!disabled_types.Has(syncer::PREFERENCES)) { |
| if (!override_prefs_controller_to_uss_for_test_) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AsyncDirectoryTypeController>( |
| syncer::PREFERENCES, error_callback, sync_client_, |
| syncer::GROUP_UI, ui_thread_)); |
| } else { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<ModelTypeController>(syncer::PREFERENCES, |
| sync_client_, ui_thread_)); |
| } |
| } |
| |
| if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AsyncDirectoryTypeController>( |
| syncer::PRIORITY_PREFERENCES, error_callback, sync_client_, |
| syncer::GROUP_UI, ui_thread_)); |
| } |
| |
| // Article sync is disabled by default. Register only if explicitly enabled. |
| if (dom_distiller::IsEnableSyncArticlesSet()) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<AsyncDirectoryTypeController>( |
| syncer::ARTICLES, error_callback, sync_client_, syncer::GROUP_UI, |
| ui_thread_)); |
| } |
| |
| #if defined(OS_CHROMEOS) |
| if (!disabled_types.Has(syncer::PRINTERS)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<ModelTypeController>(syncer::PRINTERS, sync_client_, |
| ui_thread_)); |
| } |
| #endif |
| |
| // Reading list sync is enabled by default only on iOS. Register unless |
| // Reading List or Reading List Sync is explicitly disabled. |
| if (!disabled_types.Has(syncer::READING_LIST) && |
| reading_list::switches::IsReadingListEnabled()) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<ModelTypeController>(syncer::READING_LIST, |
| sync_client_, ui_thread_)); |
| } |
| |
| if (!disabled_types.Has(syncer::USER_EVENTS) && |
| FeatureList::IsEnabled(switches::kSyncUserEvents)) { |
| sync_service->RegisterDataTypeController( |
| std::make_unique<ModelTypeController>(syncer::USER_EVENTS, sync_client_, |
| ui_thread_)); |
| } |
| } |
| |
| DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager( |
| syncer::ModelTypeSet initial_types, |
| const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>& |
| debug_info_listener, |
| const DataTypeController::TypeMap* controllers, |
| const syncer::DataTypeEncryptionHandler* encryption_handler, |
| syncer::ModelTypeConfigurer* configurer, |
| DataTypeManagerObserver* observer) { |
| return new DataTypeManagerImpl(sync_client_, initial_types, |
| debug_info_listener, controllers, |
| encryption_handler, configurer, observer); |
| } |
| |
| syncer::SyncEngine* ProfileSyncComponentsFactoryImpl::CreateSyncEngine( |
| const std::string& name, |
| invalidation::InvalidationService* invalidator, |
| const base::WeakPtr<syncer::SyncPrefs>& sync_prefs, |
| const base::FilePath& sync_data_folder) { |
| return new syncer::SyncBackendHostImpl(name, sync_client_, invalidator, |
| sync_prefs, sync_data_folder); |
| } |
| |
| std::unique_ptr<syncer::LocalDeviceInfoProvider> |
| ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() { |
| return std::make_unique<syncer::LocalDeviceInfoProviderImpl>( |
| channel_, version_, is_tablet_); |
| } |
| |
| class TokenServiceProvider |
| : public OAuth2TokenServiceRequest::TokenServiceProvider { |
| public: |
| TokenServiceProvider( |
| const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, |
| OAuth2TokenService* token_service); |
| |
| // OAuth2TokenServiceRequest::TokenServiceProvider implementation. |
| scoped_refptr<base::SingleThreadTaskRunner> GetTokenServiceTaskRunner() |
| override; |
| OAuth2TokenService* GetTokenService() override; |
| |
| private: |
| ~TokenServiceProvider() override; |
| |
| scoped_refptr<base::SingleThreadTaskRunner> task_runner_; |
| OAuth2TokenService* token_service_; |
| }; |
| |
| TokenServiceProvider::TokenServiceProvider( |
| const scoped_refptr<base::SingleThreadTaskRunner>& task_runner, |
| OAuth2TokenService* token_service) |
| : task_runner_(task_runner), token_service_(token_service) {} |
| |
| TokenServiceProvider::~TokenServiceProvider() {} |
| |
| scoped_refptr<base::SingleThreadTaskRunner> |
| TokenServiceProvider::GetTokenServiceTaskRunner() { |
| return task_runner_; |
| } |
| |
| OAuth2TokenService* TokenServiceProvider::GetTokenService() { |
| return token_service_; |
| } |
| |
| std::unique_ptr<syncer::AttachmentService> |
| ProfileSyncComponentsFactoryImpl::CreateAttachmentService( |
| std::unique_ptr<syncer::AttachmentStoreForSync> attachment_store, |
| const syncer::UserShare& user_share, |
| const std::string& store_birthday, |
| syncer::ModelType model_type, |
| syncer::AttachmentService::Delegate* delegate) { |
| std::unique_ptr<syncer::AttachmentUploader> attachment_uploader; |
| std::unique_ptr<syncer::AttachmentDownloader> attachment_downloader; |
| // Only construct an AttachmentUploader and AttachmentDownload if we have sync |
| // credentials. We may not have sync credentials because there may not be a |
| // signed in sync user. |
| if (!user_share.sync_credentials.account_id.empty() && |
| !user_share.sync_credentials.scope_set.empty()) { |
| scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider> |
| token_service_provider( |
| new TokenServiceProvider(ui_thread_, token_service_)); |
| // TODO(maniscalco): Use shared (one per profile) thread-safe instances of |
| // AttachmentUploader and AttachmentDownloader instead of creating a new one |
| // per AttachmentService (bug 369536). |
| attachment_uploader = syncer::AttachmentUploader::Create( |
| sync_service_url_, url_request_context_getter_, |
| user_share.sync_credentials.account_id, |
| user_share.sync_credentials.scope_set, token_service_provider, |
| store_birthday, model_type); |
| |
| token_service_provider = |
| new TokenServiceProvider(ui_thread_, token_service_); |
| attachment_downloader = syncer::AttachmentDownloader::Create( |
| sync_service_url_, url_request_context_getter_, |
| user_share.sync_credentials.account_id, |
| user_share.sync_credentials.scope_set, token_service_provider, |
| store_birthday, model_type); |
| } |
| |
| // It is important that the initial backoff delay is relatively large. For |
| // whatever reason, the server may fail all requests for a short period of |
| // time. When this happens we don't want to overwhelm the server with |
| // requests so we use a large initial backoff. |
| const base::TimeDelta initial_backoff_delay = |
| base::TimeDelta::FromMinutes(30); |
| const base::TimeDelta max_backoff_delay = base::TimeDelta::FromHours(4); |
| return syncer::AttachmentService::Create( |
| std::move(attachment_store), std::move(attachment_uploader), |
| std::move(attachment_downloader), delegate, initial_backoff_delay, |
| max_backoff_delay); |
| } |
| |
| syncer::SyncApiComponentFactory::SyncComponents |
| ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents( |
| syncer::SyncService* sync_service, |
| std::unique_ptr<syncer::DataTypeErrorHandler> error_handler) { |
| BookmarkModel* bookmark_model = |
| sync_service->GetSyncClient()->GetBookmarkModel(); |
| syncer::UserShare* user_share = sync_service->GetUserShare(); |
| // TODO(akalin): We may want to propagate this switch up eventually. |
| #if defined(OS_ANDROID) || defined(OS_IOS) |
| const bool kExpectMobileBookmarksFolder = true; |
| #else |
| const bool kExpectMobileBookmarksFolder = false; |
| #endif |
| BookmarkModelAssociator* model_associator = new BookmarkModelAssociator( |
| bookmark_model, sync_service->GetSyncClient(), user_share, |
| error_handler->Copy(), kExpectMobileBookmarksFolder); |
| BookmarkChangeProcessor* change_processor = |
| new BookmarkChangeProcessor(sync_service->GetSyncClient(), |
| model_associator, std::move(error_handler)); |
| return SyncComponents(model_associator, change_processor); |
| } |
| |
| // static |
| void ProfileSyncComponentsFactoryImpl::OverridePrefsForUssTest(bool use_uss) { |
| override_prefs_controller_to_uss_for_test_ = use_uss; |
| } |
| |
| bool ProfileSyncComponentsFactoryImpl:: |
| override_prefs_controller_to_uss_for_test_ = false; |
| |
| } // namespace browser_sync |
