sync: add InternalComponentsFactory::Switches to simplify passing switches to internal components.

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"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
-#include "base/rand_util.h"
+#include "sync/engine/backoff_delay_provider.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/protocol/proto_enum_conversions.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/util/data_type_histogram.h"
 #include "sync/util/logging.h"
 
 using base::TimeDelta;
 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 28 matching lines @@
     const ModelSafeRoutingInfo& routing_info,
     const base::Closure& ready_task)
     : source(source),
       types_to_download(types_to_download),
       routing_info(routing_info),
       ready_task(ready_task) {
   DCHECK(!ready_task.is_null());
 }
 ConfigurationParams::~ConfigurationParams() {}
 
-SyncSchedulerImpl::DelayProvider::DelayProvider() {}
-SyncSchedulerImpl::DelayProvider::~DelayProvider() {}
-
 SyncSchedulerImpl::WaitInterval::WaitInterval()
     : mode(UNKNOWN),
       had_nudge(false) {
 }
 
 SyncSchedulerImpl::WaitInterval::~WaitInterval() {}
 
 #define ENUM_CASE(x) case x: return #x; break;
 
 const char* SyncSchedulerImpl::WaitInterval::GetModeString(Mode mode) {
@@ skipping 32 matching lines @@
   switch (purpose) {
     ENUM_CASE(UNKNOWN);
     ENUM_CASE(POLL);
     ENUM_CASE(NUDGE);
     ENUM_CASE(CONFIGURATION);
   }
   NOTREACHED();
   return "";
 }
 
-TimeDelta SyncSchedulerImpl::DelayProvider::GetDelay(
-    const base::TimeDelta& last_delay) {
-  return SyncSchedulerImpl::GetRecommendedDelay(last_delay);
-}
-
 GetUpdatesCallerInfo::GetUpdatesSource GetUpdatesFromNudgeSource(
     NudgeSource source) {
   switch (source) {
     case NUDGE_SOURCE_NOTIFICATION:
       return GetUpdatesCallerInfo::NOTIFICATION;
     case NUDGE_SOURCE_LOCAL:
       return GetUpdatesCallerInfo::LOCAL;
     case NUDGE_SOURCE_CONTINUATION:
       return GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
     case NUDGE_SOURCE_LOCAL_REFRESH:
@@ skipping 32 matching lines @@
     case GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
+                                     BackoffDelayProvider* delay_provider,
                                      sessions::SyncSessionContext* context,
                                      Syncer* syncer)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_ptr_factory_for_weak_handle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_handle_this_(MakeWeakHandle(
           weak_ptr_factory_for_weak_handle_.GetWeakPtr())),
       name_(name),
       sync_loop_(MessageLoop::current()),
       started_(false),
       syncer_short_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
       sessions_commit_delay_(
           TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds)),
       mode_(NORMAL_MODE),
       // Start with assuming everything is fine with the connection.
       // At the end of the sync cycle we would have the correct status.
       connection_code_(HttpResponse::SERVER_CONNECTION_OK),
-      delay_provider_(new DelayProvider()),
+      delay_provider_(delay_provider),
       syncer_(syncer),
       session_context_(context) {
   DCHECK(sync_loop_);
 }
 
 SyncSchedulerImpl::~SyncSchedulerImpl() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   StopImpl(base::Closure());
 }
 
@@ skipping 666 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 :
-          GetInitialBackoffDelay(
+          delay_provider_->GetInitialDelay(
               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));
@@ skipping 12 matching lines @@
     // We are not in configuration mode. So wait_interval's pending job
     // should be null.
     DCHECK(wait_interval_->pending_configure_job.get() == NULL);
 
     // TODO(lipalani) - handle clear user data.
     InitOrCoalescePendingJob(old_job);
   }
   RestartWaiting();
 }
 
-// static
-TimeDelta SyncSchedulerImpl::GetRecommendedDelay(const TimeDelta& last_delay) {
-  if (last_delay.InSeconds() >= kMaxBackoffSeconds)
-    return TimeDelta::FromSeconds(kMaxBackoffSeconds);
-
-  // This calculates approx. base_delay_seconds * 2 +/- base_delay_seconds / 2
-  int64 backoff_s =
-      std::max(static_cast<int64>(1),
-               last_delay.InSeconds() * kBackoffRandomizationFactor);
-
-  // Flip a coin to randomize backoff interval by +/- 50%.
-  int rand_sign = base::RandInt(0, 1) * 2 - 1;
-
-  // Truncation is adequate for rounding here.
-  backoff_s = backoff_s +
-      (rand_sign * (last_delay.InSeconds() / kBackoffRandomizationFactor));
-
-  // Cap the backoff interval.
-  backoff_s = std::max(static_cast<int64>(1),
-                       std::min(backoff_s, kMaxBackoffSeconds));
-
-  return TimeDelta::FromSeconds(backoff_s);
-}
-
 void SyncSchedulerImpl::RequestStop(const base::Closure& callback) {
   syncer_->RequestEarlyExit();  // Safe to call from any thread.
   DCHECK(weak_handle_this_.IsInitialized());
   SDVLOG(3) << "Posting StopImpl";
   weak_handle_this_.Call(FROM_HERE,
                          &SyncSchedulerImpl::StopImpl,
                          callback);
 }
 
 void SyncSchedulerImpl::StopImpl(const base::Closure& callback) {
@@ skipping 171 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer