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_unittest.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/non_ui_data_type_controller.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "components/sync/api/fake_syncable_service.h"
 #include "components/sync/api/sync_change.h"
 #include "components/sync/driver/data_type_controller_mock.h"
 #include "components/sync/driver/fake_sync_client.h"
 #include "components/sync/driver/generic_change_processor_factory.h"
 #include "components/sync/driver/non_ui_data_type_controller_mock.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncer {
+namespace sync_driver {
 
 class SyncClient;
 
 namespace {
 
 using base::WaitableEvent;
+using syncer::AUTOFILL_PROFILE;
 using testing::_;
 using testing::AtLeast;
 using testing::DoAll;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 
-const ModelType kType = AUTOFILL_PROFILE;
+const syncer::ModelType kType = AUTOFILL_PROFILE;
 
 ACTION_P(WaitOnEvent, event) {
   event->Wait();
 }
 
 ACTION_P(SignalEvent, event) {
   event->Signal();
 }
 
 ACTION_P(SaveChangeProcessor, scoped_change_processor) {
   scoped_change_processor->reset(arg2);
 }
 
 class SharedChangeProcessorMock : public SharedChangeProcessor {
  public:
-  explicit SharedChangeProcessorMock(ModelType type)
+  explicit SharedChangeProcessorMock(syncer::ModelType type)
       : SharedChangeProcessor(type) {}
 
-  base::WeakPtr<SyncableService> Connect(
+  base::WeakPtr<syncer::SyncableService> Connect(
       SyncClient*,
       GenericChangeProcessorFactory*,
-      UserShare*,
-      std::unique_ptr<DataTypeErrorHandler>,
-      const base::WeakPtr<SyncMergeResult>&) {
+      syncer::UserShare*,
+      std::unique_ptr<syncer::DataTypeErrorHandler>,
+      const base::WeakPtr<syncer::SyncMergeResult>&) {
     return std::move(connect_return_);
   }
   MOCK_METHOD0(Disconnect, bool());
   MOCK_METHOD2(ProcessSyncChanges,
-               SyncError(const tracked_objects::Location&,
-                         const SyncChangeList&));
+               syncer::SyncError(const tracked_objects::Location&,
+                                 const syncer::SyncChangeList&));
   MOCK_CONST_METHOD2(GetAllSyncDataReturnError,
-                     SyncError(ModelType, SyncDataList*));
+                     syncer::SyncError(syncer::ModelType,
+                                       syncer::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<SyncableService> service) {
+  void SetConnectReturn(base::WeakPtr<syncer::SyncableService> service) {
     connect_return_ = service;
   }
 
  protected:
   virtual ~SharedChangeProcessorMock() { DCHECK(!connect_return_); }
   MOCK_METHOD2(OnUnrecoverableError,
                void(const tracked_objects::Location&, const std::string&));
 
  private:
-  base::WeakPtr<SyncableService> connect_return_;
+  base::WeakPtr<syncer::SyncableService> connect_return_;
   DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessorMock);
 };
 
 class NonUIDataTypeControllerFake : public NonUIDataTypeController {
  public:
   NonUIDataTypeControllerFake(
       SyncClient* sync_client,
       NonUIDataTypeControllerMock* mock,
       SharedChangeProcessor* change_processor,
       scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner)
       : NonUIDataTypeController(kType, base::Closure(), sync_client),
         blocked_(false),
         mock_(mock),
         change_processor_(change_processor),
         backend_task_runner_(backend_task_runner) {}
   ~NonUIDataTypeControllerFake() override {}
 
-  ModelSafeGroup model_safe_group() const override { return GROUP_DB; }
+  syncer::ModelSafeGroup model_safe_group() const override {
+    return syncer::GROUP_DB;
+  }
 
   // Prevent tasks from being posted on the backend thread until
   // UnblockBackendTasks() is called.
   void BlockBackendTasks() { blocked_ = true; }
 
   // Post pending tasks on the backend thread and start allowing tasks
   // to be posted on the backend thread again.
   void UnblockBackendTasks() {
     blocked_ = false;
     for (std::vector<PendingTask>::const_iterator it = pending_tasks_.begin();
          it != pending_tasks_.end(); ++it) {
       PostTaskOnBackendThread(it->from_here, it->task);
     }
     pending_tasks_.clear();
   }
 
   SharedChangeProcessor* CreateSharedChangeProcessor() override {
     return change_processor_.get();
   }
 
-  std::unique_ptr<DataTypeErrorHandler> CreateErrorHandler() override {
+  std::unique_ptr<syncer::DataTypeErrorHandler> CreateErrorHandler() override {
     return NonUIDataTypeController::CreateErrorHandler();
   }
 
  protected:
   bool PostTaskOnBackendThread(const tracked_objects::Location& from_here,
                                const base::Closure& task) override {
     if (blocked_) {
       pending_tasks_.push_back(PendingTask(from_here, task));
       return true;
     } else {
@@ skipping 70 matching lines @@
     EXPECT_CALL(model_load_callback_, Run(_, _));
   }
 
   void SetAssociateExpectations() {
     change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr());
     EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
         .WillOnce(Return(true));
     EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
         .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
     EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-        .WillOnce(Return(SyncError()));
+        .WillOnce(Return(syncer::SyncError()));
     EXPECT_CALL(*change_processor_.get(), GetSyncCount()).WillOnce(Return(0));
     EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_));
   }
 
   void SetActivateExpectations(DataTypeController::ConfigureResult result) {
     EXPECT_CALL(start_callback_, Run(result, _, _));
   }
 
   void SetStopExpectations() {
     EXPECT_CALL(*dtc_mock_.get(), StopModels());
@@ skipping 14 matching lines @@
   }
 
   static void SignalDone(WaitableEvent* done) { done->Signal(); }
 
   base::MessageLoopForUI message_loop_;
   base::Thread backend_thread_;
 
   StartCallbackMock start_callback_;
   ModelLoadCallbackMock model_load_callback_;
   // Must be destroyed after non_ui_dtc_.
-  FakeSyncableService syncable_service_;
+  syncer::FakeSyncableService syncable_service_;
   std::unique_ptr<NonUIDataTypeControllerFake> non_ui_dtc_;
   std::unique_ptr<NonUIDataTypeControllerMock> dtc_mock_;
   scoped_refptr<SharedChangeProcessorMock> change_processor_;
-  std::unique_ptr<SyncChangeProcessor> saved_change_processor_;
+  std::unique_ptr<syncer::SyncChangeProcessor> saved_change_processor_;
 };
 
 TEST_F(SyncNonUIDataTypeControllerTest, StartOk) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) {
   SetStartExpectations();
   change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr());
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillOnce(Return(true));
   EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true)));
   EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-      .WillOnce(Return(SyncError()));
