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

components/browser_sync/profile_sync_service.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_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 69 matching lines @@
 #include "components/version_info/version_info_values.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
 #if defined(OS_ANDROID)
 #include "components/sync/core/read_transaction.h"
 #endif
 
-using sync_driver::ChangeProcessor;
-using sync_driver::DataTypeController;
-using sync_driver::DataTypeManager;
-using sync_driver::DataTypeStatusTable;
-using sync_driver::DeviceInfoSyncService;
-using sync_driver_v2::DeviceInfoService;
 using sync_sessions::SessionsSyncManager;
-using syncer::ModelType;
-using syncer::ModelTypeSet;
+using syncer::BackendMigrator;
+using syncer::ChangeProcessor;
+using syncer::DataTypeController;
+using syncer::DataTypeManager;
+using syncer::DataTypeStatusTable;
+using syncer::DeviceInfoService;
+using syncer::DeviceInfoSyncService;
 using syncer::JsBackend;
 using syncer::JsController;
 using syncer::JsEventDetails;
 using syncer::JsEventHandler;
 using syncer::ModelSafeRoutingInfo;
+using syncer::ModelType;
+using syncer::ModelTypeSet;
+using syncer::ModelTypeStore;
+using syncer::ProtocolEventObserver;
+using syncer::SharedModelTypeProcessor;
+using syncer::SyncBackendHost;
 using syncer::SyncCredentials;
 using syncer::SyncProtocolError;
 using syncer::WeakHandle;
-using syncer_v2::ModelTypeStore;
-using syncer_v2::SharedModelTypeProcessor;
 
 namespace browser_sync {
 
 typedef GoogleServiceAuthError AuthError;
 
 const char kSyncUnrecoverableErrorHistogram[] = "Sync.UnrecoverableErrors";
 
 const net::BackoffEntry::Policy kRequestAccessTokenBackoffPolicy = {
     // Number of initial errors (in sequence) to ignore before applying
     // exponential back-off rules.
@@ skipping 65 matching lines @@
       file_thread(std::move(other.file_thread)),
       blocking_pool(other.blocking_pool) {}
 
 ProfileSyncService::ProfileSyncService(InitParams init_params)
     : OAuth2TokenService::Consumer("sync"),
       last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       sync_client_(std::move(init_params.sync_client)),
       sync_prefs_(sync_client_->GetPrefService()),
       sync_service_url_(
-          GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
-                            init_params.channel)),
+          syncer::GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
+                                    init_params.channel)),
       network_time_update_callback_(
           std::move(init_params.network_time_update_callback)),
       base_directory_(init_params.base_directory),
       url_request_context_(init_params.url_request_context),
       debug_identifier_(std::move(init_params.debug_identifier)),
       channel_(init_params.channel),
       db_thread_(init_params.db_thread),
       file_thread_(init_params.file_thread),
       blocking_pool_(init_params.blocking_pool),
       is_first_time_sync_configure_(false),
