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

components/sync/driver/fake_data_type_controller.cc

 // Copyright 2014 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/sync/driver/fake_data_type_controller.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/api/data_type_error_handler_impl.h"
 #include "components/sync/api/sync_merge_result.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncer {
+using syncer::ModelType;
+
+namespace sync_driver {
 
 FakeDataTypeController::FakeDataTypeController(ModelType type)
     : DirectoryDataTypeController(type, base::Closure(), nullptr),
       state_(NOT_RUNNING),
       model_load_delayed_(false),
       ready_for_start_(true),
       should_load_model_before_configure_(false),
       register_with_backend_call_count_(0) {}
 
 FakeDataTypeController::~FakeDataTypeController() {}
@@ skipping 40 matching lines @@
 // (depending on |result|)
 void FakeDataTypeController::FinishStart(ConfigureResult result) {
   DCHECK(CalledOnValidThread());
   // We should have a callback from Start().
   if (last_start_callback_.is_null()) {
     ADD_FAILURE();
     return;
   }
 
   // Set |state_| first below since the callback may call state().
-  SyncMergeResult local_merge_result(type());
-  SyncMergeResult syncer_merge_result(type());
+  syncer::SyncMergeResult local_merge_result(type());
+  syncer::SyncMergeResult syncer_merge_result(type());
   if (result <= OK_FIRST_RUN) {
     state_ = RUNNING;
   } else if (result == ASSOCIATION_FAILED) {
     state_ = DISABLED;
-    local_merge_result.set_error(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
-                                           "Association failed", type()));
+    local_merge_result.set_error(
+        syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
+                          "Association failed", type()));
   } else if (result == UNRECOVERABLE_ERROR) {
     state_ = NOT_RUNNING;
-    local_merge_result.set_error(SyncError(FROM_HERE,
-                                           SyncError::UNRECOVERABLE_ERROR,
-                                           "Unrecoverable error", type()));
+    local_merge_result.set_error(
+        syncer::SyncError(FROM_HERE, syncer::SyncError::UNRECOVERABLE_ERROR,
+                          "Unrecoverable error", type()));
   } else if (result == NEEDS_CRYPTO) {
     state_ = NOT_RUNNING;
-    local_merge_result.set_error(
-        SyncError(FROM_HERE, SyncError::CRYPTO_ERROR, "Crypto error", type()));
+    local_merge_result.set_error(syncer::SyncError(
+        FROM_HERE, syncer::SyncError::CRYPTO_ERROR, "Crypto error", type()));
   } else {
     NOTREACHED();
   }
   last_start_callback_.Run(result, local_merge_result, syncer_merge_result);
 }
 
 // * -> NOT_RUNNING
 void FakeDataTypeController::Stop() {
   DCHECK(CalledOnValidThread());
   if (!model_load_callback_.is_null()) {
     // Real data type controllers run the callback and specify "ABORTED" as an
     // error.  We should probably find a way to use the real code and mock out
     // unnecessary pieces.
     SimulateModelLoadFinishing();
   }
   state_ = NOT_RUNNING;
 }
 
 std::string FakeDataTypeController::name() const {
   return ModelTypeToString(type());
 }
 
-ModelSafeGroup FakeDataTypeController::model_safe_group() const {
-  return GROUP_PASSIVE;
+syncer::ModelSafeGroup FakeDataTypeController::model_safe_group() const {
+  return syncer::GROUP_PASSIVE;
 }
 
 ChangeProcessor* FakeDataTypeController::GetChangeProcessor() const {
   return NULL;
 }
 
 DataTypeController::State FakeDataTypeController::state() const {
   return state_;
 }
 
 bool FakeDataTypeController::ReadyForStart() const {
   return ready_for_start_;
 }
 
 void FakeDataTypeController::SetDelayModelLoad() {
   model_load_delayed_ = true;
 }
 
-void FakeDataTypeController::SetModelLoadError(SyncError error) {
+void FakeDataTypeController::SetModelLoadError(syncer::SyncError error) {
   load_error_ = error;
 }
 
 void FakeDataTypeController::SimulateModelLoadFinishing() {
   if (load_error_.IsSet())
     state_ = DISABLED;
   else
     state_ = MODEL_LOADED;
   model_load_callback_.Run(type(), load_error_);
 }
 
 void FakeDataTypeController::SetReadyForStart(bool ready) {
   ready_for_start_ = ready;
 }
 
 void FakeDataTypeController::SetShouldLoadModelBeforeConfigure(bool value) {
   should_load_model_before_configure_ = value;
 }
 
-std::unique_ptr<DataTypeErrorHandler>
+std::unique_ptr<syncer::DataTypeErrorHandler>
 FakeDataTypeController::CreateErrorHandler() {
   DCHECK(CalledOnValidThread());
-  return base::MakeUnique<DataTypeErrorHandlerImpl>(
+  return base::MakeUnique<syncer::DataTypeErrorHandlerImpl>(
       base::ThreadTaskRunnerHandle::Get(), base::Closure(),
       base::Bind(model_load_callback_, type()));
 }
 
-}  // namespace syncer
+}  // namespace sync_driver