[Sync] Stop dropping pending restarts from interleaved nudges.

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 65 matching lines @@
 
 void PumpLoop() {
   // Do it this way instead of RunAllPending to pump loop exactly once
   // (necessary in the presence of timers; see comment in
   // QuitLoopNow).
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(&QuitLoopNow));
   RunLoop();
 }
 
-void PumpLoopFor(base::TimeDelta time) {
+void PumpLoopFor(TimeDelta time) {
   // Allow the loop to run for the specified amount of time.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&QuitLoopNow), time);
   RunLoop();
 }
 
 static const size_t kMinNumSamples = 5;
 
 // Test harness for the SyncScheduler.  Test the delays and backoff timers used
 // in response to various events.
@@ skipping 141 matching lines @@
         backed_off_types.Put(type_it.Get());
       }
     }
     return backed_off_types;
   }
 
   bool IsAnyTypeBlocked() {
     return scheduler_->nudge_tracker_.IsAnyTypeBlocked();
   }
 
-  base::TimeDelta GetRetryTimerDelay() {
+  TimeDelta GetRetryTimerDelay() {
     EXPECT_TRUE(scheduler_->retry_timer_.IsRunning());
     return scheduler_->retry_timer_.GetCurrentDelay();
   }
 
   static std::unique_ptr<InvalidationInterface> BuildInvalidation(
       int64_t version,
       const std::string& payload) {
     return MockInvalidation::Build(version, payload);
   }
 
-  base::TimeDelta GetTypeBlockingTime(ModelType type) {
+  TimeDelta GetTypeBlockingTime(ModelType type) {
     NudgeTracker::TypeTrackerMap::const_iterator tracker_it =
         scheduler_->nudge_tracker_.type_trackers_.find(type);
     DCHECK(tracker_it != scheduler_->nudge_tracker_.type_trackers_.end());
     DCHECK(tracker_it->second->wait_interval_.get());
     return tracker_it->second->wait_interval_->length;
   }
 
   void SetTypeBlockingMode(ModelType type, WaitInterval::BlockingMode mode) {
     NudgeTracker::TypeTrackerMap::const_iterator tracker_it =
         scheduler_->nudge_tracker_.type_trackers_.find(type);
     DCHECK(tracker_it != scheduler_->nudge_tracker_.type_trackers_.end());
     DCHECK(tracker_it->second->wait_interval_.get());
     tracker_it->second->wait_interval_->mode = mode;
   }
 
   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();
   }
 
+  TimeDelta GetPendingWakeupTimerDelay() {
+    EXPECT_TRUE(scheduler_->pending_wakeup_timer_.IsRunning());
+    return scheduler_->pending_wakeup_timer_.GetCurrentDelay();
+  }
+
  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 409 matching lines @@
   EXPECT_CALL(*syncer(), PollSyncShare(_, _))
       .Times(AtLeast(kMinNumSamples))
       .WillRepeatedly(
           DoAll(Invoke(test_util::SimulatePollSuccess),
                 RecordSyncShareMultiple(&times, kMinNumSamples, true)));
 
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
 
   // Set the start time to |poll_interval| in the future.
   TimeTicks optimal_start = TimeTicks::Now() + poll_interval;
-  StartSyncScheduler(base::Time::Now() + base::TimeDelta::FromMinutes(10));
+  StartSyncScheduler(base::Time::Now() + TimeDelta::FromMinutes(10));
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(times, kMinNumSamples, optimal_start, poll_interval);
 }
 
 // Test that the short poll interval is used.
 TEST_F(SyncSchedulerImplTest, PollNotificationsDisabled) {
@@ skipping 713 matching lines @@
   // Now let the Poll timer do its thing.
   EXPECT_CALL(*syncer(), PollSyncShare(_, _))
       .WillRepeatedly(
           DoAll(Invoke(test_util::SimulatePollSuccess),
                 RecordSyncShareMultiple(&times, kMinNumSamples, true)));
   const TimeDelta poll(TimeDelta::FromMilliseconds(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   // The new optimal time is now, since the desired poll should have happened
   // in the past.
-  optimal_job_time = base::TimeTicks::Now();
+  optimal_job_time = TimeTicks::Now();
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
   ASSERT_EQ(kMinNumSamples, times.size());
   for (size_t i = 2; i < times.size(); i++) {
     SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
     EXPECT_GE(times[i], optimal_job_time);
     optimal_job_time = optimal_job_time + poll;
   }
 
   StopSyncScheduler();
@@ skipping 158 matching lines @@
   scheduler()->OnCredentialsUpdated();
   connection()->SetServerStatus(HttpResponse::SERVER_CONNECTION_OK);
   RunLoop();
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerImplTest, SuccessfulRetry) {
   StartSyncScheduler(base::Time());
 
   SyncShareTimes times;
-  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
+  TimeDelta delay = TimeDelta::FromMilliseconds(10);
   scheduler()->OnReceivedGuRetryDelay(delay);
   EXPECT_EQ(delay, GetRetryTimerDelay());
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times, true)));
 
   // Run to wait for retrying.
   RunLoop();
 
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerImplTest, FailedRetry) {
   SyncShareTimes times;
 
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(10)));
 
   StartSyncScheduler(base::Time());
 
