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

components/sync/driver/non_ui_data_type_controller_unittest.cc

Index: components/sync/driver/non_ui_data_type_controller_unittest.cc
diff --git a/components/sync/driver/non_ui_data_type_controller_unittest.cc b/components/sync/driver/non_ui_data_type_controller_unittest.cc
index 92d611aa6a63e2bf7c72b6661afa813d6f7d614b..395022ac2181e01acf612f3ea286c41bf58b31f0 100644
--- a/components/sync/driver/non_ui_data_type_controller_unittest.cc
+++ b/components/sync/driver/non_ui_data_type_controller_unittest.cc
@@ -31,14 +31,13 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace sync_driver {
+namespace syncer {
 
 class SyncClient;
 
 namespace {
 
 using base::WaitableEvent;
-using syncer::AUTOFILL_PROFILE;
 using testing::_;
 using testing::AtLeast;
 using testing::DoAll;
@@ -48,7 +47,7 @@ using testing::Return;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 
-const syncer::ModelType kType = AUTOFILL_PROFILE;
+const ModelType kType = AUTOFILL_PROFILE;
 
 ACTION_P(WaitOnEvent, event) {
   event->Wait();
@@ -64,31 +63,30 @@ ACTION_P(SaveChangeProcessor, scoped_change_processor) {
 
 class SharedChangeProcessorMock : public SharedChangeProcessor {
  public:
-  explicit SharedChangeProcessorMock(syncer::ModelType type)
+  explicit SharedChangeProcessorMock(ModelType type)
       : SharedChangeProcessor(type) {}
 
-  base::WeakPtr<syncer::SyncableService> Connect(
+  base::WeakPtr<SyncableService> Connect(
       SyncClient*,
       GenericChangeProcessorFactory*,
-      syncer::UserShare*,
-      std::unique_ptr<syncer::DataTypeErrorHandler>,
-      const base::WeakPtr<syncer::SyncMergeResult>&) {
+      UserShare*,
+      std::unique_ptr<DataTypeErrorHandler>,
+      const base::WeakPtr<SyncMergeResult>&) {
     return std::move(connect_return_);
   }
   MOCK_METHOD0(Disconnect, bool());
   MOCK_METHOD2(ProcessSyncChanges,
-               syncer::SyncError(const tracked_objects::Location&,
-                                 const syncer::SyncChangeList&));
+               SyncError(const tracked_objects::Location&,
+                         const SyncChangeList&));
   MOCK_CONST_METHOD2(GetAllSyncDataReturnError,
-                     syncer::SyncError(syncer::ModelType,
-                                       syncer::SyncDataList*));
+                     SyncError(ModelType, SyncDataList*));
   MOCK_METHOD0(GetSyncCount, int());
   MOCK_METHOD1(SyncModelHasUserCreatedNodes, bool(bool*));
   MOCK_METHOD0(CryptoReadyIfNecessary, bool());
   MOCK_CONST_METHOD1(GetDataTypeContext, bool(std::string*));
   MOCK_METHOD1(RecordAssociationTime, void(base::TimeDelta time));
 
-  void SetConnectReturn(base::WeakPtr<syncer::SyncableService> service) {
+  void SetConnectReturn(base::WeakPtr<SyncableService> service) {
     connect_return_ = service;
   }
 
@@ -98,7 +96,7 @@ class SharedChangeProcessorMock : public SharedChangeProcessor {
                void(const tracked_objects::Location&, const std::string&));
 
  private:
-  base::WeakPtr<syncer::SyncableService> connect_return_;
+  base::WeakPtr<SyncableService> connect_return_;
   DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessorMock);
 };
 
@@ -116,9 +114,7 @@ class NonUIDataTypeControllerFake : public NonUIDataTypeController {
         backend_task_runner_(backend_task_runner) {}
   ~NonUIDataTypeControllerFake() override {}
 
-  syncer::ModelSafeGroup model_safe_group() const override {
-    return syncer::GROUP_DB;
-  }
+  ModelSafeGroup model_safe_group() const override { return GROUP_DB; }
 
   // Prevent tasks from being posted on the backend thread until
   // UnblockBackendTasks() is called.
@@ -139,7 +135,7 @@ class NonUIDataTypeControllerFake : public NonUIDataTypeController {
     return change_processor_.get();
   }
 
-  std::unique_ptr<syncer::DataTypeErrorHandler> CreateErrorHandler() override {
+  std::unique_ptr<DataTypeErrorHandler> CreateErrorHandler() override {
     return NonUIDataTypeController::CreateErrorHandler();
   }
 
@@ -230,7 +226,7 @@ class SyncNonUIDataTypeControllerTest : public testing::Test,
     EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
         .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
     EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-        .WillOnce(Return(syncer::SyncError()));
+        .WillOnce(Return(SyncError()));
     EXPECT_CALL(*change_processor_.get(), GetSyncCount()).WillOnce(Return(0));
     EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_));
   }
@@ -265,11 +261,11 @@ class SyncNonUIDataTypeControllerTest : public testing::Test,
   StartCallbackMock start_callback_;
   ModelLoadCallbackMock model_load_callback_;
   // Must be destroyed after non_ui_dtc_.
-  syncer::FakeSyncableService syncable_service_;
+  FakeSyncableService syncable_service_;
   std::unique_ptr<NonUIDataTypeControllerFake> non_ui_dtc_;
   std::unique_ptr<NonUIDataTypeControllerMock> dtc_mock_;
   scoped_refptr<SharedChangeProcessorMock> change_processor_;
-  std::unique_ptr<syncer::SyncChangeProcessor> saved_change_processor_;
+  std::unique_ptr<SyncChangeProcessor> saved_change_processor_;
 };
 
 TEST_F(SyncNonUIDataTypeControllerTest, StartOk) {
@@ -290,7 +286,7 @@ TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) {
   EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true)));
   EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-      .WillOnce(Return(syncer::SyncError()));
