[Sync] Rename csync namespace to syncer

chrome/browser/sync/sync_ui_util.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/sync_ui_util.h"
 
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 148 matching lines @@
           IDS_SYNC_ACCOUNT_SYNCING_TO_USER_WITH_MANAGE_LINK,
           user_name,
           ASCIIToUTF16(chrome::kSyncGoogleDashboardURL));
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 void GetStatusForActionableError(
-    const csync::SyncProtocolError& error,
+    const syncer::SyncProtocolError& error,
     string16* status_label) {
   DCHECK(status_label);
   switch (error.action) {
-    case csync::STOP_AND_RESTART_SYNC:
+    case syncer::STOP_AND_RESTART_SYNC:
        status_label->assign(
            l10n_util::GetStringUTF16(IDS_SYNC_STOP_AND_RESTART_SYNC));
       break;
-    case csync::UPGRADE_CLIENT:
+    case syncer::UPGRADE_CLIENT:
        status_label->assign(
            l10n_util::GetStringFUTF16(IDS_SYNC_UPGRADE_CLIENT,
                l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
       break;
-    case csync::ENABLE_SYNC_ON_ACCOUNT:
+    case syncer::ENABLE_SYNC_ON_ACCOUNT:
        status_label->assign(
            l10n_util::GetStringUTF16(IDS_SYNC_ENABLE_SYNC_ON_ACCOUNT));
     break;
-    case csync::CLEAR_USER_DATA_AND_RESYNC:
+    case syncer::CLEAR_USER_DATA_AND_RESYNC:
        status_label->assign(
            l10n_util::GetStringUTF16(IDS_SYNC_CLEAR_USER_DATA));
       break;
     default:
       NOTREACHED();
   }
 }
 
 // TODO(akalin): Write unit tests for these three functions below.
 
@@ skipping 120 matching lines @@
 // different information than in the settings panel.
 MessageType GetStatusInfoForNewTabPage(ProfileSyncService* service,
                                        const SigninManager& signin,
                                        string16* status_label,
                                        string16* link_label) {
   DCHECK(status_label);
   DCHECK(link_label);
 
   if (service->HasSyncSetupCompleted() &&
       service->IsPassphraseRequired()) {
-    if (service->passphrase_required_reason() == csync::REASON_ENCRYPTION) {
+    if (service->passphrase_required_reason() == syncer::REASON_ENCRYPTION) {
       // First machine migrating to passwords.  Show as a promotion.
       if (status_label && link_label) {
         status_label->assign(
             l10n_util::GetStringFUTF16(
                 IDS_SYNC_NTP_PASSWORD_PROMO,
                 l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
         link_label->assign(
             l10n_util::GetStringUTF16(IDS_SYNC_NTP_PASSWORD_ENABLE));
       }
       return SYNC_PROMO;
@@ skipping 174 matching lines @@
   CHECK(strings);
   if (!service) {
     sync_ui_util::AddStringSyncDetails(sync_summary, "Summary",
                                        "Sync service does not exist");
   } else {
     // This bypasses regular inter-thread communication mechanisms to grab a
     // very recent snapshot from the syncer thread.  It should be up to date
     // with the last snapshot emitted by the syncer.  Keep in mind, though, that
     // not all events that update these values will ping the UI thread, so you
     // might not see all intermediate values.
-    csync::SyncStatus full_status(service->QueryDetailedSyncStatus());
+    syncer::SyncStatus full_status(service->QueryDetailedSyncStatus());
 
     // This is a cache of the last snapshot of type SYNC_CYCLE_ENDED where
     // !snapshot.has_more_to_sync().  In other words, it's the last in this
     // series of sync cycles.  The series ends only when we've done all we can
     // to resolve conflicts and there is nothing left to commit, or an error
     // occurs.
     //
     // Despite the fact that it is updated only at the end of a series of
     // commits, its values do not reflect the series.  Its counters are based on
     // the values from a single sync cycle.
     //
     // |snapshot| could be NULL if sync is not yet initialized.
-    const csync::sessions::SyncSessionSnapshot& snapshot =
+    const syncer::sessions::SyncSessionSnapshot& snapshot =
         service->sync_initialized() ?
         service->GetLastSessionSnapshot() :
-        csync::sessions::SyncSessionSnapshot();
+        syncer::sessions::SyncSessionSnapshot();
 
     sync_ui_util::AddStringSyncDetails(sync_summary, "Summary",
                                        service->QuerySyncStatusSummary());
 
     ListValue* version_info = AddSyncDetailsSection(details, "Version Info");
     sync_ui_util::AddStringSyncDetails(version_info, "Client Version",
                                        GetVersionString());
     sync_ui_util::AddStringSyncDetails(version_info, "Server URL",
                                        service->sync_service_url().spec());
 
@@ skipping 55 matching lines @@
                                     full_status.crypto_has_pending_keys);
     sync_ui_util::AddStringSyncDetails(encryption,
         "Encrypted Types",
         syncable::ModelTypeSetToString(full_status.encrypted_types));
 
 
     ListValue* cycles = AddSyncDetailsSection(
         details, "Status from Last Completed Session");
     sync_ui_util::AddStringSyncDetails(
         cycles, "Sync Source",
-        csync::GetUpdatesSourceString(
+        syncer::GetUpdatesSourceString(
         snapshot.source().updates_source));
     sync_ui_util::AddStringSyncDetails(
         cycles, "Download Step Result",
         GetSyncerErrorString(
             snapshot.model_neutral_state().last_download_updates_result));
     sync_ui_util::AddStringSyncDetails(
         cycles, "Commit Step Result",
         GetSyncerErrorString(snapshot.model_neutral_state().commit_result));
 
     // Strictly increasing counters.
@@ skipping 84 matching lines @@
     sync_ui_util::AddIntSyncDetail(transient_session, "Entries",
                                    snapshot.num_entries());
 
     if (!full_status.throttled_types.Empty()) {
       strings->Set("throttled_data_types", base::Value::CreateStringValue(
               ModelTypeSetToString(full_status.throttled_types)));
     }
 
     // Now set the actionable errors.
     if ((full_status.sync_protocol_error.error_type !=
-         csync::UNKNOWN_ERROR) &&
+         syncer::UNKNOWN_ERROR) &&
         (full_status.sync_protocol_error.error_type !=
-         csync::SYNC_SUCCESS)) {
+         syncer::SYNC_SUCCESS)) {
       strings->Set("actionable_error_detected",
                    base::Value::CreateBooleanValue(true));
       ListValue* actionable_error = new ListValue();
       strings->Set("actionable_error", actionable_error);
       sync_ui_util::AddStringSyncDetails(actionable_error, "Error Type",
-          csync::GetSyncErrorTypeString(
+          syncer::GetSyncErrorTypeString(
               full_status.sync_protocol_error.error_type));
       sync_ui_util::AddStringSyncDetails(actionable_error, "Action",
-          csync::GetClientActionString(
+          syncer::GetClientActionString(
               full_status.sync_protocol_error.action));
       sync_ui_util::AddStringSyncDetails(actionable_error, "url",
           full_status.sync_protocol_error.url);
       sync_ui_util::AddStringSyncDetails(actionable_error, "Error Description",
           full_status.sync_protocol_error.error_description);
     } else {
       strings->Set("actionable_error_detected",
                    base::Value::CreateBooleanValue(false));
     }
 
@@ skipping 34 matching lines @@
     }
   } else {
     version_modifier = " " + version_modifier;
   }
   return chrome_version.Name() + " " + chrome_version.OSType() + " " +
       chrome_version.Version() + " (" + chrome_version.LastChange() + ")" +
       version_modifier;
 }
 
 }  // namespace sync_ui_util