[Sync] Replace ProfileSyncComponentsFactory with SyncClient

chrome/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 "chrome/browser/sync/profile_sync_components_factory_impl.h"
 
 #include "base/command_line.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/dom_distiller/dom_distiller_service_factory.h"
@@ skipping 178 matching lines @@
       url_request_context_getter_(url_request_context_getter),
       chrome_sync_client_(profile_, this),
       weak_factory_(this) {
   DCHECK(token_service_);
   DCHECK(url_request_context_getter_);
 }
 
 ProfileSyncComponentsFactoryImpl::~ProfileSyncComponentsFactoryImpl() {
 }
 
+void ProfileSyncComponentsFactoryImpl::Initialize(
+    sync_driver::SyncService* sync_service) {
+  chrome_sync_client_.Initialize(sync_service);
+}
+
 void ProfileSyncComponentsFactoryImpl::RegisterDataTypes(
-    ProfileSyncService* pss) {
+    sync_driver::SyncService* sync_service) {

[stanisc, 2015/08/27 22:14:04]

Why does this have to receive sync_service? Could it get it from
chrome_sync_client_?

[Nicolas Zea, 2015/08/27 23:37:16]

Done.

   syncer::ModelTypeSet disabled_types =
       GetDisabledTypesFromCommandLine(*command_line_);
   syncer::ModelTypeSet enabled_types =
       GetEnabledTypesFromCommandLine(*command_line_);
-  RegisterCommonDataTypes(disabled_types, enabled_types, pss);
+  RegisterCommonDataTypes(disabled_types, enabled_types, sync_service);
 #if !defined(OS_ANDROID)
-  RegisterDesktopDataTypes(disabled_types, enabled_types, pss);
+  RegisterDesktopDataTypes(disabled_types, enabled_types, sync_service);
 #endif
 }
 
 void ProfileSyncComponentsFactoryImpl::RegisterCommonDataTypes(
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types,
-    ProfileSyncService* pss) {
+    sync_driver::SyncService* sync_service) {

[stanisc, 2015/08/27 22:14:04]

The same comment about sync_service as above.

[Nicolas Zea, 2015/08/27 23:37:16]

Done.

   // TODO(stanisc): can DEVICE_INFO be one of disabled datatypes?
-  pss->RegisterDataTypeController(new DeviceInfoDataTypeController(
+  sync_service->RegisterDataTypeController(new DeviceInfoDataTypeController(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
       base::Bind(&ChromeReportUnrecoverableError),
       &chrome_sync_client_,
-      pss->GetLocalDeviceInfoProvider()));
+      sync_service->GetLocalDeviceInfoProvider()));
 
   // Autofill sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::AUTOFILL)) {
-    pss->RegisterDataTypeController(
-        new AutofillDataTypeController(&chrome_sync_client_, profile_));
+    sync_service->RegisterDataTypeController(
+        new AutofillDataTypeController(&chrome_sync_client_));
   }
 
   // Autofill profile sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::AUTOFILL_PROFILE)) {
-    pss->RegisterDataTypeController(
-        new AutofillProfileDataTypeController(&chrome_sync_client_, profile_));
+    sync_service->RegisterDataTypeController(
+        new AutofillProfileDataTypeController(&chrome_sync_client_));
   }
 
   // Wallet data sync is enabled by default, but behind a syncer experiment
   // enforced by the datatype controller. Register unless explicitly disabled.
   bool wallet_disabled = disabled_types.Has(syncer::AUTOFILL_WALLET_DATA);
   if (!wallet_disabled) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new browser_sync::AutofillWalletDataTypeController(
-            &chrome_sync_client_, profile_, syncer::AUTOFILL_WALLET_DATA));
+            &chrome_sync_client_, syncer::AUTOFILL_WALLET_DATA));
   }
 
   // Wallet metadata sync depends on Wallet data sync and is disabled by
   // default. Register if Wallet data is syncing and metadata sync is explicitly
   // enabled.
   if (!wallet_disabled && enabled_types.Has(syncer::AUTOFILL_WALLET_METADATA)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new browser_sync::AutofillWalletDataTypeController(
-            &chrome_sync_client_, profile_, syncer::AUTOFILL_WALLET_METADATA));
+            &chrome_sync_client_, syncer::AUTOFILL_WALLET_METADATA));
   }
 
   // Bookmark sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::BOOKMARKS)) {