+      .WillOnce(Return(syncer::SyncError()));
   EXPECT_CALL(*change_processor_.get(), RecordAssociationTime(_));
   SetActivateExpectations(DataTypeController::OK_FIRST_RUN);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 }
 
 // Start the DTC and have StartModels() return false.  Then, stop the
 // DTC without finishing model startup.  It should stop cleanly.
@@ skipping 13 matching lines @@
 // The DTC should become disabled, and the DTC should still stop
 // cleanly.
 TEST_F(SyncNonUIDataTypeControllerTest, StartAssociationFailed) {
   SetStartExpectations();
   change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr());
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillOnce(Return(true));
   EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
   EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-      .WillOnce(Return(SyncError()));
+      .WillOnce(Return(syncer::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(SyncError(
-      FROM_HERE, SyncError::DATATYPE_ERROR, "Sync Error", non_ui_dtc_->type()));
+  syncable_service_.set_merge_data_and_start_syncing_error(
+      syncer::SyncError(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
+                        "Sync Error", non_ui_dtc_->type()));
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::DISABLED, non_ui_dtc_->state());
   non_ui_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest,
        StartAssociationTriggersUnrecoverableError) {
   SetStartExpectations();
@@ skipping 35 matching lines @@
 
   SetStartExpectations();
   change_processor_->SetConnectReturn(syncable_service_.AsWeakPtr());
   EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
       .WillOnce(Return(true));
   EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
       .WillOnce(DoAll(SignalEvent(&wait_for_db_thread_pause),
                       WaitOnEvent(&pause_db_thread),
                       SetArgumentPointee<0>(true), Return(true)));
   EXPECT_CALL(*change_processor_.get(), GetAllSyncDataReturnError(_, _))
-      .WillOnce(Return(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
-                                 "Disconnected.", kType)));
+      .WillOnce(
+          Return(syncer::SyncError(FROM_HERE, syncer::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)));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   wait_for_db_thread_pause.Wait();
   non_ui_dtc_->Stop();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
@@ skipping 62 matching lines @@
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 
   testing::Mock::VerifyAndClearExpectations(&start_callback_);
   EXPECT_CALL(model_load_callback_, Run(_, _));
-  SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR, "error",
-                  non_ui_dtc_->type());
+  syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR, "error",
+                          non_ui_dtc_->type());
   backend_thread_.task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&DataTypeErrorHandler::OnUnrecoverableError,
+      base::Bind(&syncer::DataTypeErrorHandler::OnUnrecoverableError,
                  base::Passed(non_ui_dtc_->CreateErrorHandler()), error));
   WaitForDTC();
 }
 
 }  // namespace
 
-}  // namespace syncer
+}  // namespace sync_driver