[Sync] Add support for server controlled nudge delays

sync/sessions/nudge_tracker.cc

 // Copyright (c) 2013 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/sessions/nudge_tracker.h"
 
 #include "base/basictypes.h"
+#include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace syncer {
 namespace sessions {
 
+namespace {
+
+// Delays for syncer nudges.
+const int kDefaultNudgeDelayMilliseconds = 200;
+const int kSlowNudgeDelayMilliseconds = 2000;
+const int kDefaultSessionsCommitDelaySeconds = 10;
+const int kSyncRefreshDelayMsec = 500;

[rlarocque, 2014/08/21 17:24:53]

nit: It would be nice if the Msec vs. Millisecond suffix were consistent.

+const int kSyncSchedulerDelayMsec = 250;
+
+base::TimeDelta GetDefaultDelayForType(ModelType model_type,
+                                       base::TimeDelta minimum_delay) {
+  switch (model_type) {
+   case AUTOFILL:
+     // Accompany types rely on nudges from other types, and hence have long
+     // nudge delays.
+     return base::TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds);
+   case BOOKMARKS:
+   case PREFERENCES:
+     // Types with sometimes automatic changes get longer delays to allow more
+     // coalescing.
+     return base::TimeDelta::FromMilliseconds(kSlowNudgeDelayMilliseconds);
+   case SESSIONS:
+   case FAVICON_IMAGES:
+   case FAVICON_TRACKING:
+     // Types with navigation triggered changes get longer delays to allow more
+     // coalescing.
+     return base::TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds);
+   default:
+     return minimum_delay;
+  }
+}
+
+}  // namespace
+
 size_t NudgeTracker::kDefaultMaxPayloadsPerType = 10;
 
 NudgeTracker::NudgeTracker()
     : type_tracker_deleter_(&type_trackers_),
       invalidations_enabled_(false),
-      invalidations_out_of_sync_(true) {
+      invalidations_out_of_sync_(true),
+      minimum_local_nudge_delay_(
+          base::TimeDelta::FromMilliseconds(kDefaultNudgeDelayMilliseconds)),
+      local_refresh_nudge_delay_(
+          base::TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec)),
+      remote_invalidation_nudge_delay_(
+          base::TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec)) {
   ModelTypeSet protocol_types = ProtocolTypes();
   // Default initialize all the type trackers.
   for (ModelTypeSet::Iterator it = protocol_types.First(); it.Good();
        it.Inc()) {
     type_trackers_.insert(std::make_pair(it.Get(), new DataTypeTracker()));
   }
 }
 
 NudgeTracker::~NudgeTracker() { }
 
@@ skipping 44 matching lines @@
 
   // A successful cycle while invalidations are enabled puts us back into sync.
   invalidations_out_of_sync_ = !invalidations_enabled_;
 
   for (TypeTrackerMap::iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second->RecordSuccessfulSyncCycle();
   }
 }
 
-void NudgeTracker::RecordLocalChange(ModelTypeSet types) {
+base::TimeDelta NudgeTracker::RecordLocalChange(ModelTypeSet types) {
+  // Start with the longest delay.
+  base::TimeDelta delay =
+      base::TimeDelta::FromMilliseconds(kDefaultShortPollIntervalSeconds);
   for (ModelTypeSet::Iterator type_it = types.First(); type_it.Good();
        type_it.Inc()) {
     TypeTrackerMap::iterator tracker_it = type_trackers_.find(type_it.Get());
     DCHECK(tracker_it != type_trackers_.end());
-    tracker_it->second->RecordLocalChange();
+
+    // Only if the type tracker has a valid delay (non-zero) that is shorter
+    // than the calculated delay do we update the calculated delay.
+    base::TimeDelta type_delay = tracker_it->second->RecordLocalChange();
+    if (type_delay == base::TimeDelta()) {
+      type_delay = GetDefaultDelayForType(type_it.Get(),
+                                          minimum_local_nudge_delay_);
+    }
+    if (type_delay < delay)
+      delay = type_delay;
   }
+  return delay;
 }
 
-void NudgeTracker::RecordLocalRefreshRequest(ModelTypeSet types) {
+base::TimeDelta NudgeTracker::RecordLocalRefreshRequest(ModelTypeSet types) {
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     TypeTrackerMap::iterator tracker_it = type_trackers_.find(it.Get());
     DCHECK(tracker_it != type_trackers_.end());
     tracker_it->second->RecordLocalRefreshRequest();
   }
+  return local_refresh_nudge_delay_;
 }
 
-void NudgeTracker::RecordRemoteInvalidation(
+base::TimeDelta NudgeTracker::RecordRemoteInvalidation(
     syncer::ModelType type,
     scoped_ptr<InvalidationInterface> invalidation) {
   // Forward the invalidations to the proper recipient.
   TypeTrackerMap::iterator tracker_it = type_trackers_.find(type);
   DCHECK(tracker_it != type_trackers_.end());
   tracker_it->second->RecordRemoteInvalidation(invalidation.Pass());
+  return remote_invalidation_nudge_delay_;
 }
 
 void NudgeTracker::RecordInitialSyncRequired(syncer::ModelType type) {
   TypeTrackerMap::iterator tracker_it = type_trackers_.find(type);
   DCHECK(tracker_it != type_trackers_.end());
   tracker_it->second->RecordInitialSyncRequired();
 }
 
 void NudgeTracker::OnInvalidationsEnabled() {
   invalidations_enabled_ = true;
@@ skipping 193 matching lines @@
   for (TypeTrackerMap::iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     it->second->UpdatePayloadBufferSize(size);
   }
 }
 
 void NudgeTracker::SetNextRetryTime(base::TimeTicks retry_time) {
   next_retry_time_ = retry_time;
 }
 
+void NudgeTracker::OnReceivedCustomNudgeDelays(
+    const std::map<ModelType, base::TimeDelta>& delay_map) {
+  for (std::map<ModelType, base::TimeDelta>::const_iterator iter =
+           delay_map.begin();
+       iter != delay_map.end();
+       ++iter) {
+    ModelType type = iter->first;
+    DCHECK(syncer::ProtocolTypes().Has(type));
+    TypeTrackerMap::iterator type_iter = type_trackers_.find(type);
+    if (type_iter == type_trackers_.end())
+      continue;
+
+    if (iter->second > minimum_local_nudge_delay_) {
+      type_iter->second->UpdateLocalNudgeDelay(iter->second);
+    } else {
+      type_iter->second->UpdateLocalNudgeDelay(
+          GetDefaultDelayForType(type,
+                                 minimum_local_nudge_delay_));
+    }
+  }
+}
+
+void NudgeTracker::SetDefaultNudgeDelay(base::TimeDelta nudge_delay) {
+  minimum_local_nudge_delay_ = nudge_delay;
+}
+
 }  // namespace sessions
 }  // namespace syncer