#include "chrome/browser/dom_distiller/dom_distiller_service_factory.h"
#include "chrome/browser/history/history_service.h"
#include "chrome/browser/history/history_service_factory.h"
+#include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
+#include "chrome/browser/notifications/sync_notifier/chrome_notifier_service_factory.h"
#include "chrome/browser/password_manager/password_store_factory.h"
#include "chrome/browser/pref_service_flags_storage.h"
#include "chrome/browser/prefs/pref_model_associator.h"
#include "chrome/browser/prefs/pref_service_syncable.h"
#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/search_engines/template_url_service.h"
#include "chrome/browser/search_engines/template_url_service_factory.h"
#include "chrome/browser/signin/signin_manager_factory.h"
#include "chrome/browser/sync/glue/autofill_data_type_controller.h"
#include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
#include "chrome/browser/sync/glue/bookmark_model_associator.h"
#include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
-#include "chrome/browser/sync/glue/data_type_manager_impl.h"
+#include "chrome/browser/sync/glue/extension_backed_data_type_controller.h"
#include "chrome/browser/sync/glue/extension_data_type_controller.h"
#include "chrome/browser/sync/glue/extension_setting_data_type_controller.h"
+#include "chrome/browser/sync/glue/history_delete_directives_data_type_controller.h"
+#include "chrome/browser/sync/glue/local_device_info_provider_impl.h"
#include "chrome/browser/sync/glue/password_data_type_controller.h"
#include "chrome/browser/sync/glue/search_engine_data_type_controller.h"
-#include "chrome/browser/sync/glue/shared_change_processor.h"
#include "chrome/browser/sync/glue/sync_backend_host.h"
#include "chrome/browser/sync/glue/sync_backend_host_impl.h"
#include "chrome/browser/sync/glue/theme_data_type_controller.h"
#include "chrome/browser/sync/glue/typed_url_change_processor.h"
#include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
#include "chrome/browser/sync/glue/typed_url_model_associator.h"
-#include "chrome/browser/sync/glue/ui_data_type_controller.h"
#include "chrome/browser/sync/profile_sync_components_factory_impl.h"
#include "chrome/browser/sync/profile_sync_service.h"
#include "chrome/browser/sync/profile_sync_service_factory.h"
#include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
#include "components/dom_distiller/core/dom_distiller_service.h"
#include "components/password_manager/core/browser/password_store.h"
+#include "components/search_engines/template_url_service.h"
#include "components/signin/core/browser/signin_manager.h"
+#include "components/sync_driver/data_type_manager_impl.h"
#include "components/sync_driver/data_type_manager_observer.h"
+#include "components/sync_driver/device_info_data_type_controller.h"
#include "components/sync_driver/generic_change_processor.h"
#include "components/sync_driver/proxy_data_type_controller.h"
+#include "components/sync_driver/shared_change_processor.h"
+#include "components/sync_driver/ui_data_type_controller.h"
#include "content/public/browser/browser_thread.h"
-#include "extensions/browser/extension_system.h"
-#include "sync/api/attachments/attachment_service.h"
-#include "sync/api/attachments/fake_attachment_service.h"
+#include "google_apis/gaia/oauth2_token_service_request.h"
+#include "net/url_request/url_request_context_getter.h"
#include "sync/api/attachments/fake_attachment_store.h"
#include "sync/api/syncable_service.h"
-
-#if defined(ENABLE_EXTENSIONS)
-#include "chrome/browser/extensions/api/storage/settings_sync_util.h"
-#include "chrome/browser/extensions/extension_sync_service.h"
-#endif
+#include "sync/internal_api/public/attachments/attachment_downloader.h"
+#include "sync/internal_api/public/attachments/attachment_service.h"
+#include "sync/internal_api/public/attachments/attachment_service_impl.h"
+#include "sync/internal_api/public/attachments/attachment_uploader_impl.h"
#if defined(ENABLE_APP_LIST)
#include "chrome/browser/ui/app_list/app_list_syncable_service.h"
#include "ui/app_list/app_list_switches.h"
#endif
-#if defined(ENABLE_MANAGED_USERS)
-#include "chrome/browser/managed_mode/managed_user_settings_service.h"
-#include "chrome/browser/managed_mode/managed_user_settings_service_factory.h"
-#include "chrome/browser/managed_mode/managed_user_shared_settings_service.h"
-#include "chrome/browser/managed_mode/managed_user_shared_settings_service_factory.h"
-#include "chrome/browser/managed_mode/managed_user_sync_service.h"
-#include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/api/storage/settings_sync_util.h"
+#include "chrome/browser/extensions/api/synced_notifications_private/synced_notifications_shim.h"
+#include "chrome/browser/extensions/extension_sync_service.h"
#endif
-#if !defined(OS_ANDROID)
-#include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
-#include "chrome/browser/notifications/sync_notifier/chrome_notifier_service_factory.h"
-#include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service.h"
-#include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service_factory.h"
+#if defined(ENABLE_MANAGED_USERS)
+#include "chrome/browser/supervised_user/supervised_user_settings_service.h"
+#include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
+#include "chrome/browser/supervised_user/supervised_user_shared_settings_service.h"
+#include "chrome/browser/supervised_user/supervised_user_shared_settings_service_factory.h"
+#include "chrome/browser/supervised_user/supervised_user_sync_data_type_controller.h"
+#include "chrome/browser/supervised_user/supervised_user_sync_service.h"
+#include "chrome/browser/supervised_user/supervised_user_sync_service_factory.h"
#endif
#if defined(ENABLE_SPELLCHECK)
using browser_sync::BookmarkDataTypeController;
using browser_sync::BookmarkModelAssociator;
using browser_sync::ChromeReportUnrecoverableError;
-using browser_sync::DataTypeController;
-using browser_sync::DataTypeErrorHandler;
-using browser_sync::DataTypeManager;
-using browser_sync::DataTypeManagerImpl;
-using browser_sync::DataTypeManagerObserver;
+using browser_sync::ExtensionBackedDataTypeController;
using browser_sync::ExtensionDataTypeController;
using browser_sync::ExtensionSettingDataTypeController;
+using browser_sync::HistoryDeleteDirectivesDataTypeController;
using browser_sync::PasswordDataTypeController;
-using browser_sync::ProxyDataTypeController;
using browser_sync::SearchEngineDataTypeController;
using browser_sync::SessionDataTypeController;
-using browser_sync::SharedChangeProcessor;
using browser_sync::SyncBackendHost;
using browser_sync::ThemeDataTypeController;
using browser_sync::TypedUrlChangeProcessor;
using browser_sync::TypedUrlDataTypeController;
using browser_sync::TypedUrlModelAssociator;
-using browser_sync::UIDataTypeController;
using content::BrowserThread;
+using sync_driver::DataTypeController;
+using sync_driver::DataTypeErrorHandler;
+using sync_driver::DataTypeManager;
+using sync_driver::DataTypeManagerImpl;
+using sync_driver::DataTypeManagerObserver;
+using sync_driver::DeviceInfoDataTypeController;
+using sync_driver::ProxyDataTypeController;
+using sync_driver::SharedChangeProcessor;
+using sync_driver::UIDataTypeController;
namespace {
syncer::ModelTypeSet GetDisabledTypesFromCommandLine(
- CommandLine* command_line) {
+ const CommandLine& command_line) {
syncer::ModelTypeSet disabled_types;
std::string disabled_types_str =
- command_line->GetSwitchValueASCII(switches::kDisableSyncTypes);
+ command_line.GetSwitchValueASCII(switches::kDisableSyncTypes);
disabled_types = syncer::ModelTypeSetFromString(disabled_types_str);
return disabled_types;
}
+syncer::ModelTypeSet GetEnabledTypesFromCommandLine(
+ const CommandLine& command_line) {
+ syncer::ModelTypeSet enabled_types;
+ if (command_line.HasSwitch(switches::kEnableSyncSyncedNotifications)) {
+ enabled_types.Put(syncer::SYNCED_NOTIFICATIONS);
+ }
+ return enabled_types;
+}
+
} // namespace
ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
- Profile* profile, CommandLine* command_line)
+ Profile* profile,
+ CommandLine* command_line,
+ const GURL& sync_service_url,
+ OAuth2TokenService* token_service,
+ net::URLRequestContextGetter* url_request_context_getter)
: profile_(profile),
command_line_(command_line),
- extension_system_(extensions::ExtensionSystem::Get(profile)),
- web_data_service_(
- WebDataServiceFactory::GetAutofillWebDataForProfile(
- profile_, Profile::EXPLICIT_ACCESS)) {
+ web_data_service_(WebDataServiceFactory::GetAutofillWebDataForProfile(
+ profile_, Profile::EXPLICIT_ACCESS)),
+ sync_service_url_(sync_service_url),
+ token_service_(token_service),
+ url_request_context_getter_(url_request_context_getter),
+ weak_factory_(this) {
+ DCHECK(token_service_);
+ DCHECK(url_request_context_getter_);
}
ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {
void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
ProfileSyncService* pss) {
syncer::ModelTypeSet disabled_types =
- GetDisabledTypesFromCommandLine(command_line_);
- // TODO(zea): pass an enabled_types set for types that are off by default.
- RegisterCommonDataTypes(disabled_types, pss);
+ GetDisabledTypesFromCommandLine(*command_line_);
+ syncer::ModelTypeSet enabled_types =
+ GetEnabledTypesFromCommandLine(*command_line_);
+ RegisterCommonDataTypes(disabled_types, enabled_types, pss);
#if !defined(OS_ANDROID)
- RegisterDesktopDataTypes(disabled_types, pss);
+ RegisterDesktopDataTypes(disabled_types, enabled_types, pss);
#endif
}
void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes(
syncer::ModelTypeSet disabled_types,
+ syncer::ModelTypeSet enabled_types,
ProfileSyncService* pss) {
+ // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes?
+ pss->RegisterDataTypeController(new DeviceInfoDataTypeController(
+ BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+ base::Bind(&ChromeReportUnrecoverableError),
+ this,
+ pss->GetLocalDeviceInfoProvider()));
+
// Autofill sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::AUTOFILL)) {
pss->RegisterDataTypeController(
- new AutofillDataTypeController(this, profile_, pss));
+ new AutofillDataTypeController(this, profile_));
}
// Autofill profile sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) {
pss->RegisterDataTypeController(
- new AutofillProfileDataTypeController(this, profile_, pss));
+ new AutofillProfileDataTypeController(this, profile_));
}
// Bookmark sync is enabled by default. Register unless explicitly
new BookmarkDataTypeController(this, profile_, pss));
}
+ const bool history_disabled =
+ profile_->GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled);
// TypedUrl sync is enabled by default. Register unless explicitly disabled,
// or if saving history is disabled.
- if (!profile_->GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled) &&
- !disabled_types.Has(syncer::TYPED_URLS)) {
+ if (!disabled_types.Has(syncer::TYPED_URLS) && !history_disabled) {
pss->RegisterDataTypeController(
new TypedUrlDataTypeController(this, profile_, pss));
}
// Delete directive sync is enabled by default. Register unless full history
// sync is disabled.
- if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)) {
+ if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
+ !history_disabled) {
pss->RegisterDataTypeController(
- new UIDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
- syncer::HISTORY_DELETE_DIRECTIVES,
- this,
- profile_,
- pss));
+ new HistoryDeleteDirectivesDataTypeController(this, pss));
}
// Session sync is enabled by default. Register unless explicitly disabled.
- if (!disabled_types.Has(syncer::PROXY_TABS)) {
- pss->RegisterDataTypeController(new ProxyDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- syncer::PROXY_TABS));
+ // This is also disabled if the browser history is disabled, because the
+ // tab sync data is added to the web history on the server.
+ if (!disabled_types.Has(syncer::PROXY_TABS) && !history_disabled) {
+ pss->RegisterDataTypeController(new ProxyDataTypeController(
+ BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+ syncer::PROXY_TABS));
pss->RegisterDataTypeController(
- new SessionDataTypeController(this, profile_, pss));
+ new SessionDataTypeController(this,
+ profile_,
+ pss->GetSyncedWindowDelegatesGetter(),
+ pss->GetLocalDeviceInfoProvider()));
}
// Favicon sync is enabled by default. Register unless explicitly disabled.
if (!disabled_types.Has(syncer::FAVICON_IMAGES) &&
- !disabled_types.Has(syncer::FAVICON_TRACKING)) {
+ !disabled_types.Has(syncer::FAVICON_TRACKING) &&
+ !history_disabled) {
+ // crbug/384552. We disable error uploading for this data types for now.
pss->RegisterDataTypeController(
new UIDataTypeController(
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
+ base::Closure(),
syncer::FAVICON_IMAGES,
- this,
- profile_,
- pss));
+ this));
pss->RegisterDataTypeController(
new UIDataTypeController(
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
+ base::Closure(),
syncer::FAVICON_TRACKING,
- this,
- profile_,
- pss));
+ this));
}
// Password sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::PASSWORDS)) {
pss->RegisterDataTypeController(
- new PasswordDataTypeController(this, profile_, pss));
+ new PasswordDataTypeController(this, profile_));
}
// Article sync is disabled by default. Register only if explicitly enabled.
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
base::Bind(&ChromeReportUnrecoverableError),
syncer::ARTICLES,
- this,
- profile_,
- pss));
+ this));
}
#if defined(ENABLE_MANAGED_USERS)
- if (profile_->IsManaged()) {
- pss->RegisterDataTypeController(
- new UIDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
- syncer::MANAGED_USER_SETTINGS,
- this,
- profile_,
- pss));
- } else {
- pss->RegisterDataTypeController(
- new UIDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
- syncer::MANAGED_USERS,
- this,
- profile_,
- pss));
- }
pss->RegisterDataTypeController(
- new UIDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
- syncer::MANAGED_USER_SHARED_SETTINGS,
- this,
- profile_,
- pss));
+ new SupervisedUserSyncDataTypeController(
+ syncer::SUPERVISED_USER_SETTINGS,
+ this,
+ profile_));
#endif
}
void ProfileSyncComponentsFactoryImpl::RegisterDesktopDataTypes(
syncer::ModelTypeSet disabled_types,
+ syncer::ModelTypeSet enabled_types,
ProfileSyncService* pss) {
// App sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::APPS)) {
pss->RegisterDataTypeController(
- new ExtensionDataTypeController(syncer::APPS, this, profile_, pss));
+ new ExtensionDataTypeController(syncer::APPS, this, profile_));
}
// Extension sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::EXTENSIONS)) {
pss->RegisterDataTypeController(
- new ExtensionDataTypeController(syncer::EXTENSIONS,
- this, profile_, pss));
+ new ExtensionDataTypeController(syncer::EXTENSIONS, this, profile_));
}
// Preference sync is enabled by default. Register unless explicitly
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
base::Bind(&ChromeReportUnrecoverableError),
syncer::PREFERENCES,
- this,
- profile_,
- pss));
-
+ this));
}
if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
base::Bind(&ChromeReportUnrecoverableError),
syncer::PRIORITY_PREFERENCES,
- this,
- profile_,
- pss));
+ this));
}
#if defined(ENABLE_THEMES)
// Theme sync is enabled by default. Register unless explicitly disabled.
if (!disabled_types.Has(syncer::THEMES)) {
pss->RegisterDataTypeController(
- new ThemeDataTypeController(this, profile_, pss));
+ new ThemeDataTypeController(this, profile_));
}
#endif
// disabled.
if (!disabled_types.Has(syncer::SEARCH_ENGINES)) {
pss->RegisterDataTypeController(
- new SearchEngineDataTypeController(this, profile_, pss));
+ new SearchEngineDataTypeController(this, profile_));
}
// Extension setting sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::EXTENSION_SETTINGS)) {
- pss->RegisterDataTypeController(
- new ExtensionSettingDataTypeController(
- syncer::EXTENSION_SETTINGS, this, profile_, pss));
+ pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
+ syncer::EXTENSION_SETTINGS, this, profile_));
}
// App setting sync is enabled by default. Register unless explicitly
// disabled.
if (!disabled_types.Has(syncer::APP_SETTINGS)) {
- pss->RegisterDataTypeController(
- new ExtensionSettingDataTypeController(
- syncer::APP_SETTINGS, this, profile_, pss));
+ pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
+ syncer::APP_SETTINGS, this, profile_));
}
#if defined(ENABLE_APP_LIST)
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
base::Bind(&ChromeReportUnrecoverableError),
syncer::APP_LIST,
- this,
- profile_,
- pss));
+ this));
}
#endif
- // Synced Notifications are enabled by default.
- if (!disabled_types.Has(syncer::SYNCED_NOTIFICATIONS)) {
+ // Synced Notifications are disabled by default.
+#if defined(ENABLE_EXTENSIONS) && defined(ENABLE_NOTIFICATIONS)
+ if (enabled_types.Has(syncer::SYNCED_NOTIFICATIONS)) {
pss->RegisterDataTypeController(
- new UIDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
+ new ExtensionBackedDataTypeController(
syncer::SYNCED_NOTIFICATIONS,
+ "", // TODO(dewittj): pass the extension hash here.
this,
- profile_,
- pss));
-
- // Synced Notification App Infos are enabled by default on Dev and Canary
- // only.
- // TODO(petewil): Enable on stable when the feature is ready.
- chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
- if (channel == chrome::VersionInfo::CHANNEL_UNKNOWN ||
- channel == chrome::VersionInfo::CHANNEL_DEV ||
- channel == chrome::VersionInfo::CHANNEL_CANARY) {
- pss->RegisterDataTypeController(new UIDataTypeController(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
- base::Bind(&ChromeReportUnrecoverableError),
- syncer::SYNCED_NOTIFICATION_APP_INFO,
- this,
- profile_,
- pss));
- }
+ profile_));
+
+ pss->RegisterDataTypeController(
+ new ExtensionBackedDataTypeController(
+ syncer::SYNCED_NOTIFICATION_APP_INFO,
+ "", // TODO(dewittj): pass the extension hash here.
+ this,
+ profile_));
}
+#endif
#if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_CHROMEOS)
// Dictionary sync is enabled by default.
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
base::Bind(&ChromeReportUnrecoverableError),
syncer::DICTIONARY,
- this,
- profile_,
- pss));
+ this));
}
#endif
+
+#if defined(ENABLE_MANAGED_USERS)
+ pss->RegisterDataTypeController(
+ new SupervisedUserSyncDataTypeController(
+ syncer::SUPERVISED_USERS,
+ this,
+ profile_));
+ pss->RegisterDataTypeController(
+ new SupervisedUserSyncDataTypeController(
+ syncer::SUPERVISED_USER_SHARED_SETTINGS,
+ this,
+ profile_));
+#endif
}
DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
debug_info_listener,
const DataTypeController::TypeMap* controllers,
- const browser_sync::DataTypeEncryptionHandler* encryption_handler,
+ const sync_driver::DataTypeEncryptionHandler* encryption_handler,
SyncBackendHost* backend,
- DataTypeManagerObserver* observer,
- browser_sync::FailedDataTypesHandler* failed_data_types_handler) {
- return new DataTypeManagerImpl(debug_info_listener,
+ DataTypeManagerObserver* observer) {
+ return new DataTypeManagerImpl(base::Bind(ChromeReportUnrecoverableError),
+ debug_info_listener,
controllers,
encryption_handler,
backend,
- observer,
- failed_data_types_handler);
+ observer);
}
browser_sync::SyncBackendHost*
ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
const std::string& name,
Profile* profile,
- const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs) {
- return new browser_sync::SyncBackendHostImpl(name, profile, sync_prefs);
+ invalidation::InvalidationService* invalidator,
+ const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
+ const base::FilePath& sync_folder) {
+ return new browser_sync::SyncBackendHostImpl(name, profile, invalidator,
+ sync_prefs, sync_folder);
+}
+
+scoped_ptr<sync_driver::LocalDeviceInfoProvider>
+ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() {
+ return scoped_ptr<sync_driver::LocalDeviceInfoProvider>(
+ new browser_sync::LocalDeviceInfoProviderImpl());
}
base::WeakPtr<syncer::SyncableService> ProfileSyncComponentsFactoryImpl::
return base::WeakPtr<syncer::SyncableService>();
}
switch (type) {
+ case syncer::DEVICE_INFO:
+ return ProfileSyncServiceFactory::GetForProfile(profile_)
+ ->GetDeviceInfoSyncableService()
+ ->AsWeakPtr();
case syncer::PREFERENCES:
return PrefServiceSyncable::FromProfile(
profile_)->GetSyncableService(syncer::PREFERENCES)->AsWeakPtr();
profile_, Profile::EXPLICIT_ACCESS);
return history ? history->AsWeakPtr() : base::WeakPtr<HistoryService>();
}
-#if !defined(OS_ANDROID)
- case syncer::SYNCED_NOTIFICATIONS: {
- notifier::ChromeNotifierService* notifier_service =
- notifier::ChromeNotifierServiceFactory::GetForProfile(
- profile_, Profile::EXPLICIT_ACCESS);
- return notifier_service ? notifier_service->AsWeakPtr()
- : base::WeakPtr<syncer::SyncableService>();
- }
-
+#if defined(ENABLE_EXTENSIONS)
+ case syncer::SYNCED_NOTIFICATIONS:
case syncer::SYNCED_NOTIFICATION_APP_INFO: {
- notifier::SyncedNotificationAppInfoService* app_info =
- notifier::SyncedNotificationAppInfoServiceFactory::GetForProfile(
- profile_, Profile::EXPLICIT_ACCESS);
- return app_info ? app_info->AsWeakPtr()
- : base::WeakPtr<syncer::SyncableService>();
+ return notifier::ChromeNotifierServiceFactory::GetForProfile(
+ profile_, Profile::IMPLICIT_ACCESS)
+ ->GetSyncedNotificationsShim()
+ ->AsWeakPtr();
}
#endif
#if defined(ENABLE_SPELLCHECK)
: base::WeakPtr<syncer::SyncableService>();
}
#if defined(ENABLE_MANAGED_USERS)
- case syncer::MANAGED_USER_SETTINGS:
- return ManagedUserSettingsServiceFactory::GetForProfile(profile_)->
+ case syncer::SUPERVISED_USER_SETTINGS:
+ return SupervisedUserSettingsServiceFactory::GetForProfile(profile_)->
AsWeakPtr();
- case syncer::MANAGED_USERS:
- return ManagedUserSyncServiceFactory::GetForProfile(profile_)->
+ case syncer::SUPERVISED_USERS:
+ return SupervisedUserSyncServiceFactory::GetForProfile(profile_)->
AsWeakPtr();
- case syncer::MANAGED_USER_SHARED_SETTINGS:
- return ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(
+ case syncer::SUPERVISED_USER_SHARED_SETTINGS:
+ return SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
profile_)->AsWeakPtr();
#endif
case syncer::ARTICLES: {
}
case syncer::PASSWORDS: {
#if defined(PASSWORD_MANAGER_ENABLE_SYNC)
- password_manager::PasswordStore* password_store =
+ scoped_refptr<password_manager::PasswordStore> password_store =
PasswordStoreFactory::GetForProfile(profile_,
Profile::EXPLICIT_ACCESS);
- return password_store ? password_store->GetPasswordSyncableService()
- : base::WeakPtr<syncer::SyncableService>();
+ return password_store.get() ? password_store->GetPasswordSyncableService()
+ : base::WeakPtr<syncer::SyncableService>();
#else
return base::WeakPtr<syncer::SyncableService>();
#endif
}
}
-scoped_ptr<syncer::AttachmentStore>
- ProfileSyncComponentsFactoryImpl::CreateCustomAttachmentStoreForType(
- syncer::ModelType type) {
- scoped_ptr<syncer::AttachmentStore> store(
- new syncer::FakeAttachmentStore(
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
- return store.Pass();
+class TokenServiceProvider
+ : public OAuth2TokenServiceRequest::TokenServiceProvider {
+ public:
+ TokenServiceProvider(
+ const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+ OAuth2TokenService* token_service);
+
+ // OAuth2TokenServiceRequest::TokenServiceProvider implementation.
+ virtual scoped_refptr<base::SingleThreadTaskRunner>
+ GetTokenServiceTaskRunner() OVERRIDE;
+ virtual OAuth2TokenService* GetTokenService() OVERRIDE;
+
+ private:
+ virtual ~TokenServiceProvider();
+
+ 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_;
+}
+
+scoped_ptr<syncer::AttachmentService>
+ProfileSyncComponentsFactoryImpl::CreateAttachmentService(
+ const scoped_refptr<syncer::AttachmentStore>& attachment_store,
+ const syncer::UserShare& user_share,
+ syncer::AttachmentService::Delegate* delegate) {
+ scoped_ptr<syncer::AttachmentUploader> attachment_uploader;
+ scoped_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 (e.g. sync is running in "backup" mode).
+ if (!user_share.sync_credentials.email.empty() &&
+ !user_share.sync_credentials.scope_set.empty()) {
+ scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider>
+ token_service_provider(new TokenServiceProvider(
+ content::BrowserThread::GetMessageLoopProxyForThread(
+ content::BrowserThread::UI),
+ 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.reset(new syncer::AttachmentUploaderImpl(
+ sync_service_url_,
+ url_request_context_getter_,
+ user_share.sync_credentials.email,
+ user_share.sync_credentials.scope_set,
+ token_service_provider));
+
+ token_service_provider = new TokenServiceProvider(
+ content::BrowserThread::GetMessageLoopProxyForThread(
+ content::BrowserThread::UI),
+ token_service_);
+ attachment_downloader = syncer::AttachmentDownloader::Create(
+ sync_service_url_,
+ url_request_context_getter_,
+ user_share.sync_credentials.email,
+ user_share.sync_credentials.scope_set,
+ token_service_provider);
+ }
+
+ // 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);
+ scoped_ptr<syncer::AttachmentService> attachment_service(
+ new syncer::AttachmentServiceImpl(attachment_store,
+ attachment_uploader.Pass(),
+ attachment_downloader.Pass(),
+ delegate,
+ initial_backoff_delay,
+ max_backoff_delay));
+ return attachment_service.Pass();
}
ProfileSyncComponentsFactory::SyncComponents
ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
ProfileSyncService* profile_sync_service,
- DataTypeErrorHandler* error_handler) {
+ sync_driver::DataTypeErrorHandler* error_handler) {
BookmarkModel* bookmark_model =
BookmarkModelFactory::GetForProfile(profile_sync_service->profile());
syncer::UserShare* user_share = profile_sync_service->GetUserShare();
ProfileSyncComponentsFactoryImpl::CreateTypedUrlSyncComponents(
ProfileSyncService* profile_sync_service,
history::HistoryBackend* history_backend,
- browser_sync::DataTypeErrorHandler* error_handler) {
+ sync_driver::DataTypeErrorHandler* error_handler) {
TypedUrlModelAssociator* model_associator =
new TypedUrlModelAssociator(profile_sync_service,
history_backend,
projects / platform / framework / web / crosswalk.git / blobdiff