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

components/sync/driver/fake_data_type_controller.cc

Index: components/sync/driver/fake_data_type_controller.cc
diff --git a/components/sync/driver/fake_data_type_controller.cc b/components/sync/driver/fake_data_type_controller.cc
index 45e8fbee8aa49f7850524452ff064e69ebf2fc4e..f2248fff47567e9e5cce7ac8ae39dec6477ef5c2 100644
--- a/components/sync/driver/fake_data_type_controller.cc
+++ b/components/sync/driver/fake_data_type_controller.cc
@@ -12,9 +12,7 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using syncer::ModelType;
-
-namespace sync_driver {
+namespace syncer {
 
 FakeDataTypeController::FakeDataTypeController(ModelType type)
     : DirectoryDataTypeController(type, base::Closure(), nullptr),
@@ -75,24 +73,23 @@ void FakeDataTypeController::FinishStart(ConfigureResult result) {
   }
 
   // Set |state_| first below since the callback may call state().
-  syncer::SyncMergeResult local_merge_result(type());
-  syncer::SyncMergeResult syncer_merge_result(type());
+  SyncMergeResult local_merge_result(type());
+  SyncMergeResult syncer_merge_result(type());
   if (result <= OK_FIRST_RUN) {
     state_ = RUNNING;
   } else if (result == ASSOCIATION_FAILED) {
     state_ = DISABLED;
-    local_merge_result.set_error(
-        syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                          "Association failed", type()));
+    local_merge_result.set_error(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
+                                           "Association failed", type()));
   } else if (result == UNRECOVERABLE_ERROR) {
     state_ = NOT_RUNNING;
-    local_merge_result.set_error(
-        syncer::SyncError(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR,
-                          "Unrecoverable error", type()));
+    local_merge_result.set_error(SyncError(FROM_HERE,
+                                           SyncError::UNRECOVERABLE_ERROR,
+                                           "Unrecoverable error", type()));
   } else if (result == NEEDS_CRYPTO) {
     state_ = NOT_RUNNING;
-    local_merge_result.set_error(syncer::SyncError(
-        FROM_HERE, syncer::SyncError::CRYPTO_ERROR, "Crypto error", type()));
+    local_merge_result.set_error(
+        SyncError(FROM_HERE, SyncError::CRYPTO_ERROR, "Crypto error", type()));
   } else {
     NOTREACHED();
   }
@@ -115,8 +112,8 @@ std::string FakeDataTypeController::name() const {
   return ModelTypeToString(type());
 }
 
-syncer::ModelSafeGroup FakeDataTypeController::model_safe_group() const {
-  return syncer::GROUP_PASSIVE;
+ModelSafeGroup FakeDataTypeController::model_safe_group() const {
+  return GROUP_PASSIVE;
 }
 
 ChangeProcessor* FakeDataTypeController::GetChangeProcessor() const {
@@ -135,7 +132,7 @@ void FakeDataTypeController::SetDelayModelLoad() {
   model_load_delayed_ = true;
 }
 
-void FakeDataTypeController::SetModelLoadError(syncer::SyncError error) {
+void FakeDataTypeController::SetModelLoadError(SyncError error) {
   load_error_ = error;
 }
 
@@ -155,12 +152,12 @@ void FakeDataTypeController::SetShouldLoadModelBeforeConfigure(bool value) {
   should_load_model_before_configure_ = value;
 }
 
-std::unique_ptr<syncer::DataTypeErrorHandler>
+std::unique_ptr<DataTypeErrorHandler>
 FakeDataTypeController::CreateErrorHandler() {
   DCHECK(CalledOnValidThread());
-  return base::MakeUnique<syncer::DataTypeErrorHandlerImpl>(
+  return base::MakeUnique<DataTypeErrorHandlerImpl>(
       base::ThreadTaskRunnerHandle::Get(), base::Closure(),
       base::Bind(model_load_callback_, type()));
 }
 
-}  // namespace sync_driver
+}  // namespace syncer