@@ skipping 45 matching lines @@
 
 bool ProfileSyncService::CanSyncStart() const {
   return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
 }
 
 void ProfileSyncService::Initialize() {
   sync_client_->Initialize();
 
   // We don't pass StartupController an Unretained reference to future-proof
   // against the controller impl changing to post tasks.
-  startup_controller_.reset(new StartupController(
+  startup_controller_.reset(new syncer::StartupController(
       &sync_prefs_,
       base::Bind(&ProfileSyncService::CanBackendStart, base::Unretained(this)),
       base::Bind(&ProfileSyncService::StartUpSlowBackendComponents,
                  weak_factory_.GetWeakPtr())));
   std::unique_ptr<sync_sessions::LocalSessionEventRouter> router(
       sync_client_->GetSyncSessionsClient()->GetLocalSessionEventRouter());
   local_device_ = sync_client_->GetSyncApiComponentFactory()
                       ->CreateLocalDeviceInfoProvider();
-  sync_stopped_reporter_.reset(new SyncStoppedReporter(
+  sync_stopped_reporter_.reset(new syncer::SyncStoppedReporter(
       sync_service_url_, local_device_->GetSyncUserAgent(),
-      url_request_context_, SyncStoppedReporter::ResultCallback()));
+      url_request_context_, syncer::SyncStoppedReporter::ResultCallback()));
   sessions_sync_manager_.reset(new SessionsSyncManager(
       sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(),
       std::move(router),
       base::Bind(&ProfileSyncService::NotifyForeignSessionUpdated,
                  sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(&ProfileSyncService::TriggerRefresh,
                  sync_enabled_weak_factory_.GetWeakPtr(),
                  syncer::ModelTypeSet(syncer::SESSIONS))));
 
   if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) {
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner(
         blocking_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
             blocking_pool_->GetSequenceToken(),
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
     // TODO(skym): Stop creating leveldb files when signed out.
     // TODO(skym): Verify using AsUTF8Unsafe is okay here. Should work as long
     // as the Local State file is guaranteed to be UTF-8.
     device_info_service_.reset(new DeviceInfoService(
         local_device_.get(),
         base::Bind(&ModelTypeStore::CreateStore, syncer::DEVICE_INFO,
                    directory_path_.Append(base::FilePath(kLevelDBFolderName))
                        .AsUTF8Unsafe(),
                    blocking_task_runner),
         base::Bind(&SharedModelTypeProcessor::CreateAsChangeProcessor)));
   } else {
     device_info_sync_service_.reset(
         new DeviceInfoSyncService(local_device_.get()));
   }
 
-  sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod
+  syncer::SyncApiComponentFactory::RegisterDataTypesMethod
       register_platform_types_callback =
           sync_client_->GetRegisterPlatformTypesCallback();
   sync_client_->GetSyncApiComponentFactory()->RegisterDataTypes(
       this, register_platform_types_callback);
 
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->AddObserver(this);
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
@@ skipping 41 matching lines @@
   std::string bootstrap_token = sync_prefs_.GetEncryptionBootstrapToken();
   if (bootstrap_token.empty()) {
     sync_prefs_.SetEncryptionBootstrapToken(
         sync_prefs_.GetSpareBootstrapToken());
   }
 #endif
 
 #if !defined(OS_ANDROID)
   DCHECK(sync_error_controller_ == NULL)
       << "Initialize() called more than once.";
-  sync_error_controller_.reset(new SyncErrorController(this));
+  sync_error_controller_.reset(new syncer::SyncErrorController(this));
   AddObserver(sync_error_controller_.get());
 #endif
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&ProfileSyncService::OnMemoryPressure,
                  sync_enabled_weak_factory_.GetWeakPtr())));
   startup_controller_->Reset(GetRegisteredDataTypes());
 
   // Auto-start means means the first time the profile starts up, sync should
   // start up immediately.
@@ skipping 25 matching lines @@
     signin()->AddObserver(this);
 }
 
 void ProfileSyncService::UnregisterAuthNotifications() {
   if (signin())
     signin()->RemoveObserver(this);
   oauth2_token_service_->RemoveObserver(this);
 }
 
 void ProfileSyncService::RegisterDataTypeController(
-    std::unique_ptr<sync_driver::DataTypeController> data_type_controller) {
+    std::unique_ptr<syncer::DataTypeController> data_type_controller) {
   DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       std::move(data_type_controller);
 }
 
 bool ProfileSyncService::IsDataTypeControllerRunning(
     syncer::ModelType type) const {
   DataTypeController::TypeMap::const_iterator iter =
       data_type_controllers_.find(type);
   if (iter == data_type_controllers_.end()) {
     return false;
   }
   return iter->second->state() == DataTypeController::RUNNING;
 }
 
 sync_sessions::OpenTabsUIDelegate* ProfileSyncService::GetOpenTabsUIDelegate() {
   if (!IsDataTypeControllerRunning(syncer::SESSIONS))
     return NULL;
   return sessions_sync_manager_.get();
 }
 
 sync_sessions::FaviconCache* ProfileSyncService::GetFaviconCache() {
   return sessions_sync_manager_->GetFaviconCache();
 }
 
