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