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