[Sync] Add support for server controlled nudge delays

sync/engine/sync_scheduler_impl.cc

Index: sync/engine/sync_scheduler_impl.cc
diff --git a/sync/engine/sync_scheduler_impl.cc b/sync/engine/sync_scheduler_impl.cc
index 974ed27e4ee9a9e45f7228e6b31afb6ce4b374da..1561550094fcb164309ebf0f818568bfcbe32e93 100644
--- a/sync/engine/sync_scheduler_impl.cc
+++ b/sync/engine/sync_scheduler_impl.cc
@@ -32,6 +32,26 @@ using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
+// Delays for syncer nudges.
+const int kDefaultNudgeDelayMilliseconds = 200;
+const int kSlowNudgeDelayMilliseconds = 2000;
+const int kDefaultSessionsCommitDelaySeconds = 10;
+const int kSyncRefreshDelayMsec = 500;
+const int kSyncSchedulerDelayMsec = 250;
+
+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:
@@ -65,6 +85,30 @@ bool IsActionableError(
     const SyncProtocolError& error) {
   return (error.action != UNKNOWN_ACTION);
 }
+
+TimeDelta GetDefaultDelayForType(ModelType model_type,
+                                 TimeDelta minimum_delay) {
+  switch (model_type) {
+   case AUTOFILL:
+     // Accompany types rely on nudges from other types, and hence have long
+     // nudge delays.
+     return TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds);
+   case BOOKMARKS:
+   case PREFERENCES:
+     // Types with sometimes automatic changes get longer delays to allow more
+     // coalescing.
+     return TimeDelta::FromMilliseconds(kSlowNudgeDelayMilliseconds);
+   case SESSIONS:
+   case FAVICON_IMAGES:
+   case FAVICON_TRACKING:
+     // Types with navigation triggered changes get longer delays to allow more
+     // coalescing.
+     return TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds);
+   default:
+     return minimum_delay;
+  }
+}
+
 }  // namespace
 
 ConfigurationParams::ConfigurationParams()
@@ -132,25 +176,6 @@ GetUpdatesCallerInfo::GetUpdatesSource GetUpdatesFromNudgeSource(
 #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,
@@ -161,8 +186,7 @@ SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
-      sessions_commit_delay_(
-          TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds)),
+      minimum_nudge_delay_ms_(kDefaultNudgeDelayMilliseconds),
       mode_(NORMAL_MODE),
       delay_provider_(delay_provider),
       syncer_(syncer),
