[Sync] Add support for server controlled nudge delays

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/auto_reset.h"
@@ skipping 14 matching lines @@
 using base::TimeTicks;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
+bool IsConfigRelatedUpdateSourceValue(
+    GetUpdatesCallerInfo::GetUpdatesSource source) {
+  switch (source) {
+    case GetUpdatesCallerInfo::RECONFIGURATION:
+    case GetUpdatesCallerInfo::MIGRATION:
+    case GetUpdatesCallerInfo::NEW_CLIENT:
+    case GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE:
+      return true;
+    default:
+      return 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:
     case DISABLED_BY_ADMIN:
@@ skipping 13 matching lines @@
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool IsActionableError(
     const SyncProtocolError& error) {
   return (error.action != UNKNOWN_ACTION);
 }
+
 }  // namespace
 
 ConfigurationParams::ConfigurationParams()
     : source(GetUpdatesCallerInfo::UNKNOWN) {}
 ConfigurationParams::ConfigurationParams(
     const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& source,
     ModelTypeSet types_to_download,
     const ModelSafeRoutingInfo& routing_info,
     const base::Closure& ready_task,
     const base::Closure& retry_task)
@@ skipping 47 matching lines @@
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncer threads involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 #define SDVLOG_LOC(from_here, verbose_level)             \
   DVLOG_LOC(from_here, verbose_level) << name_ << ": "
 
-namespace {
-
-const int kDefaultSessionsCommitDelaySeconds = 10;
-
-bool IsConfigRelatedUpdateSourceValue(
-    GetUpdatesCallerInfo::GetUpdatesSource source) {
-  switch (source) {
-    case GetUpdatesCallerInfo::RECONFIGURATION:
-    case GetUpdatesCallerInfo::MIGRATION:
-    case GetUpdatesCallerInfo::NEW_CLIENT:
-    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)
     : name_(name),
       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),
       delay_provider_(delay_provider),
       syncer_(syncer),
       session_context_(context),
       no_scheduling_allowed_(false),
       do_poll_after_credentials_updated_(false),
       next_sync_session_job_priority_(NORMAL_PRIORITY),
       weak_ptr_factory_(this),
       weak_ptr_factory_for_weak_handle_(this) {
   weak_handle_this_ = MakeWeakHandle(
@@ skipping 173 matching lines @@
 
   if (mode_ == CONFIGURATION_MODE) {
     SDVLOG(1) << "Not running nudge because we're in configuration mode.";
     return false;
   }
 
   return true;
 }
 
 void SyncSchedulerImpl::ScheduleLocalNudge(
-    const TimeDelta& desired_delay,
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
   DCHECK(!types.Empty());
 
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because of local change to "
       << ModelTypeSetToString(types);
   UpdateNudgeTimeRecords(types);
-  nudge_tracker_.RecordLocalChange(types);
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  base::TimeDelta nudge_delay = nudge_tracker_.RecordLocalChange(types);
+  ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleLocalRefreshRequest(
-    const TimeDelta& desired_delay,
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
   DCHECK(!types.Empty());
 
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because of local refresh request for "
       << ModelTypeSetToString(types);
-  nudge_tracker_.RecordLocalRefreshRequest(types);
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  base::TimeDelta nudge_delay = nudge_tracker_.RecordLocalRefreshRequest(types);
+  ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInvalidationNudge(
-    const TimeDelta& desired_delay,
     syncer::ModelType model_type,
     scoped_ptr<InvalidationInterface> invalidation,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
 
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because we received invalidation for "
       << ModelTypeToString(model_type);
-  nudge_tracker_.RecordRemoteInvalidation(model_type, invalidation.Pass());
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  base::TimeDelta nudge_delay =
+      nudge_tracker_.RecordRemoteInvalidation(model_type, invalidation.Pass());
+  ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInitialSyncNudge(syncer::ModelType model_type) {
   DCHECK(CalledOnValidThread());
 
   SDVLOG(2) << "Scheduling non-blocking initial sync for "
             << ModelTypeToString(model_type);
   nudge_tracker_.RecordInitialSyncRequired(model_type);
   ScheduleNudgeImpl(TimeDelta::FromSeconds(0), FROM_HERE);
 }
@@ skipping 45 matching lines @@
 }
 
 const char* SyncSchedulerImpl::GetModeString(SyncScheduler::Mode mode) {
   switch (mode) {
     ENUM_CASE(CONFIGURATION_MODE);
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
+void SyncSchedulerImpl::SetDefaultNudgeDelay(base::TimeDelta delay_ms) {
+  DCHECK(CalledOnValidThread());
+  nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
+}
+
 void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
 
   DVLOG(2) << "Will run normal mode sync cycle with types "
            << ModelTypeSetToString(session_context_->GetEnabledTypes());
   scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
   bool premature_exit = !syncer_->NormalSyncShare(
       GetEnabledAndUnthrottledTypes(),
       nudge_tracker_,
@@ skipping 381 matching lines @@
   DCHECK(CalledOnValidThread());
   syncer_short_poll_interval_seconds_ = new_interval;
 }
 
 void SyncSchedulerImpl::OnReceivedLongPollIntervalUpdate(
     const base::TimeDelta& new_interval) {
   DCHECK(CalledOnValidThread());
   syncer_long_poll_interval_seconds_ = new_interval;
 }
 
-void SyncSchedulerImpl::OnReceivedSessionsCommitDelay(
-    const base::TimeDelta& new_delay) {
+void SyncSchedulerImpl::OnReceivedCustomNudgeDelays(
+    const std::map<ModelType, base::TimeDelta>& nudge_delays) {
   DCHECK(CalledOnValidThread());
-  sessions_commit_delay_ = new_delay;
+  nudge_tracker_.OnReceivedCustomNudgeDelays(nudge_delays);
 }
 
 void SyncSchedulerImpl::OnReceivedClientInvalidationHintBufferSize(int size) {
   if (size > 0)
     nudge_tracker_.SetHintBufferSize(size);
   else
     NOTREACHED() << "Hint buffer size should be > 0.";
 }
 
 void SyncSchedulerImpl::OnSyncProtocolError(
@@ skipping 25 matching lines @@
 
 void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
   DCHECK(CalledOnValidThread());
   session_context_->set_notifications_enabled(notifications_enabled);
   if (notifications_enabled)
     nudge_tracker_.OnInvalidationsEnabled();
   else
     nudge_tracker_.OnInvalidationsDisabled();
 }
 
-base::TimeDelta SyncSchedulerImpl::GetSessionsCommitDelay() const {
-  DCHECK(CalledOnValidThread());
-  return sessions_commit_delay_;
-}
-
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer