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

components/sync/driver/non_blocking_data_type_controller.cc

Index: components/sync/driver/non_blocking_data_type_controller.cc
diff --git a/components/sync/driver/non_blocking_data_type_controller.cc b/components/sync/driver/non_blocking_data_type_controller.cc
index a01905d7af7ca012dead37a7230d33d9192bc539..c72f31b021741071d63856ece9c1336c10768cf1 100644
--- a/components/sync/driver/non_blocking_data_type_controller.cc
+++ b/components/sync/driver/non_blocking_data_type_controller.cc
@@ -23,13 +23,13 @@
 #include "components/sync/driver/backend_data_type_configurer.h"
 #include "components/sync/driver/sync_client.h"
 
-namespace sync_driver_v2 {
+namespace syncer {
 
 NonBlockingDataTypeController::NonBlockingDataTypeController(
-    syncer::ModelType type,
+    ModelType type,
     const base::Closure& dump_stack,
-    sync_driver::SyncClient* sync_client)
-    : sync_driver::DataTypeController(type, dump_stack),
+    SyncClient* sync_client)
+    : DataTypeController(type, dump_stack),
       sync_client_(sync_client),
       sync_prefs_(sync_client->GetPrefService()),
       state_(NOT_RUNNING) {}
@@ -49,51 +49,47 @@ void NonBlockingDataTypeController::LoadModels(
   model_load_callback_ = model_load_callback;
 
   if (state() != NOT_RUNNING) {
-    LoadModelsDone(
-        RUNTIME_ERROR,
-        syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                          "Model already running", type()));
+    LoadModelsDone(RUNTIME_ERROR,
+                   SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
+                             "Model already running", type()));
     return;
   }
 
   state_ = MODEL_STARTING;
 
   // Callback that posts back to the UI thread.