-    pss->RegisterDataTypeController(
-        new BookmarkDataTypeController(&chrome_sync_client_, profile_, pss));
+    sync_service->RegisterDataTypeController(
+        new BookmarkDataTypeController(&chrome_sync_client_));
   }
 
   const bool history_disabled =
       profile_->GetPrefs()->GetBoolean(prefs::kSavingBrowserHistoryDisabled);
   // TypedUrl sync is enabled by default.  Register unless explicitly disabled,
   // or if saving history is disabled.
   if (!disabled_types.Has(syncer::TYPED_URLS) && !history_disabled) {
-    pss->RegisterDataTypeController(
-        new TypedUrlDataTypeController(&chrome_sync_client_, profile_, pss));
+    sync_service->RegisterDataTypeController(
+        new TypedUrlDataTypeController(&chrome_sync_client_));
   }
 
   // Delete directive sync is enabled by default.  Register unless full history
   // sync is disabled.
   if (!disabled_types.Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
       !history_disabled) {
-    pss->RegisterDataTypeController(
-        new HistoryDeleteDirectivesDataTypeController(&chrome_sync_client_,
-                                                      pss));
+    sync_service->RegisterDataTypeController(
+        new HistoryDeleteDirectivesDataTypeController(&chrome_sync_client_));
   }
 
   // Session sync is enabled by default.  Register unless explicitly disabled.
   // This is also disabled if the browser history is disabled, because the
   // tab sync data is added to the web history on the server.
   if (!disabled_types.Has(syncer::PROXY_TABS) && !history_disabled) {
-    pss->RegisterDataTypeController(new ProxyDataTypeController(
+    sync_service->RegisterDataTypeController(new ProxyDataTypeController(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
         syncer::PROXY_TABS));
-    pss->RegisterDataTypeController(
-        new SessionDataTypeController(&chrome_sync_client_,
-                                      profile_,
-                                      pss->GetSyncedWindowDelegatesGetter(),
-                                      pss->GetLocalDeviceInfoProvider()));
+    // TODO(zea): remove this once SyncedWindowDelegateGetter is componentized.

[stanisc, 2015/08/27 22:14:04]

Should this have a crbug reference?

[Nicolas Zea, 2015/08/27 23:37:16]

Good point, done.

+    // For now, we know that the implementation of SyncService is always a
+    // ProfileSyncService at this level.
+    ProfileSyncService* pss = static_cast<ProfileSyncService*>(sync_service);
+    sync_service->RegisterDataTypeController(new SessionDataTypeController(
+        &chrome_sync_client_, profile_, pss->GetSyncedWindowDelegatesGetter(),
+        sync_service->GetLocalDeviceInfoProvider()));
   }
 
   // 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.
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Closure(),
             syncer::FAVICON_IMAGES,
             &chrome_sync_client_));
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Closure(),
             syncer::FAVICON_TRACKING,
             &chrome_sync_client_));
   }
 
   // Password sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::PASSWORDS)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new PasswordDataTypeController(&chrome_sync_client_, profile_));
   }
 
   if (!disabled_types.Has(syncer::PRIORITY_PREFERENCES)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
             syncer::PRIORITY_PREFERENCES,
             &chrome_sync_client_));
   }
 
   // Article sync is disabled by default.  Register only if explicitly enabled.
   if (dom_distiller::IsEnableSyncArticlesSet()) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
             syncer::ARTICLES,
             &chrome_sync_client_));
   }
 
 #if defined(ENABLE_SUPERVISED_USERS)
-  pss->RegisterDataTypeController(
+  sync_service->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
           syncer::SUPERVISED_USER_SETTINGS,
-          this,
+          &chrome_sync_client_,
           profile_));
