[Sync] Put everything in sync/api into csync namespace

chrome/browser/sync/glue/new_non_frontend_data_type_controller_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/sync/glue/new_non_frontend_data_type_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 188 matching lines @@
 
   void SetAssociateExpectations() {
     EXPECT_CALL(*change_processor_, Connect(_,_,_,_)).
         WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
     EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
         WillOnce(Return(true));
     EXPECT_CALL(*change_processor_, ActivateDataType(_));
     EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
         WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
     EXPECT_CALL(*change_processor_, GetSyncData(_)).
-        WillOnce(Return(SyncError()));
+        WillOnce(Return(csync::SyncError()));
     EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
   }
 
   void SetActivateExpectations(DataTypeController::StartResult result) {
     EXPECT_CALL(start_callback_, Run(result,_));
   }
 
   void SetStopExpectations() {
     EXPECT_CALL(*dtc_mock_, StopModels());
     EXPECT_CALL(*change_processor_, Disconnect()).WillOnce(Return(true));
@@ skipping 23 matching lines @@
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   ProfileMock profile_;
   scoped_ptr<ProfileSyncComponentsFactoryMock> profile_sync_factory_;
   StrictMock<ProfileSyncServiceMock> service_;
   StartCallbackMock start_callback_;
   ModelLoadCallbackMock model_load_callback_;
   // Must be destroyed after new_non_frontend_dtc_.
-  FakeSyncableService syncable_service_;
+  csync::FakeSyncableService syncable_service_;
   scoped_refptr<NewNonFrontendDataTypeControllerFake> new_non_frontend_dtc_;
   scoped_refptr<NewNonFrontendDataTypeControllerMock> dtc_mock_;
   scoped_refptr<SharedChangeProcessorMock> change_processor_;
-  scoped_ptr<SyncChangeProcessor> saved_change_processor_;
+  scoped_ptr<csync::SyncChangeProcessor> saved_change_processor_;
 };
 
 TEST_F(SyncNewNonFrontendDataTypeControllerTest, StartOk) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, new_non_frontend_dtc_->state());
 }
 
 TEST_F(SyncNewNonFrontendDataTypeControllerTest, StartFirstRun) {
   SetStartExpectations();
   EXPECT_CALL(*change_processor_, Connect(_,_,_,_)).
       WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
       WillOnce(Return(true));
   EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true)));
   EXPECT_CALL(*change_processor_, GetSyncData(_)).
-      WillOnce(Return(SyncError()));
+      WillOnce(Return(csync::SyncError()));
   EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
   SetActivateExpectations(DataTypeController::OK_FIRST_RUN);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, new_non_frontend_dtc_->state());
 }
 
 // Start the DTC and have StartModels() return false.  Then, stop the
 // DTC without finishing model startup.  It should stop cleanly.
@@ skipping 19 matching lines @@
 // cleanly.
 TEST_F(SyncNewNonFrontendDataTypeControllerTest, StartAssociationFailed) {
   SetStartExpectations();
   EXPECT_CALL(*change_processor_, Connect(_,_,_,_)).
       WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
       WillOnce(Return(true));
   EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
       WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
   EXPECT_CALL(*change_processor_, GetSyncData(_)).
-      WillOnce(Return(SyncError()));
+      WillOnce(Return(csync::SyncError()));
   EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
   SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED);
   // Set up association to fail with an association failed error.
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
   syncable_service_.set_merge_data_and_start_syncing_error(
-      SyncError(FROM_HERE, "Sync Error", new_non_frontend_dtc_->type()));
+      csync::SyncError(FROM_HERE, "Sync Error", new_non_frontend_dtc_->type()));
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::DISABLED, new_non_frontend_dtc_->state());
   new_non_frontend_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
 }
 
 TEST_F(SyncNewNonFrontendDataTypeControllerTest,
        StartAssociationTriggersUnrecoverableError) {
   SetStartExpectations();
@@ skipping 38 matching lines @@
       WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
   EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
       WillOnce(Return(true));
   EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
       WillOnce(DoAll(
           SignalEvent(&wait_for_db_thread_pause),
           WaitOnEvent(&pause_db_thread),
           SetArgumentPointee<0>(true),
           Return(true)));
   EXPECT_CALL(*change_processor_, GetSyncData(_)).
-      WillOnce(Return(SyncError(FROM_HERE, "Disconnected.", AUTOFILL_PROFILE)));
+      WillOnce(
+          Return(
+              csync::SyncError(FROM_HERE, "Disconnected.", AUTOFILL_PROFILE)));
   EXPECT_CALL(*change_processor_, Disconnect()).
       WillOnce(DoAll(SignalEvent(&pause_db_thread), Return(true)));
   EXPECT_CALL(service_, DeactivateDataType(_));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
   Start();
   wait_for_db_thread_pause.Wait();
   new_non_frontend_dtc_->Stop();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
 }
@@ skipping 16 matching lines @@
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
   Start();
   new_non_frontend_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
   Mock::VerifyAndClearExpectations(&profile_sync_factory_);
   Mock::VerifyAndClearExpectations(&service_);
   Mock::VerifyAndClearExpectations(change_processor_);
   Mock::VerifyAndClearExpectations(dtc_mock_);
 
   EXPECT_CALL(*change_processor_, Connect(_,_,_,_)).
-      WillOnce(Return(base::WeakPtr<SyncableService>()));
+      WillOnce(Return(base::WeakPtr<csync::SyncableService>()));
   new_non_frontend_dtc_->UnblockBackendTasks();
   EXPECT_CALL(*dtc_mock_, RecordUnrecoverableError(_, _));
   WaitForDTC();
 }
 
 TEST_F(SyncNewNonFrontendDataTypeControllerTest, Stop) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   SetStopExpectations();
@@ skipping 54 matching lines @@
       new_non_frontend_dtc_.get(),
       FROM_HERE,
       std::string("Test")));
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, new_non_frontend_dtc_->state());
 }
 
 }  // namespace
 
 }  // namespace browser_sync