Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

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