[Sync] Move //components/sync to the syncer namespace.

chrome/browser/sync/chrome_sync_client.cc

 // Copyright 2015 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/chrome_sync_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 97 matching lines @@
 #include "components/wifi_sync/wifi_credential_syncable_service.h"
 #include "components/wifi_sync/wifi_credential_syncable_service_factory.h"
 #endif
 
 using content::BrowserThread;
 #if defined(ENABLE_EXTENSIONS)
 using browser_sync::ExtensionDataTypeController;
 using browser_sync::ExtensionSettingDataTypeController;
 #endif
 using browser_sync::SearchEngineDataTypeController;
-using sync_driver::UIDataTypeController;
+using syncer::UIDataTypeController;
 
 namespace browser_sync {
 
 // Chrome implementation of SyncSessionsClient. Needs to be in a separate class
 // due to possible multiple inheritance issues, wherein ChromeSyncClient might
 // inherit from other interfaces with same methods.
 class SyncSessionsClientImpl : public sync_sessions::SyncSessionsClient {
  public:
   explicit SyncSessionsClientImpl(Profile* profile) : profile_(profile) {
     window_delegates_getter_.reset(
@@ skipping 64 matching lines @@
 void ChromeSyncClient::Initialize() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   web_data_service_ = WebDataServiceFactory::GetAutofillWebDataForProfile(
       profile_, ServiceAccessType::IMPLICIT_ACCESS);
   password_store_ = PasswordStoreFactory::GetForProfile(
       profile_, ServiceAccessType::IMPLICIT_ACCESS);
 
   // Component factory may already be set in tests.
   if (!GetSyncApiComponentFactory()) {
-    const GURL sync_service_url = GetSyncServiceURL(
+    const GURL sync_service_url = syncer::GetSyncServiceURL(
         *base::CommandLine::ForCurrentProcess(), chrome::GetChannel());
     ProfileOAuth2TokenService* token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
     net::URLRequestContextGetter* url_request_context_getter =
         profile_->GetRequestContext();
 
     component_factory_.reset(new ProfileSyncComponentsFactoryImpl(
         this, chrome::GetChannel(), chrome::GetVersionString(),
         ui::GetDeviceFormFactor() == ui::DEVICE_FORM_FACTOR_TABLET,
         *base::CommandLine::ForCurrentProcess(),
         prefs::kSavingBrowserHistoryDisabled, sync_service_url,
         content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::UI),
         content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::DB),
         token_service, url_request_context_getter, web_data_service_,
         password_store_));
   }
 }
 
-sync_driver::SyncService* ChromeSyncClient::GetSyncService() {
+syncer::SyncService* ChromeSyncClient::GetSyncService() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return ProfileSyncServiceFactory::GetSyncServiceForBrowserContext(profile_);
 }
 
 PrefService* ChromeSyncClient::GetPrefService() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return profile_->GetPrefs();
 }
 
 bookmarks::BookmarkModel* ChromeSyncClient::GetBookmarkModel() {
@@ skipping 17 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return autofill::PersonalDataManagerFactory::GetForProfile(profile_);
 }
 
 base::Closure ChromeSyncClient::GetPasswordStateChangedCallback() {
   return base::Bind(
       &PasswordStoreFactory::OnPasswordsSyncedStatePotentiallyChanged,
       base::Unretained(profile_));
 }
 
-sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod
+syncer::SyncApiComponentFactory::RegisterDataTypesMethod
 ChromeSyncClient::GetRegisterPlatformTypesCallback() {
   return base::Bind(
 #if BUILDFLAG(ANDROID_JAVA_UI)
       &ChromeSyncClient::RegisterAndroidDataTypes,
 #else
       &ChromeSyncClient::RegisterDesktopDataTypes,
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
       weak_ptr_factory_.GetWeakPtr());
 }
 
@@ skipping 147 matching lines @@
 #endif
     default:
       // The following datatypes still need to be transitioned to the
       // syncer::SyncableService API:
       // Bookmarks
       NOTREACHED();
       return base::WeakPtr<syncer::SyncableService>();
   }
 }
 
