[Sync] Rename csync namespace to syncer

chrome/browser/sync/glue/generic_change_processor.h

Index: chrome/browser/sync/glue/generic_change_processor.h
diff --git a/chrome/browser/sync/glue/generic_change_processor.h b/chrome/browser/sync/glue/generic_change_processor.h
index dd72179c3d1629ec18b61e3f5da207a20c8dcdfa..223cd6bf938bec3a9eba3bb5da3903dfb3c97c08 100644
--- a/chrome/browser/sync/glue/generic_change_processor.h
+++ b/chrome/browser/sync/glue/generic_change_processor.h
@@ -16,12 +16,12 @@
 #include "chrome/browser/sync/glue/data_type_error_handler.h"
 #include "sync/api/sync_change_processor.h"
 
-namespace csync {
+namespace syncer {
 class SyncData;
 class SyncableService;
 
-typedef std::vector<csync::SyncData> SyncDataList;
-}  // namespace csync
+typedef std::vector<syncer::SyncData> SyncDataList;
+}  // namespace syncer
 
 namespace browser_sync {
 
@@ -36,36 +36,36 @@ namespace browser_sync {
 // As a rule, the GenericChangeProcessor is not thread safe, and should only
 // be used on the same thread in which it was created.
 class GenericChangeProcessor : public ChangeProcessor,
-                               public csync::SyncChangeProcessor,
+                               public syncer::SyncChangeProcessor,
                                public base::NonThreadSafe {
  public:
   // Create a change processor and connect it to the syncer.
   GenericChangeProcessor(
       DataTypeErrorHandler* error_handler,
-      const base::WeakPtr<csync::SyncableService>& local_service,
-      csync::UserShare* user_share);
+      const base::WeakPtr<syncer::SyncableService>& local_service,
+      syncer::UserShare* user_share);
   virtual ~GenericChangeProcessor();
 
   // ChangeProcessor interface.
   // Build and store a list of all changes into |syncer_changes_|.
   virtual void ApplyChangesFromSyncModel(
-      const csync::BaseTransaction* trans,
-      const csync::ImmutableChangeRecordList& changes) OVERRIDE;
+      const syncer::BaseTransaction* trans,
+      const syncer::ImmutableChangeRecordList& changes) OVERRIDE;
   // Passes |syncer_changes_|, built in ApplyChangesFromSyncModel, onto
   // |local_service_| by way of its ProcessSyncChanges method.
   virtual void CommitChangesFromSyncModel() OVERRIDE;
 
-  // csync::SyncChangeProcessor implementation.
-  virtual csync::SyncError ProcessSyncChanges(
+  // syncer::SyncChangeProcessor implementation.
+  virtual syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
-      const csync::SyncChangeList& change_list) OVERRIDE;
+      const syncer::SyncChangeList& change_list) OVERRIDE;
 
   // Fills |current_sync_data| with all the syncer data for the specified type.
-  virtual csync::SyncError GetSyncDataForType(syncable::ModelType type,
-                                       csync::SyncDataList* current_sync_data);
+  virtual syncer::SyncError GetSyncDataForType(syncable::ModelType type,
+                                       syncer::SyncDataList* current_sync_data);
 
   // Generic versions of AssociatorInterface methods. Called by
-  // csync::SyncableServiceAdapter or the DataTypeController.
+  // syncer::SyncableServiceAdapter or the DataTypeController.
   virtual bool SyncModelHasUserCreatedNodes(syncable::ModelType type,
                                             bool* has_nodes);
   virtual bool CryptoReadyIfNecessary(syncable::ModelType type);
@@ -76,24 +76,24 @@ class GenericChangeProcessor : public ChangeProcessor,
   // Called from UI thread (as part of deactivating datatype), but does
   // nothing and is guaranteed to still be alive, so it's okay.
   virtual void StopImpl() OVERRIDE;                            // Does nothing.
-  virtual csync::UserShare* share_handle() const OVERRIDE;
+  virtual syncer::UserShare* share_handle() const OVERRIDE;
 
  private:
   // The SyncableService this change processor will forward changes on to.
-  const base::WeakPtr<csync::SyncableService> local_service_;
+  const base::WeakPtr<syncer::SyncableService> local_service_;
 
   // The current list of changes received from the syncer. We buffer because
   // we must ensure no syncapi transaction is held when we pass it on to
   // |local_service_|.
   // Set in ApplyChangesFromSyncModel, consumed in CommitChangesFromSyncModel.
-  csync::SyncChangeList syncer_changes_;
+  syncer::SyncChangeList syncer_changes_;
 
   // Our handle to the sync model. Unlike normal ChangeProcessors, we need to
   // be able to access the sync model before the change processor begins
   // listening to changes (the local_service_ will be interacting with us
   // when it starts up). As such we can't wait until Start(_) has been called,
   // and have to keep a local pointer to the user_share.
-  csync::UserShare* const share_handle_;
+  syncer::UserShare* const share_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(GenericChangeProcessor);
 };