-  pss->RegisterDataTypeController(
+  sync_service->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
           syncer::SUPERVISED_USER_WHITELISTS,
-          this,
+          &chrome_sync_client_,
           profile_));
 #endif
 }
 
 void ProfileSyncComponentsFactoryImpl::RegisterDesktopDataTypes(
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types,
-    ProfileSyncService* pss) {
+    sync_driver::SyncService* sync_service) {
 #if defined(ENABLE_EXTENSIONS)
   // App sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::APPS)) {
-    pss->RegisterDataTypeController(new ExtensionDataTypeController(
+    sync_service->RegisterDataTypeController(new ExtensionDataTypeController(
         syncer::APPS, &chrome_sync_client_, profile_));
   }
 
   // Extension sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::EXTENSIONS)) {
-    pss->RegisterDataTypeController(new ExtensionDataTypeController(
+    sync_service->RegisterDataTypeController(new ExtensionDataTypeController(
         syncer::EXTENSIONS, &chrome_sync_client_, profile_));
   }
 #endif
 
   // Preference sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::PREFERENCES)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
             syncer::PREFERENCES,
             &chrome_sync_client_));
   }
 
 #if defined(ENABLE_THEMES)
   // Theme sync is enabled by default.  Register unless explicitly disabled.
   if (!disabled_types.Has(syncer::THEMES)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new ThemeDataTypeController(&chrome_sync_client_, profile_));
   }
 #endif
 
   // Search Engine sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::SEARCH_ENGINES)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new SearchEngineDataTypeController(&chrome_sync_client_, profile_));
   }
 
 #if defined(ENABLE_EXTENSIONS)
   // Extension setting sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::EXTENSION_SETTINGS)) {
-    pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
-        syncer::EXTENSION_SETTINGS, &chrome_sync_client_, profile_));
+    sync_service->RegisterDataTypeController(
+        new ExtensionSettingDataTypeController(syncer::EXTENSION_SETTINGS,
+                                               &chrome_sync_client_, profile_));
   }
 
   // App setting sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::APP_SETTINGS)) {
-    pss->RegisterDataTypeController(new ExtensionSettingDataTypeController(
-        syncer::APP_SETTINGS, &chrome_sync_client_, profile_));
+    sync_service->RegisterDataTypeController(
+        new ExtensionSettingDataTypeController(syncer::APP_SETTINGS,
+                                               &chrome_sync_client_, profile_));
   }
 #endif
 
 #if defined(ENABLE_APP_LIST)
   if (app_list::switches::IsAppListSyncEnabled()) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
             syncer::APP_LIST,
             &chrome_sync_client_));
   }
 #endif
 
 #if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_CHROMEOS)
   // Dictionary sync is enabled by default.
   if (!disabled_types.Has(syncer::DICTIONARY)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
             syncer::DICTIONARY,
             &chrome_sync_client_));
   }
 #endif
 
 #if defined(ENABLE_SUPERVISED_USERS)
-  pss->RegisterDataTypeController(
+  sync_service->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
           syncer::SUPERVISED_USERS,
-          this,
+          &chrome_sync_client_,
           profile_));
