[Sync] Rename csync namespace to syncer

chrome/browser/sync/profile_sync_service_harness.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/profile_sync_service_harness.h"
 
 #include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
@@ skipping 10 matching lines @@
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/sync_ui_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 
-using csync::sessions::SyncSessionSnapshot;
+using syncer::sessions::SyncSessionSnapshot;
 
 // TODO(rsimha): Remove the following lines once crbug.com/91863 is fixed.
 // The amount of time for which we wait for a live sync operation to complete.
 static const int kLiveSyncOperationTimeoutMs = 45000;
 
 // The amount of time we wait for test cases that verify exponential backoff.
 static const int kExponentialBackoffVerificationTimeoutMs = 60000;
 
 // Simple class to implement a timeout using PostDelayedTask.  If it is not
 // aborted before picked up by a message queue, then it asserts with the message
@@ skipping 237 matching lines @@
       break;
     }
     case WAITING_FOR_INITIAL_SYNC: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_INITIAL_SYNC");
       if (IsFullySynced()) {
         // The first sync cycle is now complete. We can start running tests.
         SignalStateCompleteWithNextState(FULLY_SYNCED);
         break;
       }
       if (service()->passphrase_required_reason() ==
-              csync::REASON_DECRYPTION) {
+              syncer::REASON_DECRYPTION) {
         // A passphrase is required for decryption and we don't have it. Do not
         // wait any more.
         SignalStateCompleteWithNextState(SET_PASSPHRASE_FAILED);
         break;
       }
       break;
     }
     case WAITING_FOR_FULL_SYNC: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_FULL_SYNC");
       if (IsFullySynced()) {
@@ skipping 92 matching lines @@
       DVLOG(1) << GetClientInfoString("WAITING_FOR_MIGRATION_TO_FINISH");
       if (!HasPendingBackendMigration()) {
         // Done migrating.
         SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
       }
       break;
     }
     case WAITING_FOR_ACTIONABLE_ERROR: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_ACTIONABLE_ERROR");
       ProfileSyncService::Status status = GetStatus();
-      if (status.sync_protocol_error.action != csync::UNKNOWN_ACTION &&
+      if (status.sync_protocol_error.action != syncer::UNKNOWN_ACTION &&
           service_->HasUnrecoverableError() == true) {
         // An actionable error has been detected.
         SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
       }
       break;
     }
     case SET_PASSPHRASE_FAILED: {
       // A passphrase is required for decryption. There is nothing the sync
       // client can do until SetDecryptionPassphrase() is called.
       DVLOG(1) << GetClientInfoString("SET_PASSPHRASE_FAILED");
@@ skipping 177 matching lines @@
   const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
   retry_verifier_.Initialize(snap);
   wait_state_ = WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION;
   AwaitStatusChangeWithTimeout(kExponentialBackoffVerificationTimeoutMs,
       "Verify Exponential backoff");
   return (retry_verifier_.Succeeded());
 }
 
 bool ProfileSyncServiceHarness::AwaitActionableError() {
   ProfileSyncService::Status status = GetStatus();
-  CHECK(status.sync_protocol_error.action == csync::UNKNOWN_ACTION);
+  CHECK(status.sync_protocol_error.action == syncer::UNKNOWN_ACTION);
   wait_state_ = WAITING_FOR_ACTIONABLE_ERROR;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for actionable error");
   status = GetStatus();
-  return (status.sync_protocol_error.action != csync::UNKNOWN_ACTION &&
+  return (status.sync_protocol_error.action != syncer::UNKNOWN_ACTION &&
           service_->HasUnrecoverableError());
 }
 
 bool ProfileSyncServiceHarness::AwaitMigration(
     syncable::ModelTypeSet expected_migrated_types) {
   DVLOG(1) << GetClientInfoString("AwaitMigration");
   DVLOG(1) << profile_debug_name_ << ": waiting until migration is done for "
           << syncable::ModelTypeSetToString(expected_migrated_types);
   while (true) {
     bool migration_finished = migrated_types_.HasAll(expected_migrated_types);
@@ skipping 173 matching lines @@
 bool ProfileSyncServiceHarness::IsFullySynced() {
   if (service() == NULL) {
     DVLOG(1) << GetClientInfoString("IsFullySynced: false");
     return false;
   }
   const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
   // If we didn't try to commit anything in the previous cycle, there's a
   // good chance that we're now fully up to date.
   bool is_fully_synced =
       snap.model_neutral_state().num_successful_commits == 0
-      && snap.model_neutral_state().commit_result == csync::SYNCER_OK
+      && snap.model_neutral_state().commit_result == syncer::SYNCER_OK
       && IsDataSyncedImpl(snap);
 
   DVLOG(1) << GetClientInfoString(
       is_fully_synced ? "IsFullySynced: true" : "IsFullySynced: false");
   return is_fully_synced;
 }
 
 bool ProfileSyncServiceHarness::HasPendingBackendMigration() {
   browser_sync::BackendMigrator* migrator =
       service()->GetBackendMigratorForTest();
@@ skipping 185 matching lines @@
   if (service()) {
     const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
     const ProfileSyncService::Status& status = GetStatus();
     // Capture select info from the sync session snapshot and syncer status.
     os << "has_more_to_sync: "
        << snap.has_more_to_sync()
        << ", has_unsynced_items: "
        << (service()->sync_initialized() ? service()->HasUnsyncedItems() : 0)
        << ", did_commit: "
        << (snap.model_neutral_state().num_successful_commits == 0 &&
-           snap.model_neutral_state().commit_result == csync::SYNCER_OK)
+           snap.model_neutral_state().commit_result == syncer::SYNCER_OK)
        << ", encryption conflicts: "
        << snap.num_encryption_conflicts()
        << ", hierarchy conflicts: "
        << snap.num_hierarchy_conflicts()
        << ", simple conflicts: "
        << snap.num_simple_conflicts()
        << ", server conflicts: "
        << snap.num_server_conflicts()
        << ", num_updates_downloaded : "
        << snap.model_neutral_state().num_updates_downloaded_total
        << ", passphrase_required_reason: "
-       << csync::PassphraseRequiredReasonToString(
+       << syncer::PassphraseRequiredReasonToString(
            service()->passphrase_required_reason())
        << ", notifications_enabled: "
        << status.notifications_enabled
        << ", service_is_pushing_changes: "
        << ServiceIsPushingChanges()
        << ", has_pending_backend_migration: "
        << HasPendingBackendMigration();
   } else {
     os << "Sync service not available";
   }
@@ skipping 80 matching lines @@
 
 std::string ProfileSyncServiceHarness::GetServiceStatus() {
   DictionaryValue value;
   sync_ui_util::ConstructAboutInformation(service_, &value);
   std::string service_status;
   base::JSONWriter::WriteWithOptions(&value,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &service_status);
   return service_status;
 }