[Sync] Remove UIDataTypeController

components/browser_sync/profile_sync_components_factory_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/browser_sync/profile_sync_components_factory_impl.h"
 
 #include <utility>
 
 #include "base/debug/dump_without_crashing.h"
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/autofill/core/browser/autofill_wallet_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_profile_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/browser_sync/browser_sync_switches.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/dom_distiller/core/dom_distiller_features.h"
 #include "components/history/core/browser/history_delete_directives_data_type_controller.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/sync/browser/password_data_type_controller.h"
 #include "components/prefs/pref_service.h"
 #include "components/reading_list/core/reading_list_switches.h"
 #include "components/sync/base/report_unrecoverable_error.h"
 #include "components/sync/device_info/device_info_data_type_controller.h"
 #include "components/sync/device_info/local_device_info_provider_impl.h"
 #include "components/sync/driver/data_type_manager_impl.h"
 #include "components/sync/driver/glue/sync_backend_host.h"
 #include "components/sync/driver/glue/sync_backend_host_impl.h"
 #include "components/sync/driver/model_type_controller.h"
+#include "components/sync/driver/non_ui_data_type_controller.h"
 #include "components/sync/driver/proxy_data_type_controller.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/driver/sync_driver_switches.h"
-#include "components/sync/driver/ui_data_type_controller.h"
 #include "components/sync/engine/attachments/attachment_downloader.h"
 #include "components/sync/engine/attachments/attachment_uploader.h"
 #include "components/sync/model/attachments/attachment_service.h"
 #include "components/sync_bookmarks/bookmark_change_processor.h"
 #include "components/sync_bookmarks/bookmark_data_type_controller.h"
 #include "components/sync_bookmarks/bookmark_model_associator.h"
 #include "components/sync_sessions/session_data_type_controller.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "google_apis/gaia/oauth2_token_service_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using bookmarks::BookmarkModel;
 using sync_bookmarks::BookmarkChangeProcessor;
 using sync_bookmarks::BookmarkDataTypeController;
 using sync_bookmarks::BookmarkModelAssociator;
 using syncer::DataTypeController;
 using syncer::DataTypeManager;
 using syncer::DataTypeManagerImpl;
 using syncer::DataTypeManagerObserver;
 using syncer::DeviceInfoDataTypeController;
 using syncer::ProxyDataTypeController;
-using syncer::UIDataTypeController;
 using syncer::ModelTypeController;
+using syncer::NonUIDataTypeController;
 using sync_sessions::SessionDataTypeController;
 
 namespace browser_sync {
 
 namespace {
 
 syncer::ModelTypeSet GetDisabledTypesFromCommandLine(
     const base::CommandLine& command_line) {
   syncer::ModelTypeSet disabled_types;
   std::string disabled_types_str =
@@ skipping 64 matching lines @@
   base::Closure error_callback =
       base::Bind(&syncer::ReportUnrecoverableError, channel_);
 
   // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes?
   if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) {
     // Use an error callback that always uploads a stacktrace if it can to help
     // get USS as stable as possible.
     sync_service->RegisterDataTypeController(
         base::MakeUnique<ModelTypeController>(
             syncer::DEVICE_INFO, base::Bind(&base::debug::DumpWithoutCrashing),
-            sync_client_, base::ThreadTaskRunnerHandle::Get()));
+            sync_client_, ui_thread_));
   } else {
     sync_service->RegisterDataTypeController(
         base::MakeUnique<DeviceInfoDataTypeController>(
             error_callback, sync_client_,
             sync_service->GetLocalDeviceInfoProvider()));
   }
 
   // Autofill sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::AUTOFILL)) {
