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/password_manager/password_store_factory.h"
  13 #include "chrome/browser/pref_service_flags_storage.h"
  14 #include "chrome/browser/prefs/pref_model_associator.h"
  15 #include "chrome/browser/prefs/pref_service_syncable.h"
  16 #include "chrome/browser/profiles/profile.h"
  17 #include "chrome/browser/search_engines/template_url_service.h"
  18 #include "chrome/browser/search_engines/template_url_service_factory.h"
  19 #include "chrome/browser/signin/signin_manager.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/data_type_manager_impl.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/generic_change_processor.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/session_change_processor.h"
  34 #include "chrome/browser/sync/glue/session_data_type_controller.h"
  35 #include "chrome/browser/sync/glue/session_model_associator.h"
  36 #include "chrome/browser/sync/glue/shared_change_processor.h"
  37 #include "chrome/browser/sync/glue/sync_backend_host.h"
  38 #include "chrome/browser/sync/glue/sync_backend_host_impl.h"
  39 #include "chrome/browser/sync/glue/theme_data_type_controller.h"
  40 #include "chrome/browser/sync/glue/typed_url_change_processor.h"
  41 #include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
  42 #include "chrome/browser/sync/glue/typed_url_model_associator.h"
  43 #include "chrome/browser/sync/glue/ui_data_type_controller.h"
  44 #include "chrome/browser/sync/profile_sync_components_factory_impl.h"
  45 #include "chrome/browser/sync/profile_sync_service.h"
  46 #include "chrome/browser/sync/profile_sync_service_factory.h"
  47 #include "chrome/browser/sync/sessions2/session_data_type_controller2.h"
  48 #include "chrome/browser/themes/theme_service.h"
  49 #include "chrome/browser/themes/theme_service_factory.h"
  50 #include "chrome/browser/themes/theme_syncable_service.h"
  51 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
  52 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
  53 #include "chrome/browser/webdata/autocomplete_syncable_service.h"
  54 #include "chrome/browser/webdata/web_data_service_factory.h"
  55 #include "chrome/common/chrome_switches.h"
  56 #include "chrome/common/chrome_version_info.h"
  57 #include "chrome/common/pref_names.h"
  58 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
  59 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
  60 #include "components/dom_distiller/core/dom_distiller_service.h"
  61 #include "components/password_manager/core/browser/password_store.h"
  62 #include "components/sync_driver/data_type_manager_observer.h"
  63 #include "components/sync_driver/proxy_data_type_controller.h"
  64 #include "content/public/browser/browser_thread.h"
  65 #include "extensions/browser/extension_system.h"
  66 #include "sync/api/syncable_service.h"
  67
  68 #if defined(ENABLE_EXTENSIONS)
  69 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
  70 #include "chrome/browser/extensions/extension_sync_service.h"
  71 #endif
  72
  73 #if defined(ENABLE_MANAGED_USERS)
  74 #include "chrome/browser/managed_mode/managed_user_settings_service.h"
  75 #include "chrome/browser/managed_mode/managed_user_settings_service_factory.h"
  76 #include "chrome/browser/managed_mode/managed_user_shared_settings_service.h"
  77 #include "chrome/browser/managed_mode/managed_user_shared_settings_service_factory.h"
  78 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
  79 #include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
  80 #endif
  81
  82 #if !defined(OS_ANDROID)
  83 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service.h"
  84 #include "chrome/browser/notifications/sync_notifier/chrome_notifier_service_factory.h"
  85 #include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service.h"
  86 #include "chrome/browser/notifications/sync_notifier/synced_notification_app_info_service_factory.h"
  87 #endif
  88
  89 #if defined(ENABLE_SPELLCHECK)
  90 #include "chrome/browser/spellchecker/spellcheck_factory.h"
  91 #include "chrome/browser/spellchecker/spellcheck_service.h"
  92 #endif
  93
  94 using browser_sync::AutofillDataTypeController;
  95 using browser_sync::AutofillProfileDataTypeController;
  96 using browser_sync::BookmarkChangeProcessor;
  97 using browser_sync::BookmarkDataTypeController;
  98 using browser_sync::BookmarkModelAssociator;
  99 using browser_sync::ChromeReportUnrecoverableError;
 100 using browser_sync::DataTypeController;
 101 using browser_sync::DataTypeErrorHandler;
 102 using browser_sync::DataTypeManager;
 103 using browser_sync::DataTypeManagerImpl;
 104 using browser_sync::DataTypeManagerObserver;
 105 using browser_sync::ExtensionDataTypeController;
 106 using browser_sync::ExtensionSettingDataTypeController;
 107 using browser_sync::GenericChangeProcessor;
 108 using browser_sync::PasswordDataTypeController;
 109 using browser_sync::ProxyDataTypeController;
 110 using browser_sync::SearchEngineDataTypeController;
 111 using browser_sync::SessionChangeProcessor;
 112 using browser_sync::SessionDataTypeController;
 113 using browser_sync::SessionDataTypeController2;
 114 using browser_sync::SessionModelAssociator;
 115 using browser_sync::SharedChangeProcessor;
 116 using browser_sync::SyncBackendHost;
 117 using browser_sync::ThemeDataTypeController;
 118 using browser_sync::TypedUrlChangeProcessor;
 119 using browser_sync::TypedUrlDataTypeController;
 120 using browser_sync::TypedUrlModelAssociator;
 121 using browser_sync::UIDataTypeController;
 122 using content::BrowserThread;
 123
 124 namespace {
 125
 126 syncer::ModelTypeSet GetDisabledTypesFromCommandLine(
 127     CommandLine* command_line) {
 128   syncer::ModelTypeSet disabled_types;
 129   std::string disabled_types_str =
 130       command_line->GetSwitchValueASCII(switches::kDisableSyncTypes);
 131   disabled_types = syncer::ModelTypeSetFromString(disabled_types_str);
 132   return disabled_types;
 133 }
 134
 135 }  // namespace
 136
 137 ProfileSyncComponentsFactoryImpl::ProfileSyncComponentsFactoryImpl(
 138     Profile* profile, CommandLine* command_line)
 139     : profile_(profile),
 140       command_line_(command_line),
 141       extension_system_(extensions::ExtensionSystem::Get(profile)),
 142       web_data_service_(
 143           WebDataServiceFactory::GetAutofillWebDataForProfile(
 144               profile_, Profile::EXPLICIT_ACCESS)) {
 145 }
 146
 147 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {
 148 }
 149
 150 void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
 151     ProfileSyncService* pss) {
 152   syncer::ModelTypeSet disabled_types =
 153       GetDisabledTypesFromCommandLine(command_line_);
 154   // TODO(zea): pass an enabled_types set for types that are off by default.
 155   RegisterCommonDataTypes(disabled_types, pss);
 156 #if !defined(OS_ANDROID)
 157   RegisterDesktopDataTypes(disabled_types, pss);
 158 #endif
 159 }
 160
 161 void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes(
 162     syncer::ModelTypeSet disabled_types,
 163     ProfileSyncService* pss) {
 164   // Autofill sync is enabled by default.  Register unless explicitly
 165   // disabled.
 166   if (!disabled_types.Has(syncer::AUTOFILL)) {
 167     pss->RegisterDataTypeController(
 168         new AutofillDataTypeController(this, profile_, pss));
 169   }
 170
 171   // Autofill profile sync is enabled by default.  Register unless explicitly
 172   // disabled.
 173   if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) {
 174     pss->RegisterDataTypeController(
 175         new AutofillProfileDataTypeController(this, profile_, pss));
 176   }
 177
 178   // Bookmark sync is enabled by default.  Register unless explicitly
 179   // disabled.
 180   if (!disabled_types.Has(syncer::BOOKMARKS)) {
 181     pss->RegisterDataTypeController(
 182         new BookmarkDataTypeController(this, profile_, pss));
 183   }
 184
 185   // TypedUrl sync is enabled by default.  Register unless explicitly disabled,
 186   // or if saving history is disabled.
 187   if (!profile_->GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled) &&
 188       !disabled_types.Has(syncer::TYPED_URLS)) {
 189     pss->RegisterDataTypeController(
 190         new TypedUrlDataTypeController(this, profile_, pss));
 191   }
 192
 193   // Delete directive sync is enabled by default.  Register unless full history
 194   // sync is disabled.
 195   if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES)) {
 196     pss->RegisterDataTypeController(
 197         new UIDataTypeController(
 198             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 199             base::Bind(&ChromeReportUnrecoverableError),
 200             syncer::HISTORY_DELETE_DIRECTIVES,
 201             this,
 202             profile_,
 203             pss));
 204   }
 205
 206   // Session sync is enabled by default.  Register unless explicitly disabled.
 207   if (!disabled_types.Has(syncer::PROXY_TABS)) {
 208       pss->RegisterDataTypeController(new ProxyDataTypeController(
 209          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 210          syncer::PROXY_TABS));
 211     pss->RegisterDataTypeController(
 212         new SessionDataTypeController2(this, profile_, pss));
 213   }
 214
 215   // Favicon sync is enabled by default. Register unless explicitly disabled.
 216   if (!disabled_types.Has(syncer::FAVICON_IMAGES) &&
 217       !disabled_types.Has(syncer::FAVICON_TRACKING)) {
 218     pss->RegisterDataTypeController(
 219         new UIDataTypeController(
 220             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 221             base::Bind(&ChromeReportUnrecoverableError),
 222             syncer::FAVICON_IMAGES,
 223             this,
 224             profile_,
 225             pss));
 226     pss->RegisterDataTypeController(
 227         new UIDataTypeController(
 228             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 229             base::Bind(&ChromeReportUnrecoverableError),
 230             syncer::FAVICON_TRACKING,
 231             this,
 232             profile_,
 233             pss));
 234   }
 235
 236   // Password sync is enabled by default.  Register unless explicitly
 237   // disabled.
 238   if (!disabled_types.Has(syncer::PASSWORDS)) {
 239     pss->RegisterDataTypeController(
 240         new PasswordDataTypeController(this, profile_, pss));
 241   }
 242
 243   // Article sync is disabled by default.  Register only if explicitly enabled.
 244   if (IsEnableSyncArticlesSet()) {
 245     pss->RegisterDataTypeController(
 246         new UIDataTypeController(
 247             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 248             base::Bind(&ChromeReportUnrecoverableError),
 249             syncer::ARTICLES,
 250             this,
 251             profile_,
 252             pss));
 253   }
 254
 255 #if defined(ENABLE_MANAGED_USERS)
 256   if (profile_->IsManaged()) {
 257     pss->RegisterDataTypeController(
 258         new UIDataTypeController(
 259             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 260             base::Bind(&ChromeReportUnrecoverableError),
 261             syncer::MANAGED_USER_SETTINGS,
 262             this,
 263             profile_,
 264             pss));
 265   } else {
 266     pss->RegisterDataTypeController(
 267         new UIDataTypeController(
 268             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 269             base::Bind(&ChromeReportUnrecoverableError),
 270             syncer::MANAGED_USERS,
 271             this,
 272             profile_,
 273             pss));
 274   }
 275   pss->RegisterDataTypeController(
 276       new UIDataTypeController(
 277             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 278             base::Bind(&ChromeReportUnrecoverableError),
 279             syncer::MANAGED_USER_SHARED_SETTINGS,
 280             this,
 281             profile_,
 282             pss));
 283 #endif
 284 }
 285
 286 void ProfileSyncComponentsFactoryImpl::RegisterDesktopDataTypes(
 287     syncer::ModelTypeSet disabled_types,
 288     ProfileSyncService* pss) {
 289   // App sync is enabled by default.  Register unless explicitly
 290   // disabled.
 291   if (!disabled_types.Has(syncer::APPS)) {
 292     pss->RegisterDataTypeController(
 293         new ExtensionDataTypeController(syncer::APPS, this, profile_, pss));
 294   }
 295
 296   // Extension sync is enabled by default.  Register unless explicitly
 297   // disabled.
 298   if (!disabled_types.Has(syncer::EXTENSIONS)) {
 299     pss->RegisterDataTypeController(
 300         new ExtensionDataTypeController(syncer::EXTENSIONS,
 301                                         this, profile_, pss));
 302   }
 303
 304   // Preference sync is enabled by default.  Register unless explicitly
 305   // disabled.
 306   if (!disabled_types.Has(syncer::PREFERENCES)) {
 307     pss->RegisterDataTypeController(
 308         new UIDataTypeController(
 309             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 310             base::Bind(&ChromeReportUnrecoverableError),
 311             syncer::PREFERENCES,
 312             this,
 313             profile_,
 314             pss));
 315
 316   }
 317
 318   if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
 319     pss->RegisterDataTypeController(
 320         new UIDataTypeController(
 321             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 322             base::Bind(&ChromeReportUnrecoverableError),
 323             syncer::PRIORITY_PREFERENCES,
 324             this,
 325             profile_,
 326             pss));
 327   }
 328
 329 #if defined(ENABLE_THEMES)
 330   // Theme sync is enabled by default.  Register unless explicitly disabled.
 331   if (!disabled_types.Has(syncer::THEMES)) {
 332     pss->RegisterDataTypeController(
 333         new ThemeDataTypeController(this, profile_, pss));
 334   }
 335 #endif
 336
 337   // Search Engine sync is enabled by default.  Register unless explicitly
 338   // disabled.
 339   if (!disabled_types.Has(syncer::SEARCH_ENGINES)) {
 340     pss->RegisterDataTypeController(
 341         new SearchEngineDataTypeController(this, profile_, pss));
 342   }
 343
 344   // Extension setting sync is enabled by default.  Register unless explicitly
 345   // disabled.
 346   if (!disabled_types.Has(syncer::EXTENSION_SETTINGS)) {
 347     pss->RegisterDataTypeController(
 348         new ExtensionSettingDataTypeController(
 349             syncer::EXTENSION_SETTINGS, this, profile_, pss));
 350   }
 351
 352   // App setting sync is enabled by default.  Register unless explicitly
 353   // disabled.
 354   if (!disabled_types.Has(syncer::APP_SETTINGS)) {
 355     pss->RegisterDataTypeController(
 356         new ExtensionSettingDataTypeController(
 357             syncer::APP_SETTINGS, this, profile_, pss));
 358   }
 359
 360 #if defined(ENABLE_APP_LIST)
 361   if (!command_line_->HasSwitch(switches::kDisableSyncAppList)) {
 362     pss->RegisterDataTypeController(
 363         new UIDataTypeController(
 364             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 365             base::Bind(&ChromeReportUnrecoverableError),
 366             syncer::APP_LIST,
 367             this,
 368             profile_,
 369             pss));
 370   }
 371 #endif
 372
 373   // Synced Notifications are enabled by default.
 374   if (!disabled_types.Has(syncer::SYNCED_NOTIFICATIONS)) {
 375     pss->RegisterDataTypeController(
 376         new UIDataTypeController(
 377               BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 378               base::Bind(&ChromeReportUnrecoverableError),
 379               syncer::SYNCED_NOTIFICATIONS,
 380               this,
 381               profile_,
 382               pss));
 383
 384     // Synced Notification App Infos are disabled by default.
 385     if (command_line_->HasSwitch(switches::kEnableSyncSyncedNotifications)) {
 386       pss->RegisterDataTypeController(new UIDataTypeController(
 387           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 388           base::Bind(&ChromeReportUnrecoverableError),
 389           syncer::SYNCED_NOTIFICATION_APP_INFO,
 390           this,
 391           profile_,
 392           pss));
 393     }
 394   }
 395
 396 #if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_CHROMEOS)
 397   // Dictionary sync is enabled by default.
 398   if (!disabled_types.Has(syncer::DICTIONARY)) {
 399     pss->RegisterDataTypeController(
 400         new UIDataTypeController(
 401             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 402             base::Bind(&ChromeReportUnrecoverableError),
 403             syncer::DICTIONARY,
 404             this,
 405             profile_,
 406             pss));
 407   }
 408 #endif
 409 }
 410
 411 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
 412     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
 413         debug_info_listener,
 414     const DataTypeController::TypeMap* controllers,
 415     const browser_sync::DataTypeEncryptionHandler* encryption_handler,
 416     SyncBackendHost* backend,
 417     DataTypeManagerObserver* observer,
 418     browser_sync::FailedDataTypesHandler* failed_data_types_handler) {
 419   return new DataTypeManagerImpl(debug_info_listener,
 420                                  controllers,
 421                                  encryption_handler,
 422                                  backend,
 423                                  observer,
 424                                  failed_data_types_handler);
 425 }
 426
 427 browser_sync::SyncBackendHost*
 428 ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
 429     const std::string& name,
 430     Profile* profile,
 431     const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs) {
 432   return new browser_sync::SyncBackendHostImpl(name, profile, sync_prefs);
 433 }
 434
 435 browser_sync::GenericChangeProcessor*
 436     ProfileSyncComponentsFactoryImpl::CreateGenericChangeProcessor(
 437         ProfileSyncService* profile_sync_service,
 438         browser_sync::DataTypeErrorHandler* error_handler,
 439         const base::WeakPtr<syncer::SyncableService>& local_service,
 440         const base::WeakPtr<syncer::SyncMergeResult>& merge_result) {
 441   syncer::UserShare* user_share = profile_sync_service->GetUserShare();
 442   return new GenericChangeProcessor(error_handler,
 443                                     local_service,
 444                                     merge_result,
 445                                     user_share);
 446 }
 447
 448 browser_sync::SharedChangeProcessor* ProfileSyncComponentsFactoryImpl::
 449     CreateSharedChangeProcessor() {
 450   return new SharedChangeProcessor();
 451 }
 452
 453 base::WeakPtr<syncer::SyncableService> ProfileSyncComponentsFactoryImpl::
 454     GetSyncableServiceForType(syncer::ModelType type) {
 455   if (!profile_) {  // For tests.
 456      return base::WeakPtr<syncer::SyncableService>();
 457   }
 458   switch (type) {
 459     case syncer::PREFERENCES:
 460       return PrefServiceSyncable::FromProfile(
 461           profile_)->GetSyncableService(syncer::PREFERENCES)->AsWeakPtr();
 462     case syncer::PRIORITY_PREFERENCES:
 463       return PrefServiceSyncable::FromProfile(profile_)->GetSyncableService(
 464           syncer::PRIORITY_PREFERENCES)->AsWeakPtr();
 465     case syncer::AUTOFILL:
 466     case syncer::AUTOFILL_PROFILE: {
 467       if (!web_data_service_.get())
 468         return base::WeakPtr<syncer::SyncableService>();
 469       if (type == syncer::AUTOFILL) {
 470         return AutocompleteSyncableService::FromWebDataService(
 471             web_data_service_.get())->AsWeakPtr();
 472       } else {
 473         return autofill::AutofillProfileSyncableService::FromWebDataService(
 474             web_data_service_.get())->AsWeakPtr();
 475       }
 476     }
 477     case syncer::SEARCH_ENGINES:
 478       return TemplateURLServiceFactory::GetForProfile(profile_)->AsWeakPtr();
 479 #if defined(ENABLE_EXTENSIONS)
 480     case syncer::APPS:
 481     case syncer::EXTENSIONS:
 482       return ExtensionSyncService::Get(profile_)->AsWeakPtr();
 483     case syncer::APP_SETTINGS:
 484     case syncer::EXTENSION_SETTINGS:
 485       return extensions::settings_sync_util::GetSyncableService(profile_, type)
 486           ->AsWeakPtr();
 487 #endif
 488 #if defined(ENABLE_APP_LIST)
 489     case syncer::APP_LIST:
 490       return app_list::AppListSyncableServiceFactory::GetForProfile(profile_)->
 491           AsWeakPtr();
 492 #endif
 493 #if defined(ENABLE_THEMES)
 494     case syncer::THEMES:
 495       return ThemeServiceFactory::GetForProfile(profile_)->
 496           GetThemeSyncableService()->AsWeakPtr();
 497 #endif
 498     case syncer::HISTORY_DELETE_DIRECTIVES: {
 499       HistoryService* history =
 500           HistoryServiceFactory::GetForProfile(
 501               profile_, Profile::EXPLICIT_ACCESS);
 502       return history ? history->AsWeakPtr() : base::WeakPtr<HistoryService>();
 503     }
 504 #if !defined(OS_ANDROID)
 505     case syncer::SYNCED_NOTIFICATIONS: {
 506       notifier::ChromeNotifierService* notifier_service =
 507           notifier::ChromeNotifierServiceFactory::GetForProfile(
 508               profile_, Profile::EXPLICIT_ACCESS);
 509       return notifier_service ? notifier_service->AsWeakPtr()
 510           : base::WeakPtr<syncer::SyncableService>();
 511     }
 512
 513     case syncer::SYNCED_NOTIFICATION_APP_INFO: {
 514       notifier::SyncedNotificationAppInfoService* app_info =
 515           notifier::SyncedNotificationAppInfoServiceFactory::GetForProfile(
 516               profile_, Profile::EXPLICIT_ACCESS);
 517       return app_info ? app_info->AsWeakPtr()
 518                       : base::WeakPtr<syncer::SyncableService>();
 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::MANAGED_USER_SETTINGS:
 536       return ManagedUserSettingsServiceFactory::GetForProfile(profile_)->
 537           AsWeakPtr();
 538     case syncer::MANAGED_USERS:
 539       return ManagedUserSyncServiceFactory::GetForProfile(profile_)->
 540           AsWeakPtr();
 541     case syncer::MANAGED_USER_SHARED_SETTINGS:
 542       return ManagedUserSharedSettingsServiceFactory::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       DCHECK(!command_line_->HasSwitch(switches::kDisableSyncSessionsV2));
 555       return ProfileSyncServiceFactory::GetForProfile(profile_)->
 556           GetSessionsSyncableService()->AsWeakPtr();
 557     }
 558     case syncer::PASSWORDS: {
 559 #if defined(PASSWORD_MANAGER_ENABLE_SYNC)
 560       PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
 561           profile_, Profile::EXPLICIT_ACCESS);
 562       return password_store ? password_store->GetPasswordSyncableService()
 563                             : base::WeakPtr<syncer::SyncableService>();
 564 #else
 565       return base::WeakPtr<syncer::SyncableService>();
 566 #endif
 567     }
 568     default:
 569       // The following datatypes still need to be transitioned to the
 570       // syncer::SyncableService API:
 571       // Bookmarks
 572       // Typed URLs
 573       NOTREACHED();
 574       return base::WeakPtr<syncer::SyncableService>();
 575   }
 576 }
 577
 578 ProfileSyncComponentsFactory::SyncComponents
 579     ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
 580         ProfileSyncService* profile_sync_service,
 581         DataTypeErrorHandler* error_handler) {
 582   BookmarkModel* bookmark_model =
 583       BookmarkModelFactory::GetForProfile(profile_sync_service->profile());
 584   syncer::UserShare* user_share = profile_sync_service->GetUserShare();
 585   // TODO(akalin): We may want to propagate this switch up eventually.
 586 #if defined(OS_ANDROID)
 587   const bool kExpectMobileBookmarksFolder = true;
 588 #else
 589   const bool kExpectMobileBookmarksFolder = false;
 590 #endif
 591   BookmarkModelAssociator* model_associator =
 592       new BookmarkModelAssociator(bookmark_model,
 593                                   profile_sync_service->profile(),
 594                                   user_share,
 595                                   error_handler,
 596                                   kExpectMobileBookmarksFolder);
 597   BookmarkChangeProcessor* change_processor =
 598       new BookmarkChangeProcessor(model_associator,
 599                                   error_handler);
 600   return SyncComponents(model_associator, change_processor);
 601 }
 602
 603 ProfileSyncComponentsFactory::SyncComponents
 604     ProfileSyncComponentsFactoryImpl::CreateTypedUrlSyncComponents(
 605         ProfileSyncService* profile_sync_service,
 606         history::HistoryBackend* history_backend,
 607         browser_sync::DataTypeErrorHandler* error_handler) {
 608   TypedUrlModelAssociator* model_associator =
 609       new TypedUrlModelAssociator(profile_sync_service,
 610                                   history_backend,
 611                                   error_handler);
 612   TypedUrlChangeProcessor* change_processor =
 613       new TypedUrlChangeProcessor(profile_,
 614                                   model_associator,
 615                                   history_backend,
 616                                   error_handler);
 617   return SyncComponents(model_associator, change_processor);
 618 }
 619
 620 ProfileSyncComponentsFactory::SyncComponents
 621     ProfileSyncComponentsFactoryImpl::CreateSessionSyncComponents(
 622        ProfileSyncService* profile_sync_service,
 623         DataTypeErrorHandler* error_handler) {
 624   SessionModelAssociator* model_associator =
 625       new SessionModelAssociator(profile_sync_service, error_handler);
 626   SessionChangeProcessor* change_processor =
 627       new SessionChangeProcessor(error_handler, model_associator);
 628   return SyncComponents(model_associator, change_processor);
 629 }