-base::WeakPtr<syncer_v2::ModelTypeService>
+base::WeakPtr<syncer::ModelTypeService>
 ChromeSyncClient::GetModelTypeServiceForType(syncer::ModelType type) {
   switch (type) {
     case syncer::DEVICE_INFO:
       return ProfileSyncServiceFactory::GetForProfile(profile_)
           ->GetDeviceInfoService()
           ->AsWeakPtr();
     default:
       NOTREACHED();
-      return base::WeakPtr<syncer_v2::ModelTypeService>();
+      return base::WeakPtr<syncer::ModelTypeService>();
   }
 }
 
 scoped_refptr<syncer::ModelSafeWorker>
 ChromeSyncClient::CreateModelWorkerForGroup(
     syncer::ModelSafeGroup group,
     syncer::WorkerLoopDestructionObserver* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   switch (group) {
     case syncer::GROUP_DB:
-      return new BrowserThreadModelWorker(
+      return new syncer::BrowserThreadModelWorker(
           BrowserThread::GetTaskRunnerForThread(BrowserThread::DB),
           syncer::GROUP_DB, observer);
     case syncer::GROUP_FILE:
-      return new BrowserThreadModelWorker(
+      return new syncer::BrowserThreadModelWorker(
           BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE),
           syncer::GROUP_FILE, observer);
     case syncer::GROUP_UI:
-      return new UIModelWorker(
+      return new syncer::UIModelWorker(
           BrowserThread::GetTaskRunnerForThread(BrowserThread::UI), observer);
     case syncer::GROUP_PASSIVE:
       return new syncer::PassiveModelWorker(observer);
     case syncer::GROUP_HISTORY: {
       history::HistoryService* history_service = GetHistoryService();
       if (!history_service)
         return nullptr;
       return new HistoryModelWorker(
           history_service->AsWeakPtr(),
           BrowserThread::GetTaskRunnerForThread(BrowserThread::UI), observer);
     }
     case syncer::GROUP_PASSWORD: {
       if (!password_store_.get())
         return nullptr;
       return new PasswordModelWorker(password_store_, observer);
     }
     default:
       return nullptr;
   }
 }
 
-sync_driver::SyncApiComponentFactory*
+syncer::SyncApiComponentFactory*
 ChromeSyncClient::GetSyncApiComponentFactory() {
   return component_factory_.get();
 }
 
 void ChromeSyncClient::SetSyncApiComponentFactoryForTesting(
-    std::unique_ptr<sync_driver::SyncApiComponentFactory> component_factory) {
+    std::unique_ptr<syncer::SyncApiComponentFactory> component_factory) {
   component_factory_ = std::move(component_factory);
 }
 
 // static
 void ChromeSyncClient::GetDeviceInfoTrackers(
-    std::vector<const sync_driver::DeviceInfoTracker*>* trackers) {
+    std::vector<const syncer::DeviceInfoTracker*>* trackers) {
   DCHECK(trackers);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   std::vector<Profile*> profile_list = profile_manager->GetLoadedProfiles();
   for (Profile* profile : profile_list) {
     const browser_sync::ProfileSyncService* profile_sync_service =
         ProfileSyncServiceFactory::GetForProfile(profile);
     if (profile_sync_service != nullptr) {
-      const sync_driver::DeviceInfoTracker* tracker =
+      const syncer::DeviceInfoTracker* tracker =
           profile_sync_service->GetDeviceInfoTracker();
       if (tracker != nullptr) {
         // Even when sync is disabled and/or user is signed out, a tracker will
         // still be present. It will only be missing when the ProfileSyncService
         // has not sufficiently initialized yet.
         trackers->push_back(tracker);
       }
     }
   }
 }
 
 void ChromeSyncClient::RegisterDesktopDataTypes(
-    sync_driver::SyncService* sync_service,
+    syncer::SyncService* sync_service,
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types) {
   base::Closure error_callback =
-      base::Bind(&ChromeReportUnrecoverableError, chrome::GetChannel());
+      base::Bind(&syncer::ChromeReportUnrecoverableError, chrome::GetChannel());
 
 #if defined(ENABLE_EXTENSIONS)
   // App sync is enabled by default.  Register unless explicitly
   // disabled.
   if (!disabled_types.Has(syncer::APPS)) {
     sync_service->RegisterDataTypeController(
         base::MakeUnique<ExtensionDataTypeController>(
             syncer::APPS, error_callback, this, profile_));
   }
 
@@ skipping 84 matching lines @@
                                                error_callback, this));
   }
   // TODO(lgcheng): Add switch for this.
   sync_service->RegisterDataTypeController(
       base::MakeUnique<ArcPackageSyncDataTypeController>(
           syncer::ARC_PACKAGE, error_callback, this, profile_));
 #endif
 }
 
 void ChromeSyncClient::RegisterAndroidDataTypes(
-    sync_driver::SyncService* sync_service,
+    syncer::SyncService* sync_service,
     syncer::ModelTypeSet disabled_types,
     syncer::ModelTypeSet enabled_types) {
   base::Closure error_callback =
-      base::Bind(&ChromeReportUnrecoverableError, chrome::GetChannel());
+      base::Bind(&syncer::ChromeReportUnrecoverableError, chrome::GetChannel());
 #if defined(ENABLE_SUPERVISED_USERS)
   sync_service->RegisterDataTypeController(
       base::MakeUnique<SupervisedUserSyncDataTypeController>(
           syncer::SUPERVISED_USER_SETTINGS, error_callback, this, profile_));
   sync_service->RegisterDataTypeController(
       base::MakeUnique<SupervisedUserSyncDataTypeController>(
           syncer::SUPERVISED_USER_WHITELISTS, error_callback, this, profile_));
 #endif
 }
 
 }  // namespace browser_sync