[Sync] Sync types never recovers from throttle

components/sync/engine_impl/sync_scheduler_impl_unittest.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 "components/sync/engine_impl/sync_scheduler_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ skipping 262 matching lines @@
 
   void NewSchedulerForLocalBackend() {
     // The old syncer is destroyed with the scheduler that owns it.
     syncer_ = new testing::StrictMock<MockSyncer>();
     scheduler_ = base::MakeUnique<SyncSchedulerImpl>(
         "TestSyncScheduler", BackoffDelayProvider::FromDefaults(), context(),
         syncer_, true);
     scheduler_->SetDefaultNudgeDelay(default_delay());
   }
 
+  bool BlockTimerIsRunning() const {
+    return scheduler_->pending_wakeup_timer_.IsRunning();
+  }
+
  private:
   syncable::Directory* directory() {
     return test_user_share_.user_share()->directory.get();
   }
 
   base::MessageLoop loop_;
   TestUserShare test_user_share_;
   CancelationSignal cancelation_signal_;
   std::unique_ptr<MockConnectionManager> connection_;
   std::unique_ptr<ModelTypeRegistry> model_type_registry_;
@@ skipping 702 matching lines @@
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(WithArg<2>(test_util::SimulatePartialFailure(types)),
                       Return(true)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(base::Time());
   scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();  // To get PerformDelayedNudge called.
   PumpLoop();  // To get TrySyncCycleJob called
   EXPECT_TRUE(GetBackedOffTypes().HasAll(types));
+  EXPECT_TRUE(BlockTimerIsRunning());
   EXPECT_FALSE(scheduler()->IsBackingOff());
   EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
 
   TimeDelta throttle1(TimeDelta::FromMilliseconds(150));
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(WithArg<2>(test_util::SimulateThrottled(throttle1)),
                       Return(false)))
       .RetiresOnSaturation();
 
   // Sync still can throttle.
   const ModelTypeSet unbacked_off_types(TYPED_URLS);
   scheduler()->ScheduleLocalNudge(unbacked_off_types, FROM_HERE);
   PumpLoop();  // TO get TypesUnblock called.
   PumpLoop();  // To get TrySyncCycleJob called.
 
   EXPECT_TRUE(GetBackedOffTypes().HasAll(types));
+  EXPECT_TRUE(BlockTimerIsRunning());
   EXPECT_FALSE(scheduler()->IsBackingOff());
   EXPECT_TRUE(scheduler()->IsCurrentlyThrottled());
 
+  // Unthrottled client, but the backingoff datatype is still in backoff and
+  // scheduled.
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillOnce(DoAll(Invoke(test_util::SimulateNormalSuccess),
+                      QuitLoopNowAction(true)));
+  RunLoop();
+  EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(types));
+  EXPECT_TRUE(BlockTimerIsRunning());
+
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerImplTest, TypeThrottlingBackingOffBlocksNudge) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_)).WillRepeatedly(Return(long_delay()));
 
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
@@ skipping 20 matching lines @@
                 Return(true)))
       .RetiresOnSaturation();
 
   scheduler()->ScheduleLocalNudge(backed_off_types, FROM_HERE);
 
   PumpLoop();  // To get PerformDelayedNudge called.
   PumpLoop();  // To get TrySyncCycleJob called
 
   EXPECT_TRUE(GetThrottledTypes().HasAll(throttled_types));
   EXPECT_TRUE(GetBackedOffTypes().HasAll(backed_off_types));
+  EXPECT_TRUE(BlockTimerIsRunning());
   EXPECT_FALSE(scheduler()->IsBackingOff());
   EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
 
   // This won't cause a sync cycle because the types are throttled or backed
   // off.
   scheduler()->ScheduleLocalNudge(Union(throttled_types, backed_off_types),
                                   FROM_HERE);
   PumpLoop();
 
   StopSyncScheduler();
@@ skipping 678 matching lines @@
   base::TimeDelta second_blocking_time = GetTypeBlockingTime(THEMES);
 
   // The Exponential backoff should be between previous backoff 1.5 and 2.5
   // times.
   EXPECT_LE(first_blocking_time * 1.5, second_blocking_time);
   EXPECT_GE(first_blocking_time * 2.5, second_blocking_time);
 
   StopSyncScheduler();
 }
 
