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

ios/chrome/browser/sync/ios_chrome_sync_client.mm

 // 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 "ios/chrome/browser/sync/ios_chrome_sync_client.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 132 matching lines @@
 
   web_data_service_ =
       ios::WebDataServiceFactory::GetAutofillWebDataForBrowserState(
           browser_state_, ServiceAccessType::EXPLICIT_ACCESS);
   // TODO(crbug.com/558320) Is EXPLICIT_ACCESS appropriate here?
   password_store_ = IOSChromePasswordStoreFactory::GetForBrowserState(
       browser_state_, ServiceAccessType::EXPLICIT_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(), ::GetChannel());
     ProfileOAuth2TokenService* token_service =
         OAuth2TokenServiceFactory::GetForBrowserState(browser_state_);
 
     net::URLRequestContextGetter* url_request_context_getter =
         browser_state_->GetRequestContext();
 
     component_factory_.reset(new browser_sync::ProfileSyncComponentsFactoryImpl(
         this, ::GetChannel(), ::GetVersionString(),
         ui::GetDeviceFormFactor() == ui::DEVICE_FORM_FACTOR_TABLET,
         *base::CommandLine::ForCurrentProcess(),
         prefs::kSavingBrowserHistoryDisabled, sync_service_url,
         web::WebThread::GetTaskRunnerForThread(web::WebThread::UI),
         web::WebThread::GetTaskRunnerForThread(web::WebThread::DB),
         token_service, url_request_context_getter, web_data_service_,
         password_store_));
   }
 }
 
-sync_driver::SyncService* IOSChromeSyncClient::GetSyncService() {
+syncer::SyncService* IOSChromeSyncClient::GetSyncService() {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   return IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state_);
 }
 
 PrefService* IOSChromeSyncClient::GetPrefService() {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   return browser_state_->GetPrefs();
 }
 
 bookmarks::BookmarkModel* IOSChromeSyncClient::GetBookmarkModel() {
@@ skipping 18 matching lines @@
   return autofill::PersonalDataManagerFactory::GetForBrowserState(
       browser_state_);
 }
 
 base::Closure IOSChromeSyncClient::GetPasswordStateChangedCallback() {
   return base::Bind(
       &IOSChromePasswordStoreFactory::OnPasswordsSyncedStatePotentiallyChanged,
       base::Unretained(browser_state_));
 }
 
-sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod
+syncer::SyncApiComponentFactory::RegisterDataTypesMethod
 IOSChromeSyncClient::GetRegisterPlatformTypesCallback() {
   // The iOS port does not have any platform-specific datatypes.
-  return sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod();
+  return syncer::SyncApiComponentFactory::RegisterDataTypesMethod();
 }
 
 BookmarkUndoService* IOSChromeSyncClient::GetBookmarkUndoServiceIfExists() {
   return ios::BookmarkUndoServiceFactory::GetForBrowserStateIfExists(
       browser_state_);
 }
 
 invalidation::InvalidationService*
 IOSChromeSyncClient::GetInvalidationService() {
   invalidation::ProfileInvalidationProvider* provider =
@@ skipping 94 matching lines @@
     case syncer::PASSWORDS: {
       return password_store_ ? password_store_->GetPasswordSyncableService()
                              : base::WeakPtr<syncer::SyncableService>();
     }
     default:
       NOTREACHED();
       return base::WeakPtr<syncer::SyncableService>();
   }
 }
 
-base::WeakPtr<syncer_v2::ModelTypeService>
+base::WeakPtr<syncer::ModelTypeService>
 IOSChromeSyncClient::GetModelTypeServiceForType(syncer::ModelType type) {
   switch (type) {
     case syncer::DEVICE_INFO:
       return IOSChromeProfileSyncServiceFactory::GetForBrowserState(
                  browser_state_)
           ->GetDeviceInfoService()
           ->AsWeakPtr();
     default:
       NOTREACHED();
-      return base::WeakPtr<syncer_v2::ModelTypeService>();
+      return base::WeakPtr<syncer::ModelTypeService>();
   }
 }
 
 scoped_refptr<syncer::ModelSafeWorker>
 IOSChromeSyncClient::CreateModelWorkerForGroup(
     syncer::ModelSafeGroup group,
     syncer::WorkerLoopDestructionObserver* observer) {
   DCHECK_CURRENTLY_ON(web::WebThread::UI);
   switch (group) {
     case syncer::GROUP_DB:
-      return new browser_sync::BrowserThreadModelWorker(
+      return new syncer::BrowserThreadModelWorker(
           web::WebThread::GetTaskRunnerForThread(web::WebThread::DB),
           syncer::GROUP_DB, observer);
     case syncer::GROUP_FILE:
-      return new browser_sync::BrowserThreadModelWorker(
+      return new syncer::BrowserThreadModelWorker(
           web::WebThread::GetTaskRunnerForThread(web::WebThread::FILE),
           syncer::GROUP_FILE, observer);
     case syncer::GROUP_UI:
-      return new browser_sync::UIModelWorker(
+      return new syncer::UIModelWorker(
           web::WebThread::GetTaskRunnerForThread(web::WebThread::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 browser_sync::HistoryModelWorker(
           history_service->AsWeakPtr(),
           web::WebThread::GetTaskRunnerForThread(web::WebThread::UI), observer);
     }
     case syncer::GROUP_PASSWORD: {
       if (!password_store_)
         return nullptr;
       return new browser_sync::PasswordModelWorker(password_store_, observer);
     }
     default:
       return nullptr;
   }
 }
 
-sync_driver::SyncApiComponentFactory*
+syncer::SyncApiComponentFactory*
 IOSChromeSyncClient::GetSyncApiComponentFactory() {
   return component_factory_.get();
 }
 
 void IOSChromeSyncClient::SetSyncApiComponentFactoryForTesting(
-    std::unique_ptr<sync_driver::SyncApiComponentFactory> component_factory) {
+    std::unique_ptr<syncer::SyncApiComponentFactory> component_factory) {
   component_factory_ = std::move(component_factory);
 }
 
 // static
 void IOSChromeSyncClient::GetDeviceInfoTrackers(
-    std::vector<const sync_driver::DeviceInfoTracker*>* trackers) {
+    std::vector<const syncer::DeviceInfoTracker*>* trackers) {
   DCHECK(trackers);
   std::vector<ios::ChromeBrowserState*> browser_state_list =
       GetApplicationContext()
           ->GetChromeBrowserStateManager()
           ->GetLoadedBrowserStates();
   for (ios::ChromeBrowserState* browser_state : browser_state_list) {
     browser_sync::ProfileSyncService* profile_sync_service =
         IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state);
     if (profile_sync_service != nullptr) {
-      const sync_driver::DeviceInfoTracker* tracker =
+      const syncer::DeviceInfoTracker* tracker =
           profile_sync_service->GetDeviceInfoTracker();
       if (tracker != nullptr) {
         trackers->push_back(tracker);
       }
     }
   }
 }