[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/model_association_manager.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 <algorithm>
 #include <functional>
 
 #include "base/debug/trace_event.h"
 
 #include "base/logging.h"
@@ skipping 246 matching lines @@
                 << syncable::ModelTypeToString(dtc->second->type())
                  << " in disabled state.";
       }
     }
   }
   return found_any;
 }
 
 void ModelAssociationManager::AppendToFailedDatatypesAndLogError(
     DataTypeController::StartResult result,
-    const csync::SyncError& error) {
+    const syncer::SyncError& error) {
   failed_datatypes_info_.push_back(error);
   LOG(ERROR) << "Failed to associate models for "
              << syncable::ModelTypeToString(error.type());
   UMA_HISTOGRAM_ENUMERATION("Sync.ConfigureFailed",
                             error.type(),
                             syncable::MODEL_TYPE_COUNT);
 }
 
 void ModelAssociationManager::TypeStartCallback(
     DataTypeController::StartResult result,
-    const csync::SyncError& error) {
+    const syncer::SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_END0("sync", "ModelAssociation");
 
   DVLOG(1) << "ModelAssociationManager: TypeStartCallback";
   if (state_ == ABORTED) {
     // Now that we have finished with the current type we can stop
     // if abort was called.
     DVLOG(1) << "ModelAssociationManager: Doing an early return"
              << " because of abort";
     state_ = IDLE;
@@ skipping 36 matching lines @@
       configure_status = DataTypeManager::ABORTED;
       break;
     case DataTypeController::UNRECOVERABLE_ERROR:
       configure_status = DataTypeManager::UNRECOVERABLE_ERROR;
       break;
     default:
       NOTREACHED();
       break;
   }
 
-  std::list<csync::SyncError> errors;
+  std::list<syncer::SyncError> errors;
   errors.push_back(error);
 
   // Put our state to idle.
   state_ = IDLE;
 
   DataTypeManager::ConfigureResult configure_result(configure_status,
                                                     desired_types_,
                                                     errors,
                                                     syncable::ModelTypeSet());
   result_processor_->OnModelAssociationDone(configure_result);
@@ skipping 21 matching lines @@
 
   DVLOG(1) << "ModelAssociationManager: All types have models loaded."
           << "Moving on to StartAssociatingNextType.";
 
   // If all controllers have their |LoadModels| invoked then pass onto
   // |StartAssociatingNextType|.
   StartAssociatingNextType();
 }
 
 void ModelAssociationManager::ModelLoadCallback(
-    syncable::ModelType type, csync::SyncError error) {
+    syncable::ModelType type, syncer::SyncError error) {
   DVLOG(1) << "ModelAssociationManager: ModelLoadCallback for "
           << syncable::ModelTypeToString(type);
   if (state_ == CONFIGURING) {
     DVLOG(1) << "ModelAssociationManager: ModelLoadCallback while configuring";
     for (std::vector<DataTypeController*>::iterator it =
              pending_model_load_.begin();
           it != pending_model_load_.end();
           ++it) {
       if ((*it)->type() == type) {
         // Each type is given |kDataTypeLoadWaitTimeInSeconds| time to load
@@ skipping 114 matching lines @@
   }
   return result;
 }
 
 base::OneShotTimer<ModelAssociationManager>*
     ModelAssociationManager::GetTimerForTesting() {
   return &timer_;
 }
 
 }  // namespace browser_sync