[Sync] Sync client should to exponential backoff when receive partial failure

components/sync/engine_impl/cycle/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 "components/sync/engine_impl/cycle/nudge_tracker.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "components/sync/engine/polling_constants.h"
@@ skipping 171 matching lines @@
 
 void NudgeTracker::SetTypesThrottledUntil(ModelTypeSet types,
                                           base::TimeDelta length,
                                           base::TimeTicks now) {
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(it.Get());
     tracker_it->second->ThrottleType(length, now);
   }
 }
 
-void NudgeTracker::UpdateTypeThrottlingState(base::TimeTicks now) {
+void NudgeTracker::SetTypeBackedOff(ModelType type,
+                                    base::TimeDelta length,
+                                    base::TimeTicks now) {
+  TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(type);
+  DCHECK(tracker_it != type_trackers_.end());
+  tracker_it->second->BackOffType(length, now);
+}
+
+void NudgeTracker::UpdateTypeThrottlingAndBackoffState() {
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
-    it->second->UpdateThrottleState(now);
+    it->second->UpdateThrottleOrBackoffState();
   }
 }
 
-bool NudgeTracker::IsAnyTypeThrottled() const {
+bool NudgeTracker::IsAnyTypeBlocked() const {
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
-    if (it->second->IsThrottled()) {
+    if (it->second->IsBlocked()) {
       return true;
     }
   }
   return false;
 }
 
-bool NudgeTracker::IsTypeThrottled(ModelType type) const {
+bool NudgeTracker::IsTypeBlocked(ModelType type) const {
   DCHECK(type_trackers_.find(type) != type_trackers_.end());
-  return type_trackers_.find(type)->second->IsThrottled();
+  return type_trackers_.find(type)->second->IsBlocked();
 }
 
-base::TimeDelta NudgeTracker::GetTimeUntilNextUnthrottle(
-    base::TimeTicks now) const {
-  DCHECK(IsAnyTypeThrottled()) << "This function requires a pending unthrottle";
+WaitInterval::BlockingMode NudgeTracker::GetTypeBlockingMode(
+    ModelType type) const {
+  DCHECK(type_trackers_.find(type) != type_trackers_.end());
+  return type_trackers_.find(type)->second->GetBlockingMode();
+}
 
-  // Return min of GetTimeUntilUnthrottle() values for all IsThrottled() types.
-  base::TimeDelta time_until_next_unthrottle = base::TimeDelta::Max();
+base::TimeDelta NudgeTracker::GetTimeUntilNextUnblock() const {
+  DCHECK(IsAnyTypeBlocked()) << "This function requires a pending unblock.";
+
+  // Return min of GetTimeUntilUnblock() values for all IsBlocked() types.
+  base::TimeDelta time_until_next_unblock = base::TimeDelta::Max();
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
-    if (it->second->IsThrottled()) {
-      time_until_next_unthrottle = std::min(
-          time_until_next_unthrottle, it->second->GetTimeUntilUnthrottle(now));
+    if (it->second->IsBlocked()) {
+      time_until_next_unblock =
+          std::min(time_until_next_unblock, it->second->GetTimeUntilUnblock());
     }
   }
-  DCHECK(!time_until_next_unthrottle.is_max());
+  DCHECK(!time_until_next_unblock.is_max());
 
-  return time_until_next_unthrottle;
+  return time_until_next_unblock;
 }
 
-ModelTypeSet NudgeTracker::GetThrottledTypes() const {
+base::TimeDelta NudgeTracker::GetTypeLastBackoffInterval(ModelType type) const {
+  TypeTrackerMap::const_iterator tracker_it = type_trackers_.find(type);
+  if (tracker_it != type_trackers_.end()) {
+    NOTREACHED();
+    return base::TimeDelta::FromSeconds(0);
+  }
+
+  return tracker_it->second->GetLastBackoffInterval();
+}
+
+ModelTypeSet NudgeTracker::GetBlockedTypes() const {
   ModelTypeSet result;
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
-    if (it->second->IsThrottled()) {
+    if (it->second->IsBlocked()) {
       result.Put(it->first);
     }
   }
   return result;
 }
 
 ModelTypeSet NudgeTracker::GetNudgedTypes() const {
   ModelTypeSet result;
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
@@ skipping 44 matching lines @@
   // favor of 'origin'.
   bool has_invalidation_pending = false;
   bool has_refresh_request_pending = false;
   bool has_commit_pending = false;
   bool is_initial_sync_required = false;
   bool has_retry = IsRetryRequired();
 
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     const DataTypeTracker& tracker = *it->second;
-    if (!tracker.IsThrottled() && tracker.HasPendingInvalidation()) {
+    if (!tracker.IsBlocked() && tracker.HasPendingInvalidation()) {
       has_invalidation_pending = true;
     }
-    if (!tracker.IsThrottled() && tracker.HasRefreshRequestPending()) {
+    if (!tracker.IsBlocked() && tracker.HasRefreshRequestPending()) {
       has_refresh_request_pending = true;
     }
-    if (!tracker.IsThrottled() && tracker.HasLocalChangePending()) {
+    if (!tracker.IsBlocked() && tracker.HasLocalChangePending()) {
       has_commit_pending = true;
     }
-    if (!tracker.IsThrottled() && tracker.IsInitialSyncRequired()) {
+    if (!tracker.IsBlocked() && tracker.IsInitialSyncRequired()) {
       is_initial_sync_required = true;
     }
   }
 
   if (has_invalidation_pending) {
     return sync_pb::GetUpdatesCallerInfo::NOTIFICATION;
   } else if (has_refresh_request_pending) {
     return sync_pb::GetUpdatesCallerInfo::DATATYPE_REFRESH;
   } else if (is_initial_sync_required) {
     // Not quite accurate, but good enough for our purposes.  This setting of
@@ skipping 71 matching lines @@
           GetDefaultDelayForType(type, minimum_local_nudge_delay_));
     }
   }
 }
 
 void NudgeTracker::SetDefaultNudgeDelay(base::TimeDelta nudge_delay) {
   minimum_local_nudge_delay_ = nudge_delay;
 }
 
 }  // namespace syncer