-sync_driver::DeviceInfoTracker* ProfileSyncService::GetDeviceInfoTracker()
-    const {
+syncer::DeviceInfoTracker* ProfileSyncService::GetDeviceInfoTracker() const {
   // One of the two should always be non-null after initialization is done.
   if (device_info_service_) {
     return device_info_service_.get();
   } else {
     return device_info_sync_service_.get();
   }
 }
 
-sync_driver::LocalDeviceInfoProvider*
+syncer::LocalDeviceInfoProvider*
 ProfileSyncService::GetLocalDeviceInfoProvider() const {
   return local_device_.get();
 }
 
 void ProfileSyncService::GetDataTypeControllerStates(
     DataTypeController::StateMap* state_map) const {
   for (DataTypeController::TypeMap::const_iterator iter =
            data_type_controllers_.begin();
        iter != data_type_controllers_.end(); ++iter)
     (*state_map)[iter->first] = iter->second.get()->state();
@@ skipping 47 matching lines @@
                      base::Unretained(network_resources_.get()),
                      url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
       this, std::move(sync_thread_), db_thread_, file_thread_,
       GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
       credentials, delete_stale_data,
       std::unique_ptr<syncer::SyncManagerFactory>(
           new syncer::SyncManagerFactory()),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
-      base::Bind(ChromeReportUnrecoverableError, channel_),
+      base::Bind(syncer::ChromeReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
   DCHECK(encrypted_types.Has(syncer::PASSWORDS));
   return !Intersection(preferred_types, encrypted_types).Empty();
@@ skipping 295 matching lines @@
   if (IsBackendInitialized()) {
     ReconfigureDatatypeManager();
   }
 }
 
 void ProfileSyncService::UpdateLastSyncedTime() {
   sync_prefs_.SetLastSyncedTime(base::Time::Now());
 }
 
 void ProfileSyncService::NotifyObservers() {
-  FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_,
-                    OnStateChanged());
+  FOR_EACH_OBSERVER(syncer::SyncServiceObserver, observers_, OnStateChanged());
 }
 
 void ProfileSyncService::NotifySyncCycleCompleted() {
-  FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_,
+  FOR_EACH_OBSERVER(syncer::SyncServiceObserver, observers_,
                     OnSyncCycleCompleted());
 }
 
 void ProfileSyncService::NotifyForeignSessionUpdated() {
-  FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_,
+  FOR_EACH_OBSERVER(syncer::SyncServiceObserver, observers_,
                     OnForeignSessionUpdated());
 }
 
 void ProfileSyncService::ClearStaleErrors() {
   ClearUnrecoverableError();
   last_actionable_error_ = SyncProtocolError();
   // Clear the data type errors as well.
   if (data_type_manager_.get())
     data_type_manager_->ResetDataTypeErrors();
 }
@@ skipping 466 matching lines @@
       if (is_first_time_sync_configure_) {
         UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceInitialConfigureTime", delta);
       } else {
         UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceSubsequentConfigureTime", delta);
       }
     }
     sync_configure_start_time_ = base::Time();
   }
 
   // Notify listeners that configuration is done.
-  FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_,
+  FOR_EACH_OBSERVER(syncer::SyncServiceObserver, observers_,
                     OnSyncConfigurationCompleted());
 
   DVLOG(1) << "PSS OnConfigureDone called with status: " << configure_status_;
   // The possible status values:
   //    ABORT - Configuration was aborted. This is not an error, if
   //            initiated by user.
   //    OK - Some or all types succeeded.
   //    Everything else is an UnrecoverableError. So treat it as such.
 
   // First handle the abort case.
@@ skipping 125 matching lines @@
 }
 
 bool ProfileSyncService::CanConfigureDataTypes() const {
   return IsFirstSetupComplete() && !IsSetupInProgress();
 }
 
 bool ProfileSyncService::IsFirstSetupInProgress() const {
   return !IsFirstSetupComplete() && startup_controller_->IsSetupInProgress();
 }
 