@@ skipping 68 matching lines @@
             error_callback, sync_client_,
             sync_service->GetLocalDeviceInfoProvider(),
             history_disabled_pref_));
   }
 
   // Favicon sync is enabled by default. Register unless explicitly disabled.
   if (!disabled_types.Has(syncer::FAVICON_IMAGES) &&
       !disabled_types.Has(syncer::FAVICON_TRACKING) && !history_disabled) {
     // crbug/384552. We disable error uploading for this data types for now.
     sync_service->RegisterDataTypeController(
-        base::MakeUnique<UIDataTypeController>(syncer::FAVICON_IMAGES,
-                                               base::Closure(), sync_client_));
+        base::MakeUnique<NonUIDataTypeController>(
+            syncer::FAVICON_IMAGES, base::Closure(), sync_client_,
+            syncer::GROUP_UI, ui_thread_));
     sync_service->RegisterDataTypeController(
-        base::MakeUnique<UIDataTypeController>(syncer::FAVICON_TRACKING,
-                                               base::Closure(), sync_client_));
+        base::MakeUnique<NonUIDataTypeController>(
+            syncer::FAVICON_TRACKING, base::Closure(), sync_client_,
+            syncer::GROUP_UI, ui_thread_));
   }
 
   // Password sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::PASSWORDS)) {
     sync_service->RegisterDataTypeController(
         base::MakeUnique<PasswordDataTypeController>(
             error_callback, sync_client_,
             sync_client_->GetPasswordStateChangedCallback(), password_store_));
   }
 
   if (!disabled_types.Has(syncer::PREFERENCES)) {
     if (!override_prefs_controller_to_uss_for_test_) {
       sync_service->RegisterDataTypeController(
-          base::MakeUnique<UIDataTypeController>(syncer::PREFERENCES,
-                                                 error_callback, sync_client_));
+          base::MakeUnique<NonUIDataTypeController>(
+              syncer::PREFERENCES, error_callback, sync_client_,
+              syncer::GROUP_UI, ui_thread_));
     } else {
       sync_service->RegisterDataTypeController(
           base::MakeUnique<ModelTypeController>(
-              syncer::PREFERENCES, error_callback, sync_client_,
-              base::ThreadTaskRunnerHandle::Get()));
+              syncer::PREFERENCES, error_callback, sync_client_, ui_thread_));
     }
   }
 
   if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
     sync_service->RegisterDataTypeController(
-        base::MakeUnique<UIDataTypeController>(syncer::PRIORITY_PREFERENCES,
-                                               error_callback, sync_client_));
+        base::MakeUnique<NonUIDataTypeController>(
+            syncer::PRIORITY_PREFERENCES, error_callback, sync_client_,
+            syncer::GROUP_UI, ui_thread_));
   }
 
   // Article sync is disabled by default.  Register only if explicitly enabled.
   if (dom_distiller::IsEnableSyncArticlesSet()) {
     sync_service->RegisterDataTypeController(
-        base::MakeUnique<UIDataTypeController>(syncer::ARTICLES, error_callback,
-                                               sync_client_));
+        base::MakeUnique<NonUIDataTypeController>(
+            syncer::ARTICLES, error_callback, sync_client_, syncer::GROUP_UI,
+            ui_thread_));
   }
 
   // Reading list sync is enabled by default only on iOS. Register unless
   // Reading List or Reading List Sync is explicitly disabled.
   if (!disabled_types.Has(syncer::READING_LIST) &&
       reading_list::switches::IsReadingListEnabled()) {
     sync_service->RegisterDataTypeController(
         base::MakeUnique<ModelTypeController>(
-            syncer::READING_LIST, error_callback, sync_client_,
-            base::ThreadTaskRunnerHandle::Get()));
+            syncer::READING_LIST, error_callback, sync_client_, ui_thread_));
   }
 }
 
 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const DataTypeController::TypeMap* controllers,
     const syncer::DataTypeEncryptionHandler* encryption_handler,
     syncer::SyncBackendHost* backend,
     DataTypeManagerObserver* observer) {
@@ skipping 124 matching lines @@
 
 // static
 void ProfileSyncComponentsFactoryImpl::OverridePrefsForUssTest(bool use_uss) {
   override_prefs_controller_to_uss_for_test_ = use_uss;
 }
 
 bool ProfileSyncComponentsFactoryImpl::
     override_prefs_controller_to_uss_for_test_ = false;
 
 }  // namespace browser_sync