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

components/sync/engine_impl/cycle/nudge_tracker_unittest.cc

Index: components/sync/engine_impl/cycle/nudge_tracker_unittest.cc
diff --git a/components/sync/engine_impl/cycle/nudge_tracker_unittest.cc b/components/sync/engine_impl/cycle/nudge_tracker_unittest.cc
index 9ac27e598260aa6230b3996bd1b7518ccea577c4..8514c4b02ccb8d73d08adbd062b68bfc81c0606f 100644
--- a/components/sync/engine_impl/cycle/nudge_tracker_unittest.cc
+++ b/components/sync/engine_impl/cycle/nudge_tracker_unittest.cc
@@ -430,8 +430,8 @@ TEST_F(NudgeTrackerTest, IsGetUpdatesRequired) {
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 }
 
-// Test IsSyncRequired() responds correctly to data type throttling.
-TEST_F(NudgeTrackerTest, IsSyncRequired_Throttling) {
+// Test IsSyncRequired() responds correctly to data type throttling and backoff.
+TEST_F(NudgeTrackerTest, IsSyncRequired_Throttling_Backoff) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
   const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(10);
   const base::TimeTicks t1 = t0 + throttle_length;
@@ -445,26 +445,39 @@ TEST_F(NudgeTrackerTest, IsSyncRequired_Throttling) {
   // But the throttling of sessions unsets it.
   nudge_tracker_.SetTypesThrottledUntil(ModelTypeSet(SESSIONS), throttle_length,
                                         t0);
+  EXPECT_TRUE(nudge_tracker_.IsTypeThrottled(SESSIONS));
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
   // A refresh request for bookmarks means we have reason to sync again.
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(BOOKMARKS));
   EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
 
-  // A successful sync cycle means we took care of bookmarks.
+  // But the backoff of bookmarks unsets it.
+  nudge_tracker_.SetTypeBackedOff(BOOKMARKS, throttle_length, t0);
+  EXPECT_TRUE(nudge_tracker_.IsTypeThrottled(SESSIONS));
+  EXPECT_TRUE(nudge_tracker_.IsTypeBackedOff(BOOKMARKS));
+  EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
+
+  // A refresh request for preferences means we have reason to sync again.
+  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(PREFERENCES));
+  EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
+
+  // A successful sync cycle means we took care of preferences.
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsSyncRequired());
 
-  // But we still haven't dealt with sessions.  We'll need to remember
-  // that sessions are out of sync and re-enable the flag when their
-  // throttling interval expires.
-  nudge_tracker_.UpdateTypeThrottlingState(t1);
+  // But we still haven't dealt with sessions and bookmarks. We'll need to
+  // remember that sessions and bookmarks are out of sync and re-enable the flag
+  // when their throttling and backoff interval expires.
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t1);
   EXPECT_FALSE(nudge_tracker_.IsTypeThrottled(SESSIONS));
+  EXPECT_FALSE(nudge_tracker_.IsTypeBackedOff(BOOKMARKS));
   EXPECT_TRUE(nudge_tracker_.IsSyncRequired());
 }
 