-std::unique_ptr<sync_driver::SyncSetupInProgressHandle>
+std::unique_ptr<syncer::SyncSetupInProgressHandle>
 ProfileSyncService::GetSetupInProgressHandle() {
   if (++outstanding_setup_in_progress_handles_ == 1) {
     DCHECK(!startup_controller_->IsSetupInProgress());
     startup_controller_->SetSetupInProgress(true);
 
     NotifyObservers();
   }
 
-  return std::unique_ptr<sync_driver::SyncSetupInProgressHandle>(
-      new sync_driver::SyncSetupInProgressHandle(
+  return std::unique_ptr<syncer::SyncSetupInProgressHandle>(
+      new syncer::SyncSetupInProgressHandle(
           base::Bind(&ProfileSyncService::OnSetupInProgressHandleDestroyed,
                      weak_factory_.GetWeakPtr())));
 }
 
 bool ProfileSyncService::IsSyncAllowed() const {
   return IsSyncAllowedByFlag() && !IsManaged() && IsSyncAllowedByPlatform();
 }
 
 bool ProfileSyncService::IsSyncActive() const {
   return backend_initialized_ && data_type_manager_ &&
@@ skipping 67 matching lines @@
     bool sync_everything,
     const syncer::ModelTypeSet chosen_types) const {
   if (!IsFirstSetupComplete() ||
       sync_everything != sync_prefs_.HasKeepEverythingSynced()) {
     UMA_HISTOGRAM_BOOLEAN("Sync.SyncEverything", sync_everything);
   }
 
   // Only log the data types that are shown in the sync settings ui.
   // Note: the order of these types must match the ordering of
   // the respective types in ModelType
-  const sync_driver::user_selectable_type::UserSelectableSyncType
+  const syncer::user_selectable_type::UserSelectableSyncType
       user_selectable_types[] = {
-          sync_driver::user_selectable_type::BOOKMARKS,
-          sync_driver::user_selectable_type::PREFERENCES,
-          sync_driver::user_selectable_type::PASSWORDS,
-          sync_driver::user_selectable_type::AUTOFILL,
-          sync_driver::user_selectable_type::THEMES,
-          sync_driver::user_selectable_type::TYPED_URLS,
-          sync_driver::user_selectable_type::EXTENSIONS,
-          sync_driver::user_selectable_type::APPS,
-          sync_driver::user_selectable_type::PROXY_TABS,
+          syncer::user_selectable_type::BOOKMARKS,
+          syncer::user_selectable_type::PREFERENCES,
+          syncer::user_selectable_type::PASSWORDS,
+          syncer::user_selectable_type::AUTOFILL,
+          syncer::user_selectable_type::THEMES,
+          syncer::user_selectable_type::TYPED_URLS,
+          syncer::user_selectable_type::EXTENSIONS,
+          syncer::user_selectable_type::APPS,
+          syncer::user_selectable_type::PROXY_TABS,
       };
 
   static_assert(39 == syncer::MODEL_TYPE_COUNT,
                 "custom config histogram must be updated");
 
   if (!sync_everything) {
     const syncer::ModelTypeSet current_types = GetPreferredDataTypes();
 
     syncer::ModelTypeSet type_set = syncer::UserSelectableTypes();
     syncer::ModelTypeSet::Iterator it = type_set.First();
 
     DCHECK_EQ(arraysize(user_selectable_types), type_set.Size());
 
     for (size_t i = 0; i < arraysize(user_selectable_types) && it.Good();
          ++i, it.Inc()) {
       const syncer::ModelType type = it.Get();
       if (chosen_types.Has(type) &&
           (!IsFirstSetupComplete() || !current_types.Has(type))) {
         // Selected type has changed - log it.
         UMA_HISTOGRAM_ENUMERATION(
             "Sync.CustomSync", user_selectable_types[i],
-            sync_driver::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1);
+            syncer::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1);
       }
     }
   }
 }
 
 #if defined(OS_CHROMEOS)
 void ProfileSyncService::RefreshSpareBootstrapToken(
     const std::string& passphrase) {
-  sync_driver::SystemEncryptor encryptor;
+  syncer::SystemEncryptor encryptor;
   syncer::Cryptographer temp_cryptographer(&encryptor);
   // The first 2 params (hostname and username) doesn't have any effect here.
   syncer::KeyParams key_params = {"localhost", "dummy", passphrase};
 
   std::string bootstrap_token;
   if (!temp_cryptographer.AddKey(key_params)) {
     NOTREACHED() << "Failed to add key to cryptographer.";
   }
   temp_cryptographer.GetBootstrapToken(&bootstrap_token);
   sync_prefs_.SetSpareBootstrapToken(bootstrap_token);
@@ skipping 31 matching lines @@
 
 syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const {
   if (!IsSyncActive() || !ConfigurationDone())
     return syncer::ModelTypeSet();
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet failed_types =
       data_type_status_table_.GetFailedTypes();
   return Difference(preferred_types, failed_types);
 }
 
-sync_driver::SyncClient* ProfileSyncService::GetSyncClient() const {
+syncer::SyncClient* ProfileSyncService::GetSyncClient() const {
   return sync_client_.get();
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const {
   const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
   const syncer::ModelTypeSet preferred_types =
       Union(sync_prefs_.GetPreferredDataTypes(registered_types),
             syncer::ControlTypes());
   const syncer::ModelTypeSet enforced_types =
       Intersection(GetDataTypesFromPreferenceProviders(), registered_types);
@@ skipping 20 matching lines @@
 }
 
 bool ProfileSyncService::IsUsingSecondaryPassphrase() const {
   syncer::PassphraseType passphrase_type = GetPassphraseType();
   return passphrase_type ==
              syncer::PassphraseType::FROZEN_IMPLICIT_PASSPHRASE ||
          passphrase_type == syncer::PassphraseType::CUSTOM_PASSPHRASE;
 }
 
 std::string ProfileSyncService::GetCustomPassphraseKey() const {
-  sync_driver::SystemEncryptor encryptor;
+  syncer::SystemEncryptor encryptor;
   syncer::Cryptographer cryptographer(&encryptor);
   cryptographer.Bootstrap(sync_prefs_.GetEncryptionBootstrapToken());
   return cryptographer.GetDefaultNigoriKeyData();
 }
 
 syncer::PassphraseType ProfileSyncService::GetPassphraseType() const {
   return backend_->GetPassphraseType();
 }
 
 base::Time ProfileSyncService::GetExplicitPassphraseTime() const {
@@ skipping 368 matching lines @@
       cookie_jar_mismatch = false;
       break;
     }
   }
 
   DVLOG(1) << "Cookie jar mismatch: " << cookie_jar_mismatch;
   DVLOG(1) << "Cookie jar empty: " << cookie_jar_empty;
   backend_->OnCookieJarChanged(cookie_jar_mismatch, cookie_jar_empty);
 }
 
-void ProfileSyncService::AddObserver(
-    sync_driver::SyncServiceObserver* observer) {
+void ProfileSyncService::AddObserver(syncer::SyncServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void ProfileSyncService::RemoveObserver(
-    sync_driver::SyncServiceObserver* observer) {
+void ProfileSyncService::RemoveObserver(syncer::SyncServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void ProfileSyncService::AddProtocolEventObserver(
     ProtocolEventObserver* observer) {
   protocol_event_observers_.AddObserver(observer);
   if (HasSyncingBackend()) {
     backend_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 }
@@ skipping 19 matching lines @@
 void ProfileSyncService::RemoveTypeDebugInfoObserver(
     syncer::TypeDebugInfoObserver* type_debug_info_observer) {
   type_debug_info_observers_.RemoveObserver(type_debug_info_observer);
   if (!type_debug_info_observers_.might_have_observers() &&
       backend_initialized_) {
     backend_->DisableDirectoryTypeDebugInfoForwarding();
   }
 }
 
 void ProfileSyncService::AddPreferenceProvider(
-    SyncTypePreferenceProvider* provider) {
+    syncer::SyncTypePreferenceProvider* provider) {
   DCHECK(!HasPreferenceProvider(provider))
       << "Providers may only be added once!";
   preference_providers_.insert(provider);
 }
 
 void ProfileSyncService::RemovePreferenceProvider(
-    SyncTypePreferenceProvider* provider) {
+    syncer::SyncTypePreferenceProvider* provider) {
   DCHECK(HasPreferenceProvider(provider))
       << "Only providers that have been added before can be removed!";
   preference_providers_.erase(provider);
 }
 
 bool ProfileSyncService::HasPreferenceProvider(
-    SyncTypePreferenceProvider* provider) const {
+    syncer::SyncTypePreferenceProvider* provider) const {
   return preference_providers_.count(provider) > 0;
 }
 
 namespace {
 
 class GetAllNodesRequestHelper
     : public base::RefCountedThreadSafe<GetAllNodesRequestHelper> {
  public:
   GetAllNodesRequestHelper(
       syncer::ModelTypeSet requested_types,
@@ skipping 67 matching lines @@
   }
 
   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
     const auto& dtc_iter = data_type_controllers_.find(it.Get());
     if (dtc_iter != data_type_controllers_.end()) {
       dtc_iter->second->GetAllNodes(base::Bind(
           &GetAllNodesRequestHelper::OnReceivedNodesForType, helper));
     } else {
       // Control Types
       helper->OnReceivedNodesForType(
-          it.Get(), sync_driver::DirectoryDataTypeController::
-                        GetAllNodesForTypeFromDirectory(
-                            it.Get(), GetUserShare()->directory.get()));
+          it.Get(),
+          syncer::DirectoryDataTypeController::GetAllNodesForTypeFromDirectory(
+              it.Get(), GetUserShare()->directory.get()));
     }
   }
 }
 
 bool ProfileSyncService::HasObserver(
-    const sync_driver::SyncServiceObserver* observer) const {
+    const syncer::SyncServiceObserver* observer) const {
   return observers_.HasObserver(observer);
 }
 
 base::WeakPtr<syncer::JsController> ProfileSyncService::GetJsController() {
   return sync_js_controller_.AsWeakPtr();
 }
 
 void ProfileSyncService::SyncEvent(SyncEventCodes code) {
   UMA_HISTOGRAM_ENUMERATION("Sync.EventCodes", code, MAX_SYNC_EVENT_CODE);
 }
@@ skipping 55 matching lines @@
              << "Unrecoverable error.";
   } else {
     DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not "
              << "initialized";
   }
 }
 
 syncer::ModelTypeSet ProfileSyncService::GetDataTypesFromPreferenceProviders()
     const {
   syncer::ModelTypeSet types;
-  for (std::set<SyncTypePreferenceProvider*>::const_iterator it =
+  for (std::set<syncer::SyncTypePreferenceProvider*>::const_iterator it =
            preference_providers_.begin();
        it != preference_providers_.end(); ++it) {
     types.PutAll((*it)->GetPreferredDataTypes());
   }
   return types;
 }
 
 const DataTypeStatusTable& ProfileSyncService::data_type_status_table() const {
   return data_type_status_table_;
 }
@@ skipping 21 matching lines @@
 }
 
 syncer::SyncableService* ProfileSyncService::GetSessionsSyncableService() {
   return sessions_sync_manager_.get();
 }
 
 syncer::SyncableService* ProfileSyncService::GetDeviceInfoSyncableService() {
   return device_info_sync_service_.get();
 }
 
-syncer_v2::ModelTypeService* ProfileSyncService::GetDeviceInfoService() {
+syncer::ModelTypeService* ProfileSyncService::GetDeviceInfoService() {
   return device_info_service_.get();
 }
 
-sync_driver::SyncService::SyncTokenStatus
-ProfileSyncService::GetSyncTokenStatus() const {
+syncer::SyncService::SyncTokenStatus ProfileSyncService::GetSyncTokenStatus()
+    const {
   SyncTokenStatus status;
   status.connection_status_update_time = connection_status_update_time_;
   status.connection_status = connection_status_;
   status.token_request_time = token_request_time_;
   status.token_receive_time = token_receive_time_;
   status.last_get_token_error = last_get_token_error_;
   if (request_access_token_retry_timer_.IsRunning())
     status.next_token_request_time = next_token_request_time_;
   return status;
 }
@@ skipping 107 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync