[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 {
 
+// 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:
     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);
 }
+
+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()
     : 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)),
+      minimum_nudge_delay_ms_(kDefaultNudgeDelayMilliseconds),
       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(
       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() {
   DCHECK(CalledOnValidThread());
   Stop();
 }
 
 void SyncSchedulerImpl::OnCredentialsUpdated() {
   DCHECK(CalledOnValidThread());
 
@@ skipping 162 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);
+  ScheduleNudgeImpl(GetNudgeDelayForTypes(types), 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);
+  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) {
   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);
+  ScheduleNudgeImpl(base::TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
+                    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(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));
 
   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 338 matching lines @@
                     *session_context_->listeners(),
                     OnThrottledTypesChanged(types));
 }
 
 bool SyncSchedulerImpl::IsBackingOff() const {
   DCHECK(CalledOnValidThread());
   return wait_interval_.get() && wait_interval_->mode ==
       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,
                                         throttle_duration));
   NotifyRetryTime(base::Time::Now() + wait_interval_->length);
   NotifyThrottledTypesChanged(ModelTypeSet::All());
 }
 
 void SyncSchedulerImpl::OnTypesThrottled(
     ModelTypeSet types,
@@ skipping 23 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, 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) {
   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