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

components/sync/driver/non_ui_data_type_controller.cc

Index: components/sync/driver/non_ui_data_type_controller.cc
diff --git a/components/sync/driver/non_ui_data_type_controller.cc b/components/sync/driver/non_ui_data_type_controller.cc
index 3829b33dfd80a23ad78a97205f3be3087ca6d562..083fef62db8255c6e5a978761f05b37d15215a7d 100644
--- a/components/sync/driver/non_ui_data_type_controller.cc
+++ b/components/sync/driver/non_ui_data_type_controller.cc
@@ -18,14 +18,14 @@
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/driver/sync_service.h"
 
-namespace syncer {
+namespace sync_driver {
 
 SharedChangeProcessor* NonUIDataTypeController::CreateSharedChangeProcessor() {
   return new SharedChangeProcessor(type());
 }
 
 NonUIDataTypeController::NonUIDataTypeController(
-    ModelType type,
+    syncer::ModelType type,
     const base::Closure& dump_stack,
     SyncClient* sync_client)
     : DirectoryDataTypeController(type, dump_stack, sync_client),
@@ -36,9 +36,9 @@ void NonUIDataTypeController::LoadModels(
   DCHECK(CalledOnValidThread());
   model_load_callback_ = model_load_callback;
   if (state() != NOT_RUNNING) {
-    model_load_callback.Run(type(),
-                            SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
-                                      "Model already running", type()));
+    model_load_callback.Run(
+        type(), syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
+                                  "Model already running", type()));
     return;
   }
 
@@ -62,7 +62,7 @@ void NonUIDataTypeController::OnModelLoaded() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, MODEL_STARTING);
   state_ = MODEL_LOADED;
-  model_load_callback_.Run(type(), SyncError());
+  model_load_callback_.Run(type(), syncer::SyncError());
 }
 
 bool NonUIDataTypeController::StartModels() {
@@ -91,11 +91,12 @@ void NonUIDataTypeController::StartAssociating(
 
   start_callback_ = start_callback;
   if (!StartAssociationAsync()) {
-    SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
-                    "Failed to post StartAssociation", type());
-    SyncMergeResult local_merge_result(type());
+    syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
+                            "Failed to post StartAssociation", type());
+    syncer::SyncMergeResult local_merge_result(type());
     local_merge_result.set_error(error);
-    StartDone(ASSOCIATION_FAILED, local_merge_result, SyncMergeResult(type()));
+    StartDone(ASSOCIATION_FAILED, local_merge_result,
+              syncer::SyncMergeResult(type()));
     // StartDone should have cleared the SharedChangeProcessor.
     DCHECK(!shared_change_processor_.get());
     return;
@@ -109,7 +110,7 @@ void NonUIDataTypeController::Stop() {
     return;
 
   // Disconnect the change processor. At this point, the
-  // SyncableService can no longer interact with the Syncer, even if
+  // syncer::SyncableService can no longer interact with the Syncer, even if
   // it hasn't finished MergeDataAndStartSyncing.
   DisconnectSharedChangeProcessor();
 
@@ -127,7 +128,7 @@ void NonUIDataTypeController::Stop() {
 
 std::string NonUIDataTypeController::name() const {
   // For logging only.
-  return ModelTypeToString(type());
+  return syncer::ModelTypeToString(type());
 }
 
 DataTypeController::State NonUIDataTypeController::state() const {
@@ -135,14 +136,16 @@ DataTypeController::State NonUIDataTypeController::state() const {
 }
 
 NonUIDataTypeController::NonUIDataTypeController()
-    : DirectoryDataTypeController(UNSPECIFIED, base::Closure(), nullptr) {}
+    : DirectoryDataTypeController(syncer::UNSPECIFIED,
+                                  base::Closure(),
+                                  nullptr) {}
 
 NonUIDataTypeController::~NonUIDataTypeController() {}
 
 void NonUIDataTypeController::StartDone(
     DataTypeController::ConfigureResult start_result,
-    const SyncMergeResult& local_merge_result,
-    const SyncMergeResult& syncer_merge_result) {
+    const syncer::SyncMergeResult& local_merge_result,
+    const syncer::SyncMergeResult& syncer_merge_result) {
   DCHECK(CalledOnValidThread());
 
   DataTypeController::State new_state;
@@ -180,7 +183,8 @@ void NonUIDataTypeController::StartDone(
 void NonUIDataTypeController::RecordStartFailure(ConfigureResult result) {
   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);
@@ -188,7 +192,7 @@ void NonUIDataTypeController::RecordStartFailure(ConfigureResult result) {
 #undef PER_DATA_TYPE_MACRO
 }
 
-void NonUIDataTypeController::DisableImpl(const SyncError& error) {
+void NonUIDataTypeController::DisableImpl(const syncer::SyncError& error) {
   DCHECK(CalledOnValidThread());
   if (!model_load_callback_.is_null()) {
     model_load_callback_.Run(type(), error);
@@ -202,8 +206,8 @@ bool NonUIDataTypeController::StartAssociationAsync() {
       FROM_HERE,
       base::Bind(
           &SharedChangeProcessor::StartAssociation, shared_change_processor_,
-          BindToCurrentThread(base::Bind(&NonUIDataTypeController::StartDone,
-                                         base::AsWeakPtr(this))),
+          syncer::BindToCurrentThread(base::Bind(
+              &NonUIDataTypeController::StartDone, base::AsWeakPtr(this))),
           sync_client_, user_share_, base::Passed(CreateErrorHandler())));
 }
 
@@ -231,12 +235,12 @@ void NonUIDataTypeController::StopSyncableService() {
   }
 }
 
-std::unique_ptr<DataTypeErrorHandler>
+std::unique_ptr<syncer::DataTypeErrorHandler>
 NonUIDataTypeController::CreateErrorHandler() {
   DCHECK(CalledOnValidThread());
-  return base::MakeUnique<DataTypeErrorHandlerImpl>(
+  return base::MakeUnique<syncer::DataTypeErrorHandlerImpl>(
       base::ThreadTaskRunnerHandle::Get(), dump_stack_,
       base::Bind(&NonUIDataTypeController::DisableImpl, base::AsWeakPtr(this)));
 }
 
-}  // namespace syncer
+}  // namespace sync_driver