sync: raise initial backoff interval from 1 second to 5 minutes.

sync/engine/sync_scheduler_impl.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 "sync/engine/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 using base::TimeTicks;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sessions::SyncSourceInfo;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
+
+// For integration tests only.  Override initial backoff value.
+// TODO(tim): Remove this egregiousness, use command line flag and plumb
+// through. Done this way to reduce diffs in hotfix.
+static bool g_force_short_retry = false;
+
 bool ShouldRequestEarlyExit(const SyncProtocolError& error) {
   switch (error.error_type) {
     case SYNC_SUCCESS:
     case MIGRATION_DONE:
     case THROTTLED:
     case TRANSIENT_ERROR:
       return false;
     case NOT_MY_BIRTHDAY:
     case CLEAR_PENDING:
       // If we send terminate sync early then |sync_cycle_ended| notification
@@ skipping 846 matching lines @@
                     &SyncSchedulerImpl::PollTimerCallback);
 }
 
 void SyncSchedulerImpl::RestartWaiting() {
   CHECK(wait_interval_.get());
   wait_interval_->timer.Stop();
   wait_interval_->timer.Start(FROM_HERE, wait_interval_->length,
                               this, &SyncSchedulerImpl::DoCanaryJob);
 }
 
+namespace {
+// TODO(tim): Move this function to syncer_error.h.
+// Return true if the command in question was attempted and did not complete
+// successfully.
+bool IsError(SyncerError error) {
+  return error != UNSET && error != SYNCER_OK;
+}
+}  // namespace
+
+// static
+void SyncSchedulerImpl::ForceShortInitialBackoffRetry() {
+  g_force_short_retry = true;
+}
+
+TimeDelta SyncSchedulerImpl::GetInitialBackoffDelay(
+    const sessions::ModelNeutralState& state) const {
+  // TODO(tim): Remove this, provide integration-test-only mechanism
+  // for override.
+  if (g_force_short_retry) {
+    return TimeDelta::FromSeconds(kInitialBackoffShortRetrySeconds);
+  }
+
+  if (IsError(state.last_get_key_result))
+    return TimeDelta::FromSeconds(kInitialBackoffRetrySeconds);
+  // Note: If we received a MIGRATION_DONE on download updates, then commit
+  // should not have taken place.  Moreover, if we receive a MIGRATION_DONE
+  // on commit, it means that download updates succeeded.  Therefore, we only
+  // need to check if either code is equal to SERVER_RETURN_MIGRATION_DONE,
+  // and not if there were any more serious errors requiring the long retry.
+  if (state.last_download_updates_result == SERVER_RETURN_MIGRATION_DONE ||
+      state.commit_result == SERVER_RETURN_MIGRATION_DONE) {
+    return TimeDelta::FromSeconds(kInitialBackoffShortRetrySeconds);
+  }
+
+  return TimeDelta::FromSeconds(kInitialBackoffRetrySeconds);
+}
+
 void SyncSchedulerImpl::HandleContinuationError(
     const SyncSessionJob& old_job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (DCHECK_IS_ON()) {
     if (IsBackingOff()) {
       DCHECK(wait_interval_->timer.IsRunning() || old_job.is_canary_job);
     }
   }
 
   TimeDelta length = delay_provider_->GetDelay(
-      IsBackingOff() ? wait_interval_->length : TimeDelta::FromSeconds(1));
+      IsBackingOff() ? wait_interval_->length :
+          GetInitialBackoffDelay(
+              old_job.session->status_controller().model_neutral_state()));
 
   SDVLOG(2) << "In handle continuation error with "
             << SyncSessionJob::GetPurposeString(old_job.purpose)
             << " job. The time delta(ms) is "
             << length.InMilliseconds();
 
   // This will reset the had_nudge variable as well.
   wait_interval_.reset(new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF,
                                         length));
   if (old_job.purpose == SyncSessionJob::CONFIGURATION) {
@@ skipping 226 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer