[Sync] Rename csync namespace to syncer

chrome/browser/sync/backend_migrator.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/backend_migrator.h"
 
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/directory.h" // TODO(tim): Bug 131130.
 
 using syncable::ModelTypeSet;
 
 namespace browser_sync {
 
 using syncable::ModelTypeToString;
 
 MigrationObserver::~MigrationObserver() {}
 
 BackendMigrator::BackendMigrator(const std::string& name,
-                                 csync::UserShare* user_share,
+                                 syncer::UserShare* user_share,
                                  ProfileSyncService* service,
                                  DataTypeManager* manager,
                                  const base::Closure &migration_done_callback)
     : name_(name), user_share_(user_share), service_(service),
       manager_(manager), state_(IDLE),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       migration_done_callback_(migration_done_callback) {
 }
 
 BackendMigrator::~BackendMigrator() {
@@ skipping 66 matching lines @@
   const ModelTypeSet difference = Difference(full_set, to_migrate_);
   bool configure_with_nigori = !to_migrate_.Has(syncable::NIGORI);
   SDVLOG(1) << "BackendMigrator disabling types "
             << ModelTypeSetToString(to_migrate_) << "; configuring "
             << ModelTypeSetToString(difference)
             << (configure_with_nigori ? " with nigori" : " without nigori");
 
   // Add nigori for config or not based upon if the server told us to migrate
   // nigori or not.
   if (configure_with_nigori) {
-    manager_->Configure(difference, csync::CONFIGURE_REASON_MIGRATION);
+    manager_->Configure(difference, syncer::CONFIGURE_REASON_MIGRATION);
   } else {
     manager_->ConfigureWithoutNigori(difference,
-                                     csync::CONFIGURE_REASON_MIGRATION);
+                                     syncer::CONFIGURE_REASON_MIGRATION);
   }
 }
 
 void BackendMigrator::OnConfigureDone(
     const DataTypeManager::ConfigureResult& result) {
   if (state_ == IDLE)
     return;
 
   // |manager_|'s methods aren't re-entrant, and we're notified from
   // them, so post a task to avoid problems.
   SDVLOG(1) << "Posting OnConfigureDoneImpl";
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BackendMigrator::OnConfigureDoneImpl,
                  weak_ptr_factory_.GetWeakPtr(), result));
 }
 
 namespace {
 
-syncable::ModelTypeSet GetUnsyncedDataTypes(csync::UserShare* user_share) {
-  csync::ReadTransaction trans(FROM_HERE, user_share);
+syncable::ModelTypeSet GetUnsyncedDataTypes(syncer::UserShare* user_share) {
+  syncer::ReadTransaction trans(FROM_HERE, user_share);
   syncable::ModelTypeSet unsynced_data_types;
   for (int i = syncable::FIRST_REAL_MODEL_TYPE;
        i < syncable::MODEL_TYPE_COUNT; ++i) {
     syncable::ModelType type = syncable::ModelTypeFromInt(i);
     sync_pb::DataTypeProgressMarker progress_marker;
     trans.GetDirectory()->GetDownloadProgress(type, &progress_marker);
     if (progress_marker.token().empty()) {
       unsynced_data_types.Put(type);
     }
   }
@@ skipping 51 matching lines @@
                     << "; not re-enabling yet";
       return;
     }
 
     ChangeState(REENABLING_TYPES);
     // Don't use |to_migrate_| for the re-enabling because the user
     // may have chosen to disable types during the migration.
     const ModelTypeSet full_set = service_->GetPreferredDataTypes();
     SDVLOG(1) << "BackendMigrator re-enabling types: "
               << syncable::ModelTypeSetToString(full_set);
-    manager_->Configure(full_set, csync::CONFIGURE_REASON_MIGRATION);
+    manager_->Configure(full_set, syncer::CONFIGURE_REASON_MIGRATION);
   } else if (state_ == REENABLING_TYPES) {
     // We're done!
     ChangeState(IDLE);
 
     SDVLOG(1) << "BackendMigrator: Migration complete for: "
               << syncable::ModelTypeSetToString(to_migrate_);
     to_migrate_.Clear();
 
     if (!migration_done_callback_.is_null())
       migration_done_callback_.Run();
   }
 }
 
 BackendMigrator::State BackendMigrator::state() const {
   return state_;
 }
 
 syncable::ModelTypeSet
     BackendMigrator::GetPendingMigrationTypesForTest() const {
   return to_migrate_;
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 };  // namespace browser_sync