[Sync] Rename csync namespace to syncer

chrome/browser/sync/retry_verifier.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/retry_verifier.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 
 namespace browser_sync {
 
 namespace {
 // Given the current delay calculate the minimum and maximum wait times for
 // the next retry.
 DelayInfo CalculateDelay(int64 current_delay) {
   int64 backoff_s = std::max(static_cast<int64>(1), current_delay *
-                             csync::kBackoffRandomizationFactor);
+                             syncer::kBackoffRandomizationFactor);
 
   DelayInfo delay_info;
   delay_info.min_delay = backoff_s + (-1 * current_delay/
-                             csync::kBackoffRandomizationFactor);
+                             syncer::kBackoffRandomizationFactor);
   delay_info.max_delay = backoff_s + current_delay/2;
 
   delay_info.min_delay = std::max(static_cast<int64>(1),
-      std::min(delay_info.min_delay, csync::kMaxBackoffSeconds));
+      std::min(delay_info.min_delay, syncer::kMaxBackoffSeconds));
 
   delay_info.max_delay = std::max(static_cast<int64>(1),
-      std::min(delay_info.max_delay, csync::kMaxBackoffSeconds));
+      std::min(delay_info.max_delay, syncer::kMaxBackoffSeconds));
 
   return delay_info;
 }
 
 // Fills the table with the maximum and minimum values for each retry, upto
 // |count| number of retries.
 void FillDelayTable(DelayInfo* delay_table, int count) {
   DCHECK(count > 1);
 
   // We start off with the minimum value of 2 seconds.
@@ skipping 30 matching lines @@
                                  success_(false),
                                  done_(false) {
   memset(&delay_table_, 0, sizeof(delay_table_));
 }
 
 RetryVerifier::~RetryVerifier() {
 }
 
 // Initializes the state for verification.
 void RetryVerifier::Initialize(
-    const csync::sessions::SyncSessionSnapshot& snap) {
+    const syncer::sessions::SyncSessionSnapshot& snap) {
   retry_count_ = 0;
   last_sync_time_ = snap.sync_start_time();
   FillDelayTable(delay_table_, kMaxRetry);
   done_ = false;
   success_ = false;
 }
 
 void RetryVerifier::VerifyRetryInterval(
-    const csync::sessions::SyncSessionSnapshot& snap) {
+    const syncer::sessions::SyncSessionSnapshot& snap) {
   DCHECK(retry_count_ < kMaxRetry);
   if (retry_count_ == 0) {
     if (snap.sync_start_time() != last_sync_time_) {
       retry_count_++;
       last_sync_time_ = snap.sync_start_time();
     }
     success_ = true;
     return;
   }
 
   // Check if the sync start time has changed. If so indicates a new sync
   // has taken place.
   if (snap.sync_start_time() != last_sync_time_) {
     base::TimeDelta delta = snap.sync_start_time() - last_sync_time_;
     success_ = IsRetryOnTime(delay_table_,retry_count_ -1, delta);
     last_sync_time_ = snap.sync_start_time();
     ++retry_count_;
     done_ = (retry_count_ >= kMaxRetry);
     return;
   }
 }
 }  // namespace browser_sync