-  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);
+  TimeDelta delay = TimeDelta::FromMilliseconds(10);
   scheduler()->OnReceivedGuRetryDelay(delay);
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(test_util::SimulateDownloadUpdatesFailed),
                       RecordSyncShare(&times, false)));
 
   // Run to wait for retrying.
   RunLoop();
 
   EXPECT_TRUE(scheduler()->IsBackingOff());
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times, true)));
 
   // Run to wait for second retrying.
   RunLoop();
 
   StopSyncScheduler();
 }
 
 ACTION_P2(VerifyRetryTimerDelay, scheduler_test, expected_delay) {
   EXPECT_EQ(expected_delay, scheduler_test->GetRetryTimerDelay());
 }
 
 TEST_F(SyncSchedulerImplTest, ReceiveNewRetryDelay) {
   StartSyncScheduler(base::Time());
 
   SyncShareTimes times;
-  base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(100);
-  base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(200);
+  TimeDelta delay1 = TimeDelta::FromMilliseconds(100);
+  TimeDelta delay2 = TimeDelta::FromMilliseconds(200);
 
   scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   scheduler()->OnReceivedGuRetryDelay(delay1);
   EXPECT_EQ(delay1, GetRetryTimerDelay());
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(
           DoAll(WithoutArgs(VerifyRetryTimerDelay(this, delay1)),
                 WithArg<2>(test_util::SimulateGuRetryDelayCommand(delay2)),
                 RecordSyncShare(&times, true)));
@@ skipping 60 matching lines @@
           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_FALSE(scheduler()->IsBackingOff());
   EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
-  base::TimeDelta first_blocking_time = GetTypeBlockingTime(THEMES);
+  TimeDelta first_blocking_time = GetTypeBlockingTime(THEMES);
 
   SetTypeBlockingMode(THEMES, WaitInterval::EXPONENTIAL_BACKOFF_RETRYING);
   // This won't cause a sync cycle because the types are backed off.
   scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();
   PumpLoop();
-  base::TimeDelta second_blocking_time = GetTypeBlockingTime(THEMES);
+  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
@@ skipping 111 matching lines @@
   // 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();
 }
 
+TEST_F(SyncSchedulerImplTest, InterleavedNudgesStillRestart) {
+  UseMockDelayProvider();
+  EXPECT_CALL(*delay(), GetDelay(_))
+      .WillOnce(Return(long_delay()))
+      .RetiresOnSaturation();
+  TimeDelta poll(TimeDelta::FromDays(1));
+  scheduler()->OnReceivedLongPollIntervalUpdate(poll);
+
+  StartSyncScheduler(base::Time());
+  scheduler()->ScheduleLocalNudge({THEMES}, FROM_HERE);
+  PumpLoop();  // To get PerformDelayedNudge called.
+  EXPECT_FALSE(BlockTimerIsRunning());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+
+  // This is the tricky piece. We have a gap while the sync job is bouncing to
+  // get onto the |pending_wakeup_timer_|, should be scheduled with no delay.
+  scheduler()->ScheduleLocalNudge({TYPED_URLS}, FROM_HERE);
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_EQ(TimeDelta(), GetPendingWakeupTimerDelay());
+  EXPECT_FALSE(scheduler()->IsBackingOff());
+
+  // Setup mock as we're about to attempt to sync.
+  SyncShareTimes times;
+  EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
+      .WillOnce(DoAll(Invoke(test_util::SimulateCommitFailed),
+                      RecordSyncShare(&times, false)));
+  // Triggers the THEMES TrySyncCycleJobImpl(), which we've setup to fail. Its
+  // RestartWaiting won't schedule a delayed retry, as the TYPED_URLS nudge has
+  // a smaller delay. We verify this by making sure the delay is still zero.
+  PumpLoop();
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_EQ(TimeDelta(), GetPendingWakeupTimerDelay());
+  EXPECT_TRUE(scheduler()->IsBackingOff());
+
+  // Triggers TYPED_URLS PerformDelayedNudge(), which should no-op, because
+  // we're no long healthy, and normal priorities shouldn't go through, but it
+  // does need to setup the |pending_wakeup_timer_|. The delay should be ~60
+  // seconds, so verifying it's greater than 50 should be safe.
+  PumpLoop();
+  EXPECT_TRUE(BlockTimerIsRunning());
+  EXPECT_LT(TimeDelta::FromSeconds(50), GetPendingWakeupTimerDelay());
+  EXPECT_TRUE(scheduler()->IsBackingOff());
+}
+
 }  // namespace syncer