-  syncer_v2::ModelTypeChangeProcessor::StartCallback callback =
-      syncer::BindToCurrentThread(
-          base::Bind(&NonBlockingDataTypeController::OnProcessorStarted,
-                     base::AsWeakPtr(this)));
+  ModelTypeChangeProcessor::StartCallback callback = BindToCurrentThread(
+      base::Bind(&NonBlockingDataTypeController::OnProcessorStarted,
+                 base::AsWeakPtr(this)));
 
   // Start the type processor on the model thread.
   if (!RunOnModelThread(
           FROM_HERE,
-          base::Bind(&syncer_v2::ModelTypeService::OnSyncStarting,
+          base::Bind(&ModelTypeService::OnSyncStarting,
                      sync_client_->GetModelTypeServiceForType(type()),
                      base::Passed(CreateErrorHandler()), callback))) {
-    LoadModelsDone(
-        UNRECOVERABLE_ERROR,
-        syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                          "Failed to post model Start", type()));
+    LoadModelsDone(UNRECOVERABLE_ERROR,
+                   SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
+                             "Failed to post model Start", type()));
   }
 }
 
 void NonBlockingDataTypeController::GetAllNodes(
     const AllNodesCallback& callback) {
-  base::WeakPtr<syncer_v2::ModelTypeService> service =
+  base::WeakPtr<ModelTypeService> service =
       sync_client_->GetModelTypeServiceForType(type());
   // TODO(gangwu): Casting should happen "near" where the processor factory has
   // code that instantiates a new processor.
-  syncer_v2::SharedModelTypeProcessor* processor =
-      (syncer_v2::SharedModelTypeProcessor*)service->change_processor();
+  SharedModelTypeProcessor* processor =
+      (SharedModelTypeProcessor*)service->change_processor();
   RunOnModelThread(FROM_HERE,
-                   base::Bind(&syncer_v2::SharedModelTypeProcessor::GetAllNodes,
+                   base::Bind(&SharedModelTypeProcessor::GetAllNodes,
                               base::Unretained(processor),
                               base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
-void NonBlockingDataTypeController::LoadModelsDone(
-    ConfigureResult result,
-    const syncer::SyncError& error) {
+void NonBlockingDataTypeController::LoadModelsDone(ConfigureResult result,
+                                                   const SyncError& error) {
   DCHECK(CalledOnValidThread());
 
   if (state_ == NOT_RUNNING) {
@@ -116,8 +112,8 @@ void NonBlockingDataTypeController::LoadModelsDone(
 }
 
 void NonBlockingDataTypeController::OnProcessorStarted(
-    syncer::SyncError error,
-    std::unique_ptr<syncer_v2::ActivationContext> activation_context) {
+    SyncError error,
+    std::unique_ptr<ActivationContext> activation_context) {
   DCHECK(CalledOnValidThread());
   // Hold on to the activation context until ActivateDataType is called.
   if (state_ == MODEL_STARTING) {
@@ -129,7 +125,7 @@ void NonBlockingDataTypeController::OnProcessorStarted(
 }
 
 void NonBlockingDataTypeController::RegisterWithBackend(
-    sync_driver::BackendDataTypeConfigurer* configurer) {
+    BackendDataTypeConfigurer* configurer) {
   DCHECK(CalledOnValidThread());
   if (activated_)
     return;
@@ -149,12 +145,12 @@ void NonBlockingDataTypeController::StartAssociating(
   state_ = RUNNING;
 
   // There is no association, just call back promptly.
-  syncer::SyncMergeResult merge_result(type());
+  SyncMergeResult merge_result(type());
   start_callback.Run(OK, merge_result, merge_result);
 }
 
 void NonBlockingDataTypeController::ActivateDataType(
-    sync_driver::BackendDataTypeConfigurer* configurer) {
+    BackendDataTypeConfigurer* configurer) {
   DCHECK(CalledOnValidThread());
   DCHECK(configurer);
   DCHECK_EQ(RUNNING, state_);
@@ -165,7 +161,7 @@ void NonBlockingDataTypeController::ActivateDataType(
 }
 
 void NonBlockingDataTypeController::DeactivateDataType(
-    sync_driver::BackendDataTypeConfigurer* configurer) {
+    BackendDataTypeConfigurer* configurer) {
   DCHECK(CalledOnValidThread());
   DCHECK(configurer);
   DCHECK(activated_);
@@ -182,13 +178,13 @@ void NonBlockingDataTypeController::Stop() {
   // Check preferences if datatype is not in preferred datatypes. Only call
   // DisableSync if service is ready to handle it (controller is in loaded
   // state).
-  syncer::ModelTypeSet preferred_types =
-      sync_prefs_.GetPreferredDataTypes(syncer::ModelTypeSet(type()));
+  ModelTypeSet preferred_types =
+      sync_prefs_.GetPreferredDataTypes(ModelTypeSet(type()));
   if ((state() == MODEL_LOADED || state() == RUNNING) &&
       (!sync_prefs_.IsFirstSetupComplete() || !preferred_types.Has(type()))) {
     RunOnModelThread(
         FROM_HERE,
-        base::Bind(&syncer_v2::ModelTypeService::DisableSync,
+        base::Bind(&ModelTypeService::DisableSync,
                    sync_client_->GetModelTypeServiceForType(type())));
   }
 
@@ -197,25 +193,24 @@ void NonBlockingDataTypeController::Stop() {
 
 std::string NonBlockingDataTypeController::name() const {
   // For logging only.
-  return syncer::ModelTypeToString(type());
+  return ModelTypeToString(type());
 }
 
-sync_driver::DataTypeController::State NonBlockingDataTypeController::state()
-    const {
+DataTypeController::State NonBlockingDataTypeController::state() const {
   return state_;
 }
 
-std::unique_ptr<syncer::DataTypeErrorHandler>
+std::unique_ptr<DataTypeErrorHandler>
 NonBlockingDataTypeController::CreateErrorHandler() {
   DCHECK(CalledOnValidThread());
-  return base::MakeUnique<syncer::DataTypeErrorHandlerImpl>(
+  return base::MakeUnique<DataTypeErrorHandlerImpl>(
       base::ThreadTaskRunnerHandle::Get(), dump_stack_,
       base::Bind(&NonBlockingDataTypeController::ReportLoadModelError,
                  base::AsWeakPtr(this)));
 }
 
 void NonBlockingDataTypeController::ReportLoadModelError(
-    const syncer::SyncError& error) {
+    const SyncError& error) {
   DCHECK(CalledOnValidThread());
   LoadModelsDone(UNRECOVERABLE_ERROR, error);
 }
@@ -224,8 +219,7 @@ void NonBlockingDataTypeController::RecordStartFailure(
     ConfigureResult result) const {
   DCHECK(CalledOnValidThread());
   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures",
-                            ModelTypeToHistogramInt(type()),
-                            syncer::MODEL_TYPE_COUNT);
+                            ModelTypeToHistogramInt(type()), MODEL_TYPE_COUNT);
 #define PER_DATA_TYPE_MACRO(type_str)                                    \
   UMA_HISTOGRAM_ENUMERATION("Sync." type_str "ConfigureFailure", result, \
                             MAX_CONFIGURE_RESULT);
@@ -233,4 +227,4 @@ void NonBlockingDataTypeController::RecordStartFailure(
 #undef PER_DATA_TYPE_MACRO
 }
 
-}  // namespace sync_driver_v2
+}  // namespace syncer