-  pss->RegisterDataTypeController(
+  sync_service->RegisterDataTypeController(
       new SupervisedUserSyncDataTypeController(
           syncer::SUPERVISED_USER_SHARED_SETTINGS,
-          this,
+          &chrome_sync_client_,
           profile_));
 #endif
 
 #if defined(OS_CHROMEOS)
   if (command_line_->HasSwitch(switches::kEnableWifiCredentialSync) &&
       !disabled_types.Has(syncer::WIFI_CREDENTIALS)) {
-    pss->RegisterDataTypeController(
+    sync_service->RegisterDataTypeController(
         new UIDataTypeController(
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
             base::Bind(&ChromeReportUnrecoverableError),
             syncer::WIFI_CREDENTIALS,
             &chrome_sync_client_));
   }
 #endif
 }
 
 DataTypeManager* ProfileSyncComponentsFactoryImpl::CreateDataTypeManager(
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const DataTypeController::TypeMap* controllers,
     const sync_driver::DataTypeEncryptionHandler* encryption_handler,
     SyncBackendHost* backend,
     DataTypeManagerObserver* observer) {
   return new DataTypeManagerImpl(base::Bind(ChromeReportUnrecoverableError),
                                  debug_info_listener,
                                  controllers,
                                  encryption_handler,
                                  backend,
                                  observer);
 }
 
 browser_sync::SyncBackendHost*
 ProfileSyncComponentsFactoryImpl::CreateSyncBackendHost(
     const std::string& name,
-    Profile* profile,
     invalidation::InvalidationService* invalidator,
     const base::WeakPtr<sync_driver::SyncPrefs>& sync_prefs,
     const base::FilePath& sync_folder) {
-  return new browser_sync::SyncBackendHostImpl(name, profile, invalidator,
+  return new browser_sync::SyncBackendHostImpl(name, profile_, invalidator,
                                                sync_prefs, sync_folder);
 }
 
 scoped_ptr<sync_driver::LocalDeviceInfoProvider>
 ProfileSyncComponentsFactoryImpl::CreateLocalDeviceInfoProvider() {
   return scoped_ptr<sync_driver::LocalDeviceInfoProvider>(
       new browser_sync::LocalDeviceInfoProviderImpl());
 }
 
 class TokenServiceProvider
@@ skipping 26 matching lines @@
 
 scoped_refptr<base::SingleThreadTaskRunner>
 TokenServiceProvider::GetTokenServiceTaskRunner() {
   return task_runner_;
 }
 
 OAuth2TokenService* TokenServiceProvider::GetTokenService() {
   return token_service_;
 }
 
-base::WeakPtr<syncer::SyncableService>
-ProfileSyncComponentsFactoryImpl::GetSyncableServiceForType(
-    syncer::ModelType type) {
-  return chrome_sync_client_.GetSyncableServiceForType(type);
-}
-
 scoped_ptr<syncer::AttachmentService>
 ProfileSyncComponentsFactoryImpl::CreateAttachmentService(
     scoped_ptr<syncer::AttachmentStoreForSync> attachment_store,
     const syncer::UserShare& user_share,
     const std::string& store_birthday,
     syncer::ModelType model_type,
     syncer::AttachmentService::Delegate* delegate) {
   scoped_ptr<syncer::AttachmentUploader> attachment_uploader;
   scoped_ptr<syncer::AttachmentDownloader> attachment_downloader;
   // Only construct an AttachmentUploader and AttachmentDownload if we have sync
@@ skipping 34 matching lines @@
       base::TimeDelta::FromMinutes(30);
   const base::TimeDelta max_backoff_delay = base::TimeDelta::FromHours(4);
   scoped_ptr<syncer::AttachmentService> attachment_service(
       new syncer::AttachmentServiceImpl(
           attachment_store.Pass(), attachment_uploader.Pass(),
           attachment_downloader.Pass(), delegate, initial_backoff_delay,
           max_backoff_delay));
   return attachment_service.Pass();
 }
 
-ProfileSyncComponentsFactory::SyncComponents
+sync_driver::SyncApiComponentFactory::SyncComponents
     ProfileSyncComponentsFactoryImpl::CreateBookmarkSyncComponents(
-        ProfileSyncService* profile_sync_service,
+        sync_driver::SyncService* sync_service,
         sync_driver::DataTypeErrorHandler* error_handler) {
   BookmarkModel* bookmark_model =
-      BookmarkModelFactory::GetForProfile(profile_sync_service->profile());
-  syncer::UserShare* user_share = profile_sync_service->GetUserShare();
+      BookmarkModelFactory::GetForProfile(profile_);
+  syncer::UserShare* user_share = sync_service->GetUserShare();
   // TODO(akalin): We may want to propagate this switch up eventually.
 #if defined(OS_ANDROID)
   const bool kExpectMobileBookmarksFolder = true;
 #else
   const bool kExpectMobileBookmarksFolder = false;
 #endif
   BookmarkModelAssociator* model_associator =
       new BookmarkModelAssociator(bookmark_model,
-                                  profile_sync_service->profile(),
+                                  profile_,
                                   user_share,
                                   error_handler,
                                   kExpectMobileBookmarksFolder);
   BookmarkChangeProcessor* change_processor =
-      new BookmarkChangeProcessor(profile_sync_service->profile(),
+      new BookmarkChangeProcessor(profile_,
                                   model_associator,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }
 
-ProfileSyncComponentsFactory::SyncComponents
+sync_driver::SyncApiComponentFactory::SyncComponents
     ProfileSyncComponentsFactoryImpl::CreateTypedUrlSyncComponents(
-        ProfileSyncService* profile_sync_service,
+        sync_driver::SyncService* sync_service,
         history::HistoryBackend* history_backend,
         sync_driver::DataTypeErrorHandler* error_handler) {
+  // TODO(zea): Once TypedURLs are converted to SyncableService, remove
+  // |sync_service_| member, and make GetSyncService require it be called on
+  // the UI thread.
   TypedUrlModelAssociator* model_associator =
-      new TypedUrlModelAssociator(profile_sync_service,
+      new TypedUrlModelAssociator(sync_service,
                                   history_backend,
                                   error_handler);
   TypedUrlChangeProcessor* change_processor =
       new TypedUrlChangeProcessor(profile_,
                                   model_associator,
                                   history_backend,
                                   error_handler);
   return SyncComponents(model_associator, change_processor);
 }