-// Test IsGetUpdatesRequired() responds correctly to data type throttling.
-TEST_F(NudgeTrackerTest, IsGetUpdatesRequired_Throttling) {
+// Test IsGetUpdatesRequired() responds correctly to data type throttling and
+// backoff.
+TEST_F(NudgeTrackerTest, IsGetUpdatesRequired_Throttling_Backoff) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
   const base::TimeDelta throttle_length = base::TimeDelta::FromMinutes(10);
   const base::TimeTicks t1 = t0 + throttle_length;
@@ -484,15 +497,26 @@ TEST_F(NudgeTrackerTest, IsGetUpdatesRequired_Throttling) {
   nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(BOOKMARKS));
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
 
-  // A successful sync cycle means we took care of bookmarks.
+  // But the backoff of bookmarks unsets it.
+  nudge_tracker_.SetTypeBackedOff(BOOKMARKS, throttle_length, t0);
+  EXPECT_TRUE(nudge_tracker_.IsTypeThrottled(SESSIONS));
+  EXPECT_TRUE(nudge_tracker_.IsTypeBackedOff(BOOKMARKS));
+  EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
+
+  // A refresh request for preferences means we have reason to sync again.
+  nudge_tracker_.RecordLocalRefreshRequest(ModelTypeSet(PREFERENCES));
+  EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
+
+  // A successful sync cycle means we took care of preferences.
   nudge_tracker_.RecordSuccessfulSyncCycle();
   EXPECT_FALSE(nudge_tracker_.IsGetUpdatesRequired());
 
-  // But we still haven't dealt with sessions.  We'll need to remember
-  // that sessions are out of sync and re-enable the flag when their
-  // throttling interval expires.
-  nudge_tracker_.UpdateTypeThrottlingState(t1);
+  // But we still haven't dealt with sessions and bookmarks. We'll need to
+  // remember that sessions and bookmarks are out of sync and re-enable the flag
+  // when their throttling and backoff interval expires.
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t1);
   EXPECT_FALSE(nudge_tracker_.IsTypeThrottled(SESSIONS));
+  EXPECT_FALSE(nudge_tracker_.IsTypeBackedOff(BOOKMARKS));
   EXPECT_TRUE(nudge_tracker_.IsGetUpdatesRequired());
 }
 
@@ -503,6 +527,13 @@ TEST_F(NudgeTrackerTest, NoTypesThrottled) {
   EXPECT_TRUE(nudge_tracker_.GetThrottledTypes().Empty());
 }
 
+// Tests backoff-related getter functions when no types are backed off.
+TEST_F(NudgeTrackerTest, NoTypesBackedOff) {
+  EXPECT_FALSE(nudge_tracker_.IsAnyTypeBackedOff());
+  EXPECT_FALSE(nudge_tracker_.IsTypeBackedOff(SESSIONS));
+  EXPECT_TRUE(nudge_tracker_.GetBackedOffTypes().Empty());
+}
+
 // Tests throttling-related getter functions when some types are throttled.
 TEST_F(NudgeTrackerTest, ThrottleAndUnthrottle) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
@@ -518,13 +549,35 @@ TEST_F(NudgeTrackerTest, ThrottleAndUnthrottle) {
   EXPECT_FALSE(nudge_tracker_.GetThrottledTypes().Empty());
   EXPECT_EQ(throttle_length, nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
 
-  nudge_tracker_.UpdateTypeThrottlingState(t1);
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t1);
 
   EXPECT_FALSE(nudge_tracker_.IsAnyTypeThrottled());
   EXPECT_FALSE(nudge_tracker_.IsTypeThrottled(SESSIONS));
   EXPECT_TRUE(nudge_tracker_.GetThrottledTypes().Empty());
 }
 
+// Tests backoff-related getter functions when some types are backed off.
+TEST_F(NudgeTrackerTest, BackoffAndUnbackoff) {
+  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
+  const base::TimeDelta backoff_length = base::TimeDelta::FromMinutes(10);
+  const base::TimeTicks t1 = t0 + backoff_length;
+
+  nudge_tracker_.SetTypeBackedOff(SESSIONS, backoff_length, t0);
+  nudge_tracker_.SetTypeBackedOff(PREFERENCES, backoff_length, t0);
+
+  EXPECT_TRUE(nudge_tracker_.IsAnyTypeBackedOff());
+  EXPECT_TRUE(nudge_tracker_.IsTypeBackedOff(SESSIONS));
+  EXPECT_TRUE(nudge_tracker_.IsTypeBackedOff(PREFERENCES));
+  EXPECT_FALSE(nudge_tracker_.GetBackedOffTypes().Empty());
+  EXPECT_EQ(backoff_length, nudge_tracker_.GetTimeUntilNextUnbackoff(t0));
+
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t1);
+
+  EXPECT_FALSE(nudge_tracker_.IsAnyTypeBackedOff());
+  EXPECT_FALSE(nudge_tracker_.IsTypeBackedOff(SESSIONS));
+  EXPECT_TRUE(nudge_tracker_.GetBackedOffTypes().Empty());
+}
+
 TEST_F(NudgeTrackerTest, OverlappingThrottleIntervals) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
   const base::TimeDelta throttle1_length = base::TimeDelta::FromMinutes(10);
