chrome/browser/sync/profile_sync_components_factory_impl.cc

   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 "base/command_line.h"
   6 #include "build/build_config.h"
   7 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
   8 #include "chrome/browser/bookmarks/enhanced_bookmarks_features.h"
   9 #include "chrome/browser/dom_distiller/dom_distiller_service_factory.h"
  10 #include "chrome/browser/history/history_service.h"
  11 #include "chrome/browser/history/history_service_factory.h"
  12 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
  13 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service_factory.h"
  14 #include "chrome/browser/password_manager/password_store_factory.h"
  15 #include "chrome/browser/pref_service_flags_storage.h"
  16 #include "chrome/browser/prefs/pref_model_associator.h"
  17 #include "chrome/browser/prefs/pref_service_syncable.h"
  18 #include "chrome/browser/profiles/profile.h"
  19 #include "chrome/browser/search_engines/template_url_service_factory.h"
  20 #include "chrome/browser/signin/signin_manager_factory.h"
  21 #include "chrome/browser/sync/glue/autofill_data_type_controller.h"
  22 #include "chrome/browser/sync/glue/autofill_profile_data_type_controller.h"
  23 #include "chrome/browser/sync/glue/bookmark_change_processor.h"
  24 #include "chrome/browser/sync/glue/bookmark_data_type_controller.h"
  25 #include "chrome/browser/sync/glue/bookmark_model_associator.h"
  26 #include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
  27 #include "chrome/browser/sync/glue/extension_backed_data_type_controller.h"
  28 #include "chrome/browser/sync/glue/extension_data_type_controller.h"
  29 #include "chrome/browser/sync/glue/extension_setting_data_type_controller.h"
  30 #include "chrome/browser/sync/glue/history_delete_directives_data_type_controller.h"
  31 #include "chrome/browser/sync/glue/local_device_info_provider_impl.h"
  32 #include "chrome/browser/sync/glue/password_data_type_controller.h"
  33 #include "chrome/browser/sync/glue/search_engine_data_type_controller.h"
  34 #include "chrome/browser/sync/glue/sync_backend_host.h"
  35 #include "chrome/browser/sync/glue/sync_backend_host_impl.h"
  36 #include "chrome/browser/sync/glue/theme_data_type_controller.h"
  37 #include "chrome/browser/sync/glue/typed_url_change_processor.h"
  38 #include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
  39 #include "chrome/browser/sync/glue/typed_url_model_associator.h"
  40 #include "chrome/browser/sync/profile_sync_components_factory_impl.h"
  41 #include "chrome/browser/sync/profile_sync_service.h"
  42 #include "chrome/browser/sync/profile_sync_service_factory.h"
  43 #include "chrome/browser/sync/sessions/session_data_type_controller.h"
  44 #include "chrome/browser/themes/theme_service.h"
  45 #include "chrome/browser/themes/theme_service_factory.h"
  46 #include "chrome/browser/themes/theme_syncable_service.h"
  47 #include "chrome/browser/webdata/autocomplete_syncable_service.h"
  48 #include "chrome/browser/webdata/web_data_service_factory.h"
  49 #include "chrome/common/chrome_switches.h"
  50 #include "chrome/common/chrome_version_info.h"
  51 #include "chrome/common/pref_names.h"
  52 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
  53 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
  54 #include "components/dom_distiller/core/dom_distiller_service.h"
  55 #include "components/password_manager/core/browser/password_store.h"
  56 #include "components/search_engines/template_url_service.h"
  57 #include "components/signin/core/browser/signin_manager.h"
  58 #include "components/sync_driver/data_type_manager_impl.h"
  59 #include "components/sync_driver/data_type_manager_observer.h"
  60 #include "components/sync_driver/device_info_data_type_controller.h"
  61 #include "components/sync_driver/generic_change_processor.h"
  62 #include "components/sync_driver/proxy_data_type_controller.h"
  63 #include "components/sync_driver/shared_change_processor.h"
  64 #include "components/sync_driver/ui_data_type_controller.h"
  65 #include "content/public/browser/browser_thread.h"
  66 #include "google_apis/gaia/oauth2_token_service_request.h"
  67 #include "net/url_request/url_request_context_getter.h"
  68 #include "sync/api/syncable_service.h"
  69 #include "sync/internal_api/public/attachments/attachment_downloader.h"
  70 #include "sync/internal_api/public/attachments/attachment_service.h"
  71 #include "sync/internal_api/public/attachments/attachment_service_impl.h"
  72 #include "sync/internal_api/public/attachments/attachment_uploader_impl.h"
  73
  74 #if defined(ENABLE_APP_LIST)
  75 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
  76 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
  77 #include "ui/app_list/app_list_switches.h"
  78 #endif
  79
  80 #if defined(ENABLE_EXTENSIONS)
  81 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
  82 #include "chrome/browser/extensions/api/synced_notifications_private/synced_notifications_shim.h"
  83 #include "chrome/browser/extensions/extension_sync_service.h"
  84 #endif
  85
  86 #if defined(ENABLE_MANAGED_USERS)
  87 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
  88 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
  89 #include "chrome/browser/supervised_user/supervised_user_shared_settings_service.h"
  90 #include "chrome/browser/supervised_user/supervised_user_shared_settings_service_factory.h"
  91 #include "chrome/browser/supervised_user/supervised_user_sync_data_type_controller.h"
  92 #include "chrome/browser/supervised_user/supervised_user_sync_service.h"
  93 #include "chrome/browser/supervised_user/supervised_user_sync_service_factory.h"
  94 #endif
  95
  96 #if defined(ENABLE_SPELLCHECK)
  97 #include "chrome/browser/spellchecker/spellcheck_factory.h"
  98 #include "chrome/browser/spellchecker/spellcheck_service.h"
  99 #endif
 100
 101 using browser_sync::AutofillDataTypeController;
 102 using browser_sync::AutofillProfileDataTypeController;
 103 using browser_sync::BookmarkChangeProcessor;
 104 using browser_sync::BookmarkDataTypeController;
 105 using browser_sync::BookmarkModelAssociator;
 106 using browser_sync::ChromeReportUnrecoverableError;
 107 using browser_sync::ExtensionBackedDataTypeController;
 108 using browser_sync::ExtensionDataTypeController;
 109 using browser_sync::ExtensionSettingDataTypeController;
 110 using browser_sync::HistoryDeleteDirectivesDataTypeController;
 111 using browser_sync::PasswordDataTypeController;
 112 using browser_sync::SearchEngineDataTypeController;
 113 using browser_sync::SessionDataTypeController;
 114 using browser_sync::SyncBackendHost;
 115 using browser_sync::ThemeDataTypeController;
 116 using browser_sync::TypedUrlChangeProcessor;
 117 using browser_sync::TypedUrlDataTypeController;
 118 using browser_sync::TypedUrlModelAssociator;
 119 using content::BrowserThread;
 120 using sync_driver::DataTypeController;
 121 using sync_driver::DataTypeErrorHandler;
 122 using sync_driver::DataTypeManager;
 123 using sync_driver::DataTypeManagerImpl;
 124 using sync_driver::DataTypeManagerObserver;
 125 using sync_driver::DeviceInfoDataTypeController;
 126 using sync_driver::ProxyDataTypeController;
 127 using sync_driver::SharedChangeProcessor;
 128 using sync_driver::UIDataTypeController;
 129
 130 namespace {
 131
 132 syncer::ModelTypeSet GetDisabledTypesFromCommandLine(
 133     const CommandLine& command_line) {
 134   syncer::ModelTypeSet disabled_types;
 135   std::string disabled_types_str =
 136       command_line.GetSwitchValueASCII(switches::kDisableSyncTypes);
 137   disabled_types = syncer::ModelTypeSetFromString(disabled_types_str);
 138   return disabled_types;
 139 }
 140
 141 syncer::ModelTypeSet GetEnabledTypesFromCommandLine(
 142     const CommandLine& command_line) {
 143   syncer::ModelTypeSet enabled_types;
 144   if (command_line.HasSwitch(switches::kEnableSyncSyncedNotifications)) {
 145     enabled_types.Put(syncer::SYNCED_NOTIFICATIONS);
 146   }
 147   return enabled_types;
 148 }
 149
 150 }  // namespace
 151
 152 ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
 153     Profile* profile,
 154     CommandLine* command_line,
 155     const GURL& sync_service_url,
 156     OAuth2TokenService* token_service,
 157     net::URLRequestContextGetter* url_request_context_getter)
 158     : profile_(profile),
 159       command_line_(command_line),
 160       web_data_service_(WebDataServiceFactory::GetAutofillWebDataForProfile(
 161           profile_, Profile::EXPLICIT_ACCESS)),
 162       sync_service_url_(sync_service_url),
 163       token_service_(token_service),
 164       url_request_context_getter_(url_request_context_getter),
 165       weak_factory_(this) {
 166   DCHECK(token_service_);
 167   DCHECK(url_request_context_getter_);
 168 }
 169
 170 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {
 171 }
 172
 173 void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
 174     ProfileSyncService* pss) {
 175   syncer::ModelTypeSet disabled_types =
 176       GetDisabledTypesFromCommandLine(*command_line_);
 177   syncer::ModelTypeSet enabled_types =
 178       GetEnabledTypesFromCommandLine(*command_line_);
 179   RegisterCommonDataTypes(disabled_types, enabled_types, pss);
 180 #if !defined(OS_ANDROID)
 181   RegisterDesktopDataTypes(disabled_types, enabled_types, pss);
 182 #endif
 183 }
 184
 185 void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes(
 186     syncer::ModelTypeSet disabled_types,
 187     syncer::ModelTypeSet enabled_types,
 188     ProfileSyncService* pss) {
 189   // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes?
 190   pss->RegisterDataTypeController(new DeviceInfoDataTypeController(
 191       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 192       base::Bind(&ChromeReportUnrecoverableError),
 193       this,
 194       pss->GetLocalDeviceInfoProvider()));
 195
 196   // Autofill sync is enabled by default.  Register unless explicitly
 197   // disabled.
 198   if (!disabled_types.Has(syncer::AUTOFILL)) {
 199     pss->RegisterDataTypeController(
 200         new AutofillDataTypeController(this, profile_));
 201   }
 202
 203   // Autofill profile sync is enabled by default.  Register unless explicitly
 204   // disabled.
 205   if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) {
 206     pss->RegisterDataTypeController(
 207         new AutofillProfileDataTypeController(this, profile_));
 208   }
 209
 210   // Bookmark sync is enabled by default.  Register unless explicitly
 211   // disabled.
 212   if (!disabled_types.Has(syncer::BOOKMARKS)) {
 213     pss->RegisterDataTypeController(
 214         new BookmarkDataTypeController(this, profile_, pss));
 215   }
 216
 217   const bool history_disabled =
 218       profile_->GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled);
 219   // TypedUrl sync is enabled by default.  Register unless explicitly disabled,
 220   // or if saving history is disabled.
 221   if (!disabled_types.Has(syncer::TYPED_URLS) && !history_disabled) {
 222     pss->RegisterDataTypeController(
 223         new TypedUrlDataTypeController(this, profile_, pss));
 224   }
 225
 226   // Delete directive sync is enabled by default.  Register unless full history
 227   // sync is disabled.
 228   if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
 229       !history_disabled) {
 230     pss->RegisterDataTypeController(
 231         new HistoryDeleteDirectivesDataTypeController(this, pss));
 232   }
 233
 234   // Session sync is enabled by default.  Register unless explicitly disabled.
 235   // This is also disabled if the browser history is disabled, because the
 236   // tab sync data is added to the web history on the server.
 237   if (!disabled_types.Has(syncer::PROXY_TABS) && !history_disabled) {
 238     pss->RegisterDataTypeController(new ProxyDataTypeController(
 239         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 240         syncer::PROXY_TABS));
 241     pss->RegisterDataTypeController(
 242         new SessionDataTypeController(this,
 243                                       profile_,
 244                                       pss->GetSyncedWindowDelegatesGetter(),
 245                                       pss->GetLocalDeviceInfoProvider()));
 246   }
 247
 248   // Favicon sync is enabled by default. Register unless explicitly disabled.
 249   if (!disabled_types.Has(syncer::FAVICON_IMAGES) &&
 250       !disabled_types.Has(syncer::FAVICON_TRACKING) &&
 251       !history_disabled) {
 252     // crbug/384552. We disable error uploading for this data types for now.
 253     pss->RegisterDataTypeController(
 254         new UIDataTypeController(
 255             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 256             base::Closure(),
 257             syncer::FAVICON_IMAGES,
 258             this));
 259     pss->RegisterDataTypeController(
 260         new UIDataTypeController(
 261             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 262             base::Closure(),
 263             syncer::FAVICON_TRACKING,
 264             this));
 265   }
 266
 267   // Password sync is enabled by default.  Register unless explicitly
 268   // disabled.
 269   if (!disabled_types.Has(syncer::PASSWORDS)) {
 270     pss->RegisterDataTypeController(
 271         new PasswordDataTypeController(this, profile_));
 272   }
 273
 274   // Article sync is disabled by default.  Register only if explicitly enabled.
 275   if (IsEnableSyncArticlesSet()) {
 276     pss->RegisterDataTypeController(
 277         new UIDataTypeController(
 278             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 279             base::Bind(&ChromeReportUnrecoverableError),
 280             syncer::ARTICLES,
 281             this));
 282   }
 283
 284 #if defined(ENABLE_MANAGED_USERS)
 285   pss->RegisterDataTypeController(
 286       new SupervisedUserSyncDataTypeController(
 287           syncer::SUPERVISED_USER_SETTINGS,
 288           this,
 289           profile_));
 290 #endif
 291
 292   // Enhanced bookmark sync is disabled by default.  Register only if explicitly
 293   // enabled.
 294   if (IsEnhancedBookmarksSyncEnabled()) {
 295     pss->RegisterDataTypeController(new UIDataTypeController(
 296         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 297         base::Bind(&ChromeReportUnrecoverableError),
 298         syncer::ENHANCED_BOOKMARKS, this));
 299   }
 300 }
 301
 302 void ProfileSyncComponentsFactoryImpl::RegisterDesktopDataTypes(
 303     syncer::ModelTypeSet disabled_types,
 304     syncer::ModelTypeSet enabled_types,
 305     ProfileSyncService* pss) {
 306   // App sync is enabled by default.  Register unless explicitly
 307   // disabled.
 308   if (!disabled_types.Has(syncer::APPS)) {
 309     pss->RegisterDataTypeController(
 310         new ExtensionDataTypeController(syncer::APPS, this, profile_));
 311   }
 312
 313   // Extension sync is enabled by default.  Register unless explicitly
 314   // disabled.
 315   if (!disabled_types.Has(syncer::EXTENSIONS)) {
 316     pss->RegisterDataTypeController(
 317         new ExtensionDataTypeController(syncer::EXTENSIONS, this, profile_));
 318   }
 319
 320   // Preference sync is enabled by default.  Register unless explicitly
 321   // disabled.
 322   if (!disabled_types.Has(syncer::PREFERENCES)) {
 323     pss->RegisterDataTypeController(
 324         new UIDataTypeController(
 325             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 326             base::Bind(&ChromeReportUnrecoverableError),
 327             syncer::PREFERENCES,
 328             this));
 329   }
 330
 331   if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
 332     pss->RegisterDataTypeController(
 333         new UIDataTypeController(
 334             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 335             base::Bind(&ChromeReportUnrecoverableError),
 336             syncer::PRIORITY_PREFERENCES,
 337             this));
 338   }
 339
 340 #if defined(ENABLE_THEMES)
 341   // Theme sync is enabled by default.  Register unless explicitly disabled.
 342   if (!disabled_types.Has(syncer::THEMES)) {
 343     pss->RegisterDataTypeController(
 344         new ThemeDataTypeController(this, profile_));
 345   }
 346 #endif
 347
 348   // Search Engine sync is enabled by default.  Register unless explicitly
 349   // disabled.
 350   if (!disabled_types.Has(syncer::SEARCH_ENGINES)) {
 351     pss->RegisterDataTypeController(
 352         new SearchEngineDataTypeController(this, profile_));
 353   }
 354
 355   // Extension setting sync is enabled by default.  Register unless explicitly
 356   // disabled.
 357   if (!disabled_types.Has(syncer::EXTENSION_SETTINGS)) {
 358     pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
 359         syncer::EXTENSION_SETTINGS, this, profile_));
 360   }
 361
 362   // App setting sync is enabled by default.  Register unless explicitly
 363   // disabled.
 364   if (!disabled_types.Has(syncer::APP_SETTINGS)) {
 365     pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
 366         syncer::APP_SETTINGS, this, profile_));
 367   }
 368
 369 #if defined(ENABLE_APP_LIST)
 370   if (app_list::switches::IsAppListSyncEnabled()) {
 371     pss->RegisterDataTypeController(
 372         new UIDataTypeController(
 373             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 374             base::Bind(&ChromeReportUnrecoverableError),
 375             syncer::APP_LIST,
 376             this));
 377   }
 378 #endif
 379
 380   // Synced Notifications are disabled by default.
 381 #if defined(ENABLE_EXTENSIONS) && defined(ENABLE_NOTIFICATIONS)
 382   if (enabled_types.Has(syncer::SYNCED_NOTIFICATIONS)) {
 383     pss->RegisterDataTypeController(
 384         new ExtensionBackedDataTypeController(
 385               syncer::SYNCED_NOTIFICATIONS,
 386               "",  // TODO(dewittj): pass the extension hash here.
 387               this,
 388               profile_));
 389
 390     pss->RegisterDataTypeController(
 391         new ExtensionBackedDataTypeController(
 392               syncer::SYNCED_NOTIFICATION_APP_INFO,
 393               "",  // TODO(dewittj): pass the extension hash here.
 394               this,
 395               profile_));
 396   }
 397 #endif
 398
 399 #if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_CHROMEOS)
 400   // Dictionary sync is enabled by default.
 401   if (!disabled_types.Has(syncer::DICTIONARY)) {
 402     pss->RegisterDataTypeController(
 403         new UIDataTypeController(
 404             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 405             base::Bind(&ChromeReportUnrecoverableError),
 406             syncer::DICTIONARY,
 407             this));
 408   }
 409 #endif
 410
 411 #if defined(ENABLE_MANAGED_USERS)
 412   pss->RegisterDataTypeController(
 413       new SupervisedUserSyncDataTypeController(
 414           syncer::SUPERVISED_USERS,
 415           this,
 416           profile_));
 417   pss->RegisterDataTypeController(
 418       new SupervisedUserSyncDataTypeController(
 419           syncer::SUPERVISED_USER_SHARED_SETTINGS,
 420           this,
 421           profile_));
 422 #endif
 423 }
 424
 425 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
 426     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
 427         debug_info_listener,
 428     const DataTypeController::TypeMap* controllers,
 429     const sync_driver::DataTypeEncryptionHandler* encryption_handler,
 430     SyncBackendHost* backend,
 431     DataTypeManagerObserver* observer) {
 432   return new DataTypeManagerImpl(base::Bind(ChromeReportUnrecoverableError),
 433                                  debug_info_listener,
 434                                  controllers,
 435                                  encryption_handler,
 436                                  backend,
 437                                  observer);
 438 }
 439
 440 browser_sync::SyncBackendHost*
 441 ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
 442     const std::string& name,
 443     Profile* profile,
 444     invalidation::InvalidationService* invalidator,
 445     const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
 446     const base::FilePath& sync_folder) {
 447   return new browser_sync::SyncBackendHostImpl(name, profile, invalidator,
 448                                                sync_prefs, sync_folder);
 449 }
 450
 451 scoped_ptr<sync_driver::LocalDeviceInfoProvider>
 452 ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() {
 453   return scoped_ptr<sync_driver::LocalDeviceInfoProvider>(
 454       new browser_sync::LocalDeviceInfoProviderImpl());
 455 }
 456
 457 base::WeakPtr<syncer::SyncableService> ProfileSyncComponentsFactoryImpl::
 458     GetSyncableServiceForType(syncer::ModelType type) {
 459   if (!profile_) {  // For tests.
 460      return base::WeakPtr<syncer::SyncableService>();
 461   }
 462   switch (type) {
 463     case syncer::DEVICE_INFO:
 464       return ProfileSyncServiceFactory::GetForProfile(profile_)
 465           ->GetDeviceInfoSyncableService()
 466           ->AsWeakPtr();
 467     case syncer::PREFERENCES:
 468       return PrefServiceSyncable::FromProfile(
 469           profile_)->GetSyncableService(syncer::PREFERENCES)->AsWeakPtr();
 470     case syncer::PRIORITY_PREFERENCES:
 471       return PrefServiceSyncable::FromProfile(profile_)->GetSyncableService(
 472           syncer::PRIORITY_PREFERENCES)->AsWeakPtr();
 473     case syncer::AUTOFILL:
 474     case syncer::AUTOFILL_PROFILE: {
 475       if (!web_data_service_.get())
 476         return base::WeakPtr<syncer::SyncableService>();
 477       if (type == syncer::AUTOFILL) {
 478         return AutocompleteSyncableService::FromWebDataService(
 479             web_data_service_.get())->AsWeakPtr();
 480       } else {
 481         return autofill::AutofillProfileSyncableService::FromWebDataService(
 482             web_data_service_.get())->AsWeakPtr();
 483       }
 484     }
 485     case syncer::SEARCH_ENGINES:
 486       return TemplateURLServiceFactory::GetForProfile(profile_)->AsWeakPtr();
 487 #if defined(ENABLE_EXTENSIONS)
 488     case syncer::APPS:
 489     case syncer::EXTENSIONS:
 490       return ExtensionSyncService::Get(profile_)->AsWeakPtr();
 491     case syncer::APP_SETTINGS:
 492     case syncer::EXTENSION_SETTINGS:
 493       return extensions::settings_sync_util::GetSyncableService(profile_, type)
 494           ->AsWeakPtr();
 495 #endif
 496 #if defined(ENABLE_APP_LIST)
 497     case syncer::APP_LIST:
 498       return app_list::AppListSyncableServiceFactory::GetForProfile(profile_)->
 499           AsWeakPtr();
 500 #endif
 501 #if defined(ENABLE_THEMES)
 502     case syncer::THEMES:
 503       return ThemeServiceFactory::GetForProfile(profile_)->
 504           GetThemeSyncableService()->AsWeakPtr();
 505 #endif
 506     case syncer::HISTORY_DELETE_DIRECTIVES: {
 507       HistoryService* history =
 508           HistoryServiceFactory::GetForProfile(
 509               profile_, Profile::EXPLICIT_ACCESS);
 510       return history ? history->AsWeakPtr() : base::WeakPtr<HistoryService>();
 511     }
 512 #if defined(ENABLE_EXTENSIONS)
 513     case syncer::SYNCED_NOTIFICATIONS:
 514     case syncer::SYNCED_NOTIFICATION_APP_INFO: {
 515       return notifier::ChromeNotifierServiceFactory::GetForProfile(
 516                  profile_, Profile::IMPLICIT_ACCESS)
 517           ->GetSyncedNotificationsShim()
 518           ->AsWeakPtr();
 519     }
 520 #endif
 521 #if defined(ENABLE_SPELLCHECK)
 522     case syncer::DICTIONARY:
 523       return SpellcheckServiceFactory::GetForContext(profile_)->
 524           GetCustomDictionary()->AsWeakPtr();
 525 #endif
 526     case syncer::FAVICON_IMAGES:
 527     case syncer::FAVICON_TRACKING: {
 528       browser_sync::FaviconCache* favicons =
 529           ProfileSyncServiceFactory::GetForProfile(profile_)->
 530               GetFaviconCache();
 531       return favicons ? favicons->AsWeakPtr()
 532                       : base::WeakPtr<syncer::SyncableService>();
 533     }
 534 #if defined(ENABLE_MANAGED_USERS)
 535     case syncer::SUPERVISED_USER_SETTINGS:
 536       return SupervisedUserSettingsServiceFactory::GetForProfile(profile_)->
 537           AsWeakPtr();
 538     case syncer::SUPERVISED_USERS:
 539       return SupervisedUserSyncServiceFactory::GetForProfile(profile_)->
 540           AsWeakPtr();
 541     case syncer::SUPERVISED_USER_SHARED_SETTINGS:
 542       return SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
 543           profile_)->AsWeakPtr();
 544 #endif
 545     case syncer::ARTICLES: {
 546       dom_distiller::DomDistillerService* service =
 547           dom_distiller::DomDistillerServiceFactory::GetForBrowserContext(
 548               profile_);
 549       if (service)
 550         return service->GetSyncableService()->AsWeakPtr();
 551       return base::WeakPtr<syncer::SyncableService>();
 552     }
 553     case syncer::SESSIONS: {
 554       return ProfileSyncServiceFactory::GetForProfile(profile_)->
 555           GetSessionsSyncableService()->AsWeakPtr();
 556     }
 557     case syncer::PASSWORDS: {
 558 #if defined(PASSWORD_MANAGER_ENABLE_SYNC)
 559       scoped_refptr<password_manager::PasswordStore> password_store =
 560           PasswordStoreFactory::GetForProfile(profile_,
 561                                               Profile::EXPLICIT_ACCESS);
 562       return password_store.get() ? password_store->GetPasswordSyncableService()
 563                                   : base::WeakPtr<syncer::SyncableService>();
 564 #else
 565       return base::WeakPtr<syncer::SyncableService>();
 566 #endif
 567     }
 568     case syncer::ENHANCED_BOOKMARKS: {
 569       // TODO(wittman): Return enhanced bookmarks SyncableService once
 570       // implemented.
 571       return base::WeakPtr<syncer::SyncableService>();
 572     }
 573     default:
 574       // The following datatypes still need to be transitioned to the
 575       // syncer::SyncableService API:
 576       // Bookmarks
 577       // Typed URLs
 578       NOTREACHED();
 579       return base::WeakPtr<syncer::SyncableService>();
 580   }
 581 }
 582
 583 class TokenServiceProvider
 584     : public OAuth2TokenServiceRequest::TokenServiceProvider {
 585  public:
 586   TokenServiceProvider(
 587       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
 588       OAuth2TokenService* token_service);
 589
 590   // OAuth2TokenServiceRequest::TokenServiceProvider implementation.
 591   virtual scoped_refptr<base::SingleThreadTaskRunner>
 592       GetTokenServiceTaskRunner() override;
 593   virtual OAuth2TokenService* GetTokenService() override;
 594
 595  private:
 596   virtual ~TokenServiceProvider();
 597
 598   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 599   OAuth2TokenService* token_service_;
 600 };
 601
 602 TokenServiceProvider::TokenServiceProvider(
 603     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
 604     OAuth2TokenService* token_service)
 605     : task_runner_(task_runner), token_service_(token_service) {
 606 }
 607
 608 TokenServiceProvider::~TokenServiceProvider() {
 609 }
 610
 611 scoped_refptr<base::SingleThreadTaskRunner>
 612 TokenServiceProvider::GetTokenServiceTaskRunner() {
 613   return task_runner_;
 614 }
 615
 616 OAuth2TokenService* TokenServiceProvider::GetTokenService() {
 617   return token_service_;
 618 }
 619
 620 scoped_ptr<syncer::AttachmentService>
 621 ProfileSyncComponentsFactoryImpl::CreateAttachmentService(
 622     const scoped_refptr<syncer::AttachmentStore>& attachment_store,
 623     const syncer::UserShare& user_share,
 624     syncer::AttachmentService::Delegate* delegate) {
 625   scoped_ptr<syncer::AttachmentUploader> attachment_uploader;
 626   scoped_ptr<syncer::AttachmentDownloader> attachment_downloader;
 627   // Only construct an AttachmentUploader and AttachmentDownload if we have sync
 628   // credentials. We may not have sync credentials because there may not be a
 629   // signed in sync user (e.g. sync is running in "backup" mode).
 630   if (!user_share.sync_credentials.email.empty() &&
 631       !user_share.sync_credentials.scope_set.empty()) {
 632     scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider>
 633         token_service_provider(new TokenServiceProvider(
 634             content::BrowserThread::GetMessageLoopProxyForThread(
 635                 content::BrowserThread::UI),
 636             token_service_));
 637     // TODO(maniscalco): Use shared (one per profile) thread-safe instances of
 638     // AttachmentUploader and AttachmentDownloader instead of creating a new one
 639     // per AttachmentService (bug 369536).
 640     attachment_uploader.reset(new syncer::AttachmentUploaderImpl(
 641         sync_service_url_,
 642         url_request_context_getter_,
 643         user_share.sync_credentials.email,
 644         user_share.sync_credentials.scope_set,
 645         token_service_provider));
 646
 647     token_service_provider = new TokenServiceProvider(
 648         content::BrowserThread::GetMessageLoopProxyForThread(
 649             content::BrowserThread::UI),
 650         token_service_);
 651     attachment_downloader = syncer::AttachmentDownloader::Create(
 652         sync_service_url_,
 653         url_request_context_getter_,
 654         user_share.sync_credentials.email,
 655         user_share.sync_credentials.scope_set,
 656         token_service_provider);
 657   }
 658
 659   // It is important that the initial backoff delay is relatively large.  For
 660   // whatever reason, the server may fail all requests for a short period of
 661   // time.  When this happens we don't want to overwhelm the server with
 662   // requests so we use a large initial backoff.
 663   const base::TimeDelta initial_backoff_delay =
 664       base::TimeDelta::FromMinutes(30);
 665   const base::TimeDelta max_backoff_delay = base::TimeDelta::FromHours(4);
 666   scoped_ptr<syncer::AttachmentService> attachment_service(
 667       new syncer::AttachmentServiceImpl(attachment_store,
 668                                         attachment_uploader.Pass(),
 669                                         attachment_downloader.Pass(),
 670                                         delegate,
 671                                         initial_backoff_delay,
 672                                         max_backoff_delay));
 673   return attachment_service.Pass();
 674 }
 675
 676 ProfileSyncComponentsFactory::SyncComponents
 677     ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
 678         ProfileSyncService* profile_sync_service,
 679         sync_driver::DataTypeErrorHandler* error_handler) {
 680   BookmarkModel* bookmark_model =
 681       BookmarkModelFactory::GetForProfile(profile_sync_service->profile());
 682   syncer::UserShare* user_share = profile_sync_service->GetUserShare();
 683   // TODO(akalin): We may want to propagate this switch up eventually.
 684 #if defined(OS_ANDROID)
 685   const bool kExpectMobileBookmarksFolder = true;
 686 #else
 687   const bool kExpectMobileBookmarksFolder = false;
 688 #endif
 689   BookmarkModelAssociator* model_associator =
 690       new BookmarkModelAssociator(bookmark_model,
 691                                   profile_sync_service->profile(),
 692                                   user_share,
 693                                   error_handler,
 694                                   kExpectMobileBookmarksFolder);
 695   BookmarkChangeProcessor* change_processor =
 696       new BookmarkChangeProcessor(profile_sync_service->profile(),
 697                                   model_associator,
 698                                   error_handler);
 699   return SyncComponents(model_associator, change_processor);
 700 }
 701
 702 ProfileSyncComponentsFactory::SyncComponents
 703     ProfileSyncComponentsFactoryImpl::CreateTypedUrlSyncComponents(
 704         ProfileSyncService* profile_sync_service,
 705         history::HistoryBackend* history_backend,
 706         sync_driver::DataTypeErrorHandler* error_handler) {
 707   TypedUrlModelAssociator* model_associator =
 708       new TypedUrlModelAssociator(profile_sync_service,
 709                                   history_backend,
 710                                   error_handler);
 711   TypedUrlChangeProcessor* change_processor =
 712       new TypedUrlChangeProcessor(profile_,
 713                                   model_associator,
 714                                   history_backend,
 715                                   error_handler);
 716   return SyncComponents(model_associator, change_processor);
 717 }