+      .WillOnce(Return(SyncError()));
   EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_));
   SetActivateExpectations(DataTypeController::OK_FIRST_RUN);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
@@ -324,14 +320,13 @@ TEST_F(SyncNonUIDataTypeControllerTest, StartAssociationFailed) {
   EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
   EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-      .WillOnce(Return(syncer::SyncError()));
+      .WillOnce(Return(SyncError()));
   EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_));
   SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED);
   // Set up association to fail with an association failed error.
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
-  syncable_service_.set_merge_data_and_start_syncing_error(
-      syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                        "Sync Error", non_ui_dtc_->type()));
+  syncable_service_.set_merge_data_and_start_syncing_error(SyncError(
+      FROM_HERE, SyncError::DATATYPE_ERROR, "Sync Error", non_ui_dtc_->type()));
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::DISABLED, non_ui_dtc_->state());
@@ -387,9 +382,8 @@ TEST_F(SyncNonUIDataTypeControllerTest, AbortDuringAssociation) {
                       WaitOnEvent(&pause_db_thread),
                       SetArgumentPointee<0>(true), Return(true)));
   EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-      .WillOnce(
-          Return(syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                                   "Disconnected.", kType)));
+      .WillOnce(Return(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
+                                 "Disconnected.", kType)));
   EXPECT_CALL(*dtc_mock_.get(), StopModels());
   EXPECT_CALL(*change_processor_.get(), Disconnect())
       .WillOnce(DoAll(SignalEvent(&pause_db_thread), Return(true)));
@@ -472,15 +466,15 @@ TEST_F(SyncNonUIDataTypeControllerTest, OnUnrecoverableError) {
 
   testing::Mock::VerifyAndClearExpectations(&start_callback_);
   EXPECT_CALL(model_load_callback_, Run(_, _));
-  syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, "error",
-                          non_ui_dtc_->type());
+  SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, "error",
+                  non_ui_dtc_->type());
   backend_thread_.task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&syncer::DataTypeErrorHandler::OnUnrecoverableError,
+      base::Bind(&DataTypeErrorHandler::OnUnrecoverableError,
                  base::Passed(non_ui_dtc_->CreateErrorHandler()), error));
   WaitForDTC();
 }
 
 }  // namespace
 
-}  // namespace sync_driver
+}  // namespace syncer