[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/model_association_manager_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 "base/callback.h"
 #include "base/message_loop.h"
 #include "chrome/browser/sync/glue/fake_data_type_controller.h"
 #include "chrome/browser/sync/glue/model_association_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 23 matching lines @@
 }
 
 ACTION_P(VerifyResult, expected_result) {
   EXPECT_EQ(arg0.status, expected_result.status);
   EXPECT_TRUE(arg0.requested_types.Equals(expected_result.requested_types));
   EXPECT_EQ(arg0.failed_data_types.size(),
             expected_result.failed_data_types.size());
 
   if (arg0.failed_data_types.size() ==
           expected_result.failed_data_types.size()) {
-    std::list<csync::SyncError>::const_iterator it1, it2;
+    std::list<syncer::SyncError>::const_iterator it1, it2;
     for (it1 = arg0.failed_data_types.begin(),
          it2 = expected_result.failed_data_types.begin();
          it1 != arg0.failed_data_types.end();
          ++it1, ++it2) {
       EXPECT_EQ((*it1).type(), (*it2).type());
     }
   }
 
   EXPECT_TRUE(arg0.waiting_to_start.Equals(expected_result.waiting_to_start));
 }
@@ skipping 16 matching lines @@
 TEST_F(ModelAssociationManagerTest, SimpleModelStart) {
   controllers_[syncable::BOOKMARKS] =
       new FakeDataTypeController(syncable::BOOKMARKS);
   ModelAssociationManager model_association_manager(&controllers_,
                                                     &result_processor_);
   syncable::ModelTypeSet types;
   types.Put(syncable::BOOKMARKS);
   DataTypeManager::ConfigureResult expected_result(
       DataTypeManager::OK,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       syncable::ModelTypeSet());
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result));
 
   model_association_manager.Initialize(types);
   model_association_manager.StopDisabledTypes();
   model_association_manager.StartAssociationAsync();
 
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::MODEL_LOADED);
   GetController(controllers_, syncable::BOOKMARKS)->FinishStart(
       DataTypeController::OK);
 }
 
 // Start a type and call stop before it finishes associating.
 TEST_F(ModelAssociationManagerTest, StopModelBeforeFinish) {
   controllers_[syncable::BOOKMARKS] =
       new FakeDataTypeController(syncable::BOOKMARKS);
   ModelAssociationManager model_association_manager(&controllers_,
                                                     &result_processor_);
 
   syncable::ModelTypeSet types;
   types.Put(syncable::BOOKMARKS);
 
   DataTypeManager::ConfigureResult expected_result(
       DataTypeManager::ABORTED,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       syncable::ModelTypeSet());
 
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result));
 
   model_association_manager.Initialize(types);
   model_association_manager.StopDisabledTypes();
   model_association_manager.StartAssociationAsync();
 
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::MODEL_LOADED);
   model_association_manager.Stop();
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::NOT_RUNNING);
 }
 
 // Start a type, let it finish and then call stop.
 TEST_F(ModelAssociationManagerTest, StopAfterFinish) {
   controllers_[syncable::BOOKMARKS] =
       new FakeDataTypeController(syncable::BOOKMARKS);
   ModelAssociationManager model_association_manager(&controllers_,
                                                     &result_processor_);
   syncable::ModelTypeSet types;
   types.Put(syncable::BOOKMARKS);
   DataTypeManager::ConfigureResult expected_result(
       DataTypeManager::OK,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       syncable::ModelTypeSet());
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result));
 
   model_association_manager.Initialize(types);
   model_association_manager.StopDisabledTypes();
   model_association_manager.StartAssociationAsync();
 
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::MODEL_LOADED);
   GetController(controllers_, syncable::BOOKMARKS)->FinishStart(
       DataTypeController::OK);
 
   model_association_manager.Stop();
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::NOT_RUNNING);
 }
 
 // Make a type fail model association and verify correctness.
 TEST_F(ModelAssociationManagerTest, TypeFailModelAssociation) {
   controllers_[syncable::BOOKMARKS] =
       new FakeDataTypeController(syncable::BOOKMARKS);
   ModelAssociationManager model_association_manager(&controllers_,
                                                     &result_processor_);
   syncable::ModelTypeSet types;
   types.Put(syncable::BOOKMARKS);
-  std::list<csync::SyncError> errors;
-  csync::SyncError error(FROM_HERE, "Failed", syncable::BOOKMARKS);
+  std::list<syncer::SyncError> errors;
+  syncer::SyncError error(FROM_HERE, "Failed", syncable::BOOKMARKS);
   errors.push_back(error);
   DataTypeManager::ConfigureResult expected_result(
       DataTypeManager::PARTIAL_SUCCESS,
       types,
       errors,
       syncable::ModelTypeSet());
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result));
 
   model_association_manager.Initialize(types);
   model_association_manager.StopDisabledTypes();
   model_association_manager.StartAssociationAsync();
 
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::MODEL_LOADED);
   GetController(controllers_, syncable::BOOKMARKS)->FinishStart(
       DataTypeController::ASSOCIATION_FAILED);
 }
 
 // Ensure configuring stops when a type returns a unrecoverable error.
 TEST_F(ModelAssociationManagerTest, TypeReturnUnrecoverableError) {
   controllers_[syncable::BOOKMARKS] =
       new FakeDataTypeController(syncable::BOOKMARKS);
   ModelAssociationManager model_association_manager(&controllers_,
                                                     &result_processor_);
   syncable::ModelTypeSet types;
   types.Put(syncable::BOOKMARKS);
-  std::list<csync::SyncError> errors;
-  csync::SyncError error(FROM_HERE, "Failed", syncable::BOOKMARKS);
+  std::list<syncer::SyncError> errors;
+  syncer::SyncError error(FROM_HERE, "Failed", syncable::BOOKMARKS);
   errors.push_back(error);
   DataTypeManager::ConfigureResult expected_result(
       DataTypeManager::UNRECOVERABLE_ERROR,
       types,
       errors,
       syncable::ModelTypeSet());
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result));
 
   model_association_manager.Initialize(types);