@@ -174,6 +198,12 @@ SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
       weak_ptr_factory_for_weak_handle_(this) {
   weak_handle_this_ = MakeWeakHandle(
       weak_ptr_factory_for_weak_handle_.GetWeakPtr());
+  ModelTypeSet protocol_types = ProtocolTypes();
+  for (ModelTypeSet::Iterator iter = protocol_types.First();
+       iter.Good(); iter.Inc()) {
+    nudge_delays_[iter.Get()] = GetDefaultDelayForType(
+        iter.Get(), TimeDelta::FromMilliseconds(minimum_nudge_delay_ms_));
+  }
 }
 
 SyncSchedulerImpl::~SyncSchedulerImpl() {
@@ -356,7 +386,6 @@ bool SyncSchedulerImpl::CanRunNudgeJobNow(JobPriority priority) {
 }
 
 void SyncSchedulerImpl::ScheduleLocalNudge(
-    const TimeDelta& desired_delay,
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
@@ -367,11 +396,10 @@ void SyncSchedulerImpl::ScheduleLocalNudge(
       << ModelTypeSetToString(types);
   UpdateNudgeTimeRecords(types);
   nudge_tracker_.RecordLocalChange(types);
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  ScheduleNudgeImpl(GetNudgeDelayForTypes(types), nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleLocalRefreshRequest(
-    const TimeDelta& desired_delay,
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
@@ -381,11 +409,11 @@ void SyncSchedulerImpl::ScheduleLocalRefreshRequest(
       << "Scheduling sync because of local refresh request for "
       << ModelTypeSetToString(types);
   nudge_tracker_.RecordLocalRefreshRequest(types);
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  ScheduleNudgeImpl(base::TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
+                    nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInvalidationNudge(
-    const TimeDelta& desired_delay,
     syncer::ModelType model_type,
     scoped_ptr<InvalidationInterface> invalidation,
     const tracked_objects::Location& nudge_location) {
@@ -395,7 +423,8 @@ void SyncSchedulerImpl::ScheduleInvalidationNudge(
       << "Scheduling sync because we received invalidation for "
       << ModelTypeToString(model_type);
   nudge_tracker_.RecordRemoteInvalidation(model_type, invalidation.Pass());
-  ScheduleNudgeImpl(desired_delay, nudge_location);
+  ScheduleNudgeImpl(base::TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
+                    nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleInitialSyncNudge(syncer::ModelType model_type) {
@@ -461,6 +490,16 @@ const char* SyncSchedulerImpl::GetModeString(SyncScheduler::Mode mode) {
   return "";
 }
 
+void SyncSchedulerImpl::SetDefaultNudgeDelay(int delay_ms) {
+  minimum_nudge_delay_ms_ = delay_ms;
+  ModelTypeSet protocol_types = syncer::ProtocolTypes();
+  for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
+       iter.Inc()) {
+    nudge_delays_[iter.Get()] = GetDefaultDelayForType(
+        iter.Get(), TimeDelta::FromMilliseconds(minimum_nudge_delay_ms_));
+  }
+}
+
 void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
@@ -819,6 +858,22 @@ bool SyncSchedulerImpl::IsBackingOff() const {
       WaitInterval::EXPONENTIAL_BACKOFF;
 }
 
+TimeDelta SyncSchedulerImpl::GetNudgeDelayForTypes(ModelTypeSet types) const {
+  // Start with the longest delay.
+  TimeDelta delay =
+      TimeDelta::FromMilliseconds(kDefaultShortPollIntervalSeconds);
+  // Take the shorted delay from all requested types.

[rlarocque, 2014/08/20 00:13:31]

shortest?

[Nicolas Zea, 2014/08/20 22:49:43]

Done.

+  for (ModelTypeSet::Iterator iter = types.First(); iter.Good(); iter.Inc()) {
+    std::map<ModelType, TimeDelta>::const_iterator delay_iter =
+        nudge_delays_.find(iter.Get());
+    if (delay_iter != nudge_delays_.end() &&
+        delay_iter->second < delay) {
+      delay = delay_iter->second;
+    }
+  }
+  return delay;
+}
+
 void SyncSchedulerImpl::OnThrottled(const base::TimeDelta& throttle_duration) {
   DCHECK(CalledOnValidThread());
   wait_interval_.reset(new WaitInterval(WaitInterval::THROTTLED,
@@ -862,10 +917,22 @@ void SyncSchedulerImpl::OnReceivedLongPollIntervalUpdate(
   syncer_long_poll_interval_seconds_ = new_interval;
 }
 
-void SyncSchedulerImpl::OnReceivedSessionsCommitDelay(
-    const base::TimeDelta& new_delay) {
+void SyncSchedulerImpl::OnReceivedCustomNudgeDelays(
+    const std::map<ModelType, int>& nudge_delays) {

[rlarocque, 2014/08/20 00:13:31]

I'd prefer it if this parameter were a map<ModelType, TimeDelta>.  Let's not
store these time durations as ints any longer than we have to.

[Nicolas Zea, 2014/08/20 22:49:43]

Done.

   DCHECK(CalledOnValidThread());
-  sessions_commit_delay_ = new_delay;
+  for (std::map<ModelType, int>::const_iterator iter = nudge_delays.begin();
+       iter != nudge_delays.end(); ++iter) {
+    // Only accept delays that are longer or equal to the minimum delay.
+    // Otherwise reset to default for that type. This provides a way for the
+    // server to "unset" a custom nudge delay by assigning a 0 value to it.
+    if (iter->second >= minimum_nudge_delay_ms_) {
+      nudge_delays_[iter->first] = TimeDelta::FromMilliseconds(iter->second);
+    } else {
+      nudge_delays_[iter->first] = GetDefaultDelayForType(
+          iter->first,
+          base::TimeDelta::FromMilliseconds(minimum_nudge_delay_ms_));
+    }
+  }
 }
 
 void SyncSchedulerImpl::OnReceivedClientInvalidationHintBufferSize(int size) {
@@ -911,11 +978,6 @@ void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
     nudge_tracker_.OnInvalidationsDisabled();
 }
 
-base::TimeDelta SyncSchedulerImpl::GetSessionsCommitDelay() const {
-  DCHECK(CalledOnValidThread());
-  return sessions_commit_delay_;
-}
-
 #undef SDVLOG_LOC
 
 #undef SDVLOG