[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 {
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     if (it->second->IsThrottled()) {
       return true;
     }
   }
   return false;
 }
 
+bool NudgeTracker::IsAnyTypeBackedOff() const {
+  for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
+       it != type_trackers_.end(); ++it) {
+    if (it->second->IsBackedOff()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 bool NudgeTracker::IsTypeThrottled(ModelType type) const {
   DCHECK(type_trackers_.find(type) != type_trackers_.end());
   return type_trackers_.find(type)->second->IsThrottled();
 }
 
-base::TimeDelta NudgeTracker::GetTimeUntilNextUnthrottle(
-    base::TimeTicks now) const {
-  DCHECK(IsAnyTypeThrottled()) << "This function requires a pending unthrottle";
+bool NudgeTracker::IsTypeBackedOff(ModelType type) const {
+  DCHECK(type_trackers_.find(type) != type_trackers_.end());
+  return type_trackers_.find(type)->second->IsBackedOff();
+}
 
-  // Return min of GetTimeUntilUnthrottle() values for all IsThrottled() types.
-  base::TimeDelta time_until_next_unthrottle = base::TimeDelta::Max();
+base::TimeDelta NudgeTracker::GetTimeUntilNextUnblock() const {
+  DCHECK(IsAnyTypeThrottled() || IsAnyTypeBackedOff())
+      << "This function requires a pending unthrottle or unbackoff";
+
+  // Return min of GetTimeUntilUnblock() values for all IsThrottled() and
+  // IsBackedOff() 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->IsThrottled() || it->second->IsBackedOff()) {
+      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;
+}
+
+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::GetThrottledTypes() const {
   ModelTypeSet result;
   for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
        it != type_trackers_.end(); ++it) {
     if (it->second->IsThrottled()) {
       result.Put(it->first);
     }
   }
   return result;
 }
 
+ModelTypeSet NudgeTracker::GetBackedOffTypes() const {
+  ModelTypeSet result;
+  for (TypeTrackerMap::const_iterator it = type_trackers_.begin();
+       it != type_trackers_.end(); ++it) {
+    if (it->second->IsBackedOff()) {
+      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) {
     if (it->second->HasLocalChangePending()) {
       result.Put(it->first);
     }
   }
   return result;
 }
@@ skipping 139 matching lines @@
           GetDefaultDelayForType(type, minimum_local_nudge_delay_));
     }
   }
 }
 
 void NudgeTracker::SetDefaultNudgeDelay(base::TimeDelta nudge_delay) {
   minimum_local_nudge_delay_ = nudge_delay;
 }
 
 }  // namespace syncer