@@ skipping 15 matching lines @@
   GetController(controllers_, syncable::BOOKMARKS)->SetDelayModelLoad();
   ModelAssociationManager model_association_manager(&controllers_,
                                                     &result_processor_);
   syncable::ModelTypeSet types(syncable::BOOKMARKS, syncable::THEMES);
 
   syncable::ModelTypeSet expected_types_waiting_to_load;
   expected_types_waiting_to_load.Put(syncable::BOOKMARKS);
   DataTypeManager::ConfigureResult expected_result_partially_done(
       DataTypeManager::PARTIAL_SUCCESS,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       expected_types_waiting_to_load);
 
   model_association_manager.Initialize(types);
   model_association_manager.StopDisabledTypes();
 
   model_association_manager.StartAssociationAsync();
 
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result_partially_done));
 
@@ skipping 19 matching lines @@
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::MODEL_STARTING);
 
   model_association_manager.Initialize(types);
   EXPECT_EQ(GetController(controllers_, syncable::BOOKMARKS)->state(),
             DataTypeController::NOT_RUNNING);
 
   DataTypeManager::ConfigureResult expected_result_done(
       DataTypeManager::OK,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       syncable::ModelTypeSet());
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result_done));
 
   model_association_manager.StopDisabledTypes();
   model_association_manager.StartAssociationAsync();
 
   GetController(controllers_,
                 syncable::BOOKMARKS)->SimulateModelLoadFinishing();
   GetController(controllers_, syncable::BOOKMARKS)->FinishStart(
@@ skipping 12 matching lines @@
                                                     &result_processor_);
   syncable::ModelTypeSet types;
   types.Put(syncable::BOOKMARKS);
   types.Put(syncable::APPS);
 
   syncable::ModelTypeSet expected_types_waiting_to_load;
   expected_types_waiting_to_load.Put(syncable::BOOKMARKS);
   DataTypeManager::ConfigureResult expected_result_partially_done(
       DataTypeManager::PARTIAL_SUCCESS,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       expected_types_waiting_to_load);
 
   DataTypeManager::ConfigureResult expected_result_done(
       DataTypeManager::OK,
       types,
-      std::list<csync::SyncError>(),
+      std::list<syncer::SyncError>(),
       syncable::ModelTypeSet());
 
   EXPECT_CALL(result_processor_, OnModelAssociationDone(_)).
               WillOnce(VerifyResult(expected_result_partially_done));
   EXPECT_CALL(result_processor_, OnTypesLoaded());
 
   model_association_manager.Initialize(types);
   model_association_manager.StopDisabledTypes();
   model_association_manager.StartAssociationAsync();
 
@@ skipping 24 matching lines @@
 
   GetController(controllers_,
                 syncable::BOOKMARKS)->SimulateModelLoadFinishing();
 
   GetController(controllers_, syncable::BOOKMARKS)->FinishStart(
       DataTypeController::OK);
 }
 
 
 }  // namespace browser_sync