@@ -547,7 +600,7 @@ TEST_F(NudgeTrackerTest, OverlappingThrottleIntervals) {
   EXPECT_EQ(throttle1_length, nudge_tracker_.GetTimeUntilNextUnthrottle(t0));
 
   // Expire the first interval.
-  nudge_tracker_.UpdateTypeThrottlingState(t1);
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t1);
 
   // SESSIONS appeared in both intervals.  We expect it will be throttled for
   // the longer of the two, so it's still throttled at time t1.
@@ -557,10 +610,46 @@ TEST_F(NudgeTrackerTest, OverlappingThrottleIntervals) {
             nudge_tracker_.GetTimeUntilNextUnthrottle(t1));
 
   // Expire the second interval.
-  nudge_tracker_.UpdateTypeThrottlingState(t2);
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t2);
   EXPECT_TRUE(nudge_tracker_.GetThrottledTypes().Empty());
 }
 
+TEST_F(NudgeTrackerTest, OverlappingBackoffIntervals) {
+  const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(1234);
+  const base::TimeDelta backoff1_length = base::TimeDelta::FromMinutes(10);
+  const base::TimeDelta backoff2_length = base::TimeDelta::FromMinutes(20);
+  const base::TimeTicks t1 = t0 + backoff1_length;
+  const base::TimeTicks t2 = t0 + backoff2_length;
+
+  // Setup the longer of two intervals.
+  nudge_tracker_.SetTypeBackedOff(SESSIONS, backoff2_length, t0);
+  nudge_tracker_.SetTypeBackedOff(PREFERENCES, backoff2_length, t0);
+  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
+                                 nudge_tracker_.GetBackedOffTypes()));
+  EXPECT_EQ(backoff2_length, nudge_tracker_.GetTimeUntilNextUnbackoff(t0));
+
+  // Setup the shorter interval.
+  nudge_tracker_.SetTypeBackedOff(SESSIONS, backoff1_length, t0);
+  nudge_tracker_.SetTypeBackedOff(BOOKMARKS, backoff1_length, t0);
+  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES, BOOKMARKS),
+                                 nudge_tracker_.GetBackedOffTypes()));
+  EXPECT_EQ(backoff1_length, nudge_tracker_.GetTimeUntilNextUnbackoff(t0));
+
+  // Expire the first interval.
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t1);
+
+  // SESSIONS appeared in both intervals.  We expect it will be backed off for
+  // the longer of the two, so it's still backed off at time t1.
+  EXPECT_TRUE(ModelTypeSetEquals(ModelTypeSet(SESSIONS, PREFERENCES),
+                                 nudge_tracker_.GetBackedOffTypes()));
+  EXPECT_EQ(backoff2_length - backoff1_length,
+            nudge_tracker_.GetTimeUntilNextUnbackoff(t1));
+
+  // Expire the second interval.
+  nudge_tracker_.UpdateTypeThrottlingAndBackoffState(t2);
+  EXPECT_TRUE(nudge_tracker_.GetBackedOffTypes().Empty());
+}
+
 TEST_F(NudgeTrackerTest, Retry) {
   const base::TimeTicks t0 = base::TimeTicks::FromInternalValue(12345);
   const base::TimeTicks t3 = t0 + base::TimeDelta::FromSeconds(3);