Fix the drift in repeating timers.

Source/platform/TimerTest.cpp

 // Copyright 2015 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 "config.h"
 #include "platform/Timer.h"
 
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
@@ skipping 117 matching lines @@
             if (m_timerTasks.top().runTimeSecs() > deadline) {
                 gCurrentTimeSecs = deadline;
                 break;
             }
             gCurrentTimeSecs = m_timerTasks.top().runTimeSecs();
             m_timerTasks.top().run();
             m_timerTasks.pop();
         }
     }
 
+    void runPendingTasks()
+    {
+        while (!m_timerTasks.empty() && m_timerTasks.top().runTimeSecs() <= gCurrentTimeSecs) {
+            m_timerTasks.top().run();
+            m_timerTasks.pop();
+        }
+    }
+
     bool hasOneTimerTask() const
     {
         return m_timerTasks.size() == 1;
     }
 
     long nextTimerTaskDelayMillis() const
     {
         ASSERT(hasOneTimerTask());
         return m_timerTasks.top().delayMs();
     }
@@ skipping 69 matching lines @@
     {
         static const unsigned char enabled[] = {0};
         return enabled;
     }
 
     void runUntilIdle()
     {
         mockScheduler()->runUntilIdle();
     }
 
+    void runPendingTasks()
+    {
+        mockScheduler()->runPendingTasks();
+    }
+
     void runUntilIdleOrDeadlinePassed(double deadline)
     {
         mockScheduler()->runUntilIdleOrDeadlinePassed(deadline);
     }
 
     bool hasOneTimerTask() const
     {
         return mockScheduler()->hasOneTimerTask();
     }
 
@@ skipping 28 matching lines @@
     void TearDown() override
     {
         Platform::initialize(m_oldPlatform);
     }
 
     void countingTask(Timer<TimerTest>*)
     {
         m_runTimes.push_back(monotonicallyIncreasingTime());
     }
 
+    void recordNextFireTimeTask(Timer<TimerTest>* timer)
+    {
+        m_nextFireTimes.push_back(monotonicallyIncreasingTime() + timer->nextFireInterval());
+    }
+
     void advanceTimeBy(double timeSecs)
     {
         gCurrentTimeSecs += timeSecs;
     }
 
     void runUntilIdle()
     {
         m_platform->runUntilIdle();
     }
 
+    void runPendingTasks()
+    {
+        m_platform->runPendingTasks();
+    }
+
     void runUntilIdleOrDeadlinePassed(double deadline)
     {
         m_platform->runUntilIdleOrDeadlinePassed(deadline);
     }
 
     bool hasOneTimerTask() const
     {
         return m_platform->hasOneTimerTask();
     }
 
     long nextTimerTaskDelayMillis() const
     {
         return m_platform->nextTimerTaskDelayMillis();
     }
 
 protected:
     double m_startTime;
     std::vector<double> m_runTimes;
+    std::vector<double> m_nextFireTimes;
 
 private:
     OwnPtr<TimerTestPlatform> m_platform;
     Platform* m_oldPlatform;
 };
 
 TEST_F(TimerTest, StartOneShot_Zero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(0, FROM_HERE);
@@ skipping 416 matching lines @@
     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 
     timer.setAlignedFireTime(m_startTime);
     timer.didChangeAlignmentInterval(monotonicallyIncreasingTime());
 
     EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 }
 
+TEST_F(TimerTest, RepeatingTimerDoesNotDrift)
+{
+    Timer<TimerTest> timer(this, &TimerTest::recordNextFireTimeTask);
+    timer.startRepeating(2.0, FROM_HERE);
+
+    ASSERT(hasOneTimerTask());
+    recordNextFireTimeTask(&timer); // Scheduled to run at m_startTime + 2.0
+
+    advanceTimeBy(2.0);
+    runPendingTasks(); // Scheduled to run at m_startTime + 4.0
+
+    advanceTimeBy(2.1);
+    runPendingTasks(); // Scheduled to run at m_startTime + 6.0
+
+    advanceTimeBy(2.9);
+    runPendingTasks(); // Scheduled to run at m_startTime + 8.0
+
+    advanceTimeBy(3.1);
+    runPendingTasks(); // Scheduled to run at m_startTime + 12.0 (skips a beat)
+
+    advanceTimeBy(4.0);
+    runPendingTasks(); // Scheduled to run at m_startTime + 16.0 (skips a beat)
+
+    advanceTimeBy(10.0); // Scheduled to run at m_startTime + 22.0 (skips a few beats)
+    runPendingTasks();
+
+    runUntilIdleOrDeadlinePassed(m_startTime + 5.5);
+    EXPECT_THAT(m_nextFireTimes, ElementsAre(
+        m_startTime + 2.0,
+        m_startTime + 4.0,
+        m_startTime + 6.0,
+        m_startTime + 8.0,
+        m_startTime + 12.0,
+        m_startTime + 16.0,
+        m_startTime + 26.0));
+}
 
 } // namespace
 } // namespace blink