+// If a datatype is in backoff or throttling, pending_wakeup_timer_ should
+// schedule a delay job for OnTypesUnblocked. SyncScheduler sometimes use
+// pending_wakeup_timer_ to schdule PerformDelayedNudge job before
+// OnTypesUnblocked got run. This test will verify after ran
+// PerformDelayedNudge, OnTypesUnblocked will be rescheduled if any datatype is
+// in backoff or throttling.
+TEST_F(SyncSchedulerImplTest, TypeBackoffAndSuccessfulSync) {
+  UseMockDelayProvider();
+  EXPECT_CALL(*delay(), GetDelay(_)).WillRepeatedly(Return(long_delay()));
+
+  TimeDelta poll(TimeDelta::FromDays(1));
+  scheduler()->OnReceivedLongPollIntervalUpdate(poll);
+
+  const ModelTypeSet types(THEMES);
+
+  // Set backoff datatype.
+  ::testing::InSequence seq;
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillOnce(DoAll(WithArg<2>(test_util::SimulatePartialFailure(types)),
+                      Return(true)))
+      .RetiresOnSaturation();
+
+  StartSyncScheduler(base::Time());
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
+  PumpLoop();  // To get PerformDelayedNudge called.
+  PumpLoop();  // To get TrySyncCycleJob called
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(types));
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+  EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
+
+  SyncShareTimes times;
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillOnce(DoAll(Invoke(test_util::SimulateNormalSuccess),
+                      RecordSyncShare(&times, true)))
+      .RetiresOnSaturation();
+
+  // Do a successful Sync.
+  const ModelTypeSet unbacked_off_types(TYPED_URLS);
+  scheduler()->ScheduleLocalNudge(unbacked_off_types, FROM_HERE);
+  PumpLoop();  // TO get PerformDelayedNudge called.
+  PumpLoop();  // To get TrySyncCycleJob called.
+
+  // Timer is still running for backoff datatype after Sync success.
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(types));
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+  EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
+
+  StopSyncScheduler();
+}
+
+// Verify that the timer is scheduled for an unblock job after one datatype is
+// unblocked, and there is another one still blocked.
+TEST_F(SyncSchedulerImplTest, TypeBackingOffAndFailureSync) {
+  UseMockDelayProvider();
+  EXPECT_CALL(*delay(), GetDelay(_))
+      .WillOnce(Return(long_delay()))
+      .RetiresOnSaturation();
+
+  TimeDelta poll(TimeDelta::FromDays(1));
+  scheduler()->OnReceivedLongPollIntervalUpdate(poll);
+
+  // Set a backoff datatype.
+  const ModelTypeSet themes_types(THEMES);
+  ::testing::InSequence seq;
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillOnce(
+          DoAll(WithArg<2>(test_util::SimulatePartialFailure(themes_types)),
+                Return(true)))
+      .RetiresOnSaturation();
+
+  StartSyncScheduler(base::Time());
+  scheduler()->ScheduleLocalNudge(themes_types, FROM_HERE);
+  PumpLoop();  // To get PerformDelayedNudge called.
+  PumpLoop();  // To get TrySyncCycleJob called
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(themes_types));
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+  EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
+
+  // Set anther backoff datatype.
+  const ModelTypeSet typed_urls_types(TYPED_URLS);
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillOnce(
+          DoAll(WithArg<2>(test_util::SimulatePartialFailure(typed_urls_types)),
+                Return(true)))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*delay(), GetDelay(_))
+      .WillOnce(Return(default_delay()))
+      .RetiresOnSaturation();
+
+  scheduler()->ScheduleLocalNudge(typed_urls_types, FROM_HERE);
+  PumpLoop();  // TO get PerformDelayedNudge called.
+  PumpLoop();  // To get TrySyncCycleJob called.
+
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(themes_types));
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(typed_urls_types));
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+  EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
+
+  // Unblock one datatype.
+  SyncShareTimes times;
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillRepeatedly(DoAll(Invoke(test_util::SimulateNormalSuccess),
+                            RecordSyncShare(&times, true)));
+  EXPECT_CALL(*delay(), GetDelay(_)).WillRepeatedly(Return(long_delay()));
+
+  PumpLoop();  // TO get OnTypesUnblocked called.
+  PumpLoop();  // To get TrySyncCycleJob called.
+
+  // Timer is still scheduled for another backoff datatype.
+  EXPECT_TRUE(GetBackedOffTypes().HasAll(themes_types));
+  EXPECT_FALSE(GetBackedOffTypes().HasAll(typed_urls_types));
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+  EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
+
+  StopSyncScheduler();
+}
+
 }  // namespace syncer