Make WTF::Vector work with gmock matchers, refactor some tests to use it

third_party/WebKit/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 @@
         return nullptr;
     }
 
     void postTimerTaskAt(const WebTraceLocation&, WebTaskRunner::Task* task, double monotonicTime) override
     {
         m_timerTasks.push(DelayedTask(task, (monotonicTime - monotonicallyIncreasingTime()) * 1000));
     }
 
     void runUntilIdle()
     {
-        while (!m_timerTasks.empty()) {
+        while (m_timerTasks.size()) {
             gCurrentTimeSecs = m_timerTasks.top().runTimeSeconds();
             m_timerTasks.top().run();
             m_timerTasks.pop();
         }
     }
 
     void runUntilIdleOrDeadlinePassed(double deadline)
     {
-        while (!m_timerTasks.empty()) {
+        while (m_timerTasks.size()) {
             if (m_timerTasks.top().runTimeSeconds() > deadline) {
                 gCurrentTimeSecs = deadline;
                 break;
             }
             gCurrentTimeSecs = m_timerTasks.top().runTimeSeconds();
             m_timerTasks.top().run();
             m_timerTasks.pop();
         }
     }
 
     void runPendingTasks()
     {
-        while (!m_timerTasks.empty() && m_timerTasks.top().runTimeSeconds() <= gCurrentTimeSecs) {
+        while (m_timerTasks.size() && m_timerTasks.top().runTimeSeconds() <= gCurrentTimeSecs) {
             m_timerTasks.top().run();
             m_timerTasks.pop();
         }
     }
 
     bool hasOneTimerTask() const
     {
         return m_timerTasks.size() == 1;
     }
 
@@ skipping 120 matching lines @@
         m_startTime = gCurrentTimeSecs;
     }
 
     void TearDown() override
     {
         Platform::initialize(m_oldPlatform);
     }
 
     void countingTask(Timer<TimerTest>*)
     {
-        m_runTimes.push_back(monotonicallyIncreasingTime());
+        m_runTimes.append(monotonicallyIncreasingTime());
     }
 
     void recordNextFireTimeTask(Timer<TimerTest>* timer)
     {
-        m_nextFireTimes.push_back(monotonicallyIncreasingTime() + timer->nextFireInterval());
+        m_nextFireTimes.append(monotonicallyIncreasingTime() + timer->nextFireInterval());
     }
 
     void advanceTimeBy(double timeSecs)
     {
         gCurrentTimeSecs += timeSecs;
     }
 
     void runUntilIdle()
     {
         m_platform->runUntilIdle();
@@ skipping 14 matching lines @@
         return m_platform->hasOneTimerTask();
     }
 
     double nextTimerTaskDelaySecs() const
     {
         return m_platform->nextTimerTaskDelaySecs();
     }
 
 protected:
     double m_startTime;
-    // TODO(alexclarke): Migrate to WTF::Vector and add gmock matcher support.
-    std::vector<double> m_runTimes;
-    std::vector<double> m_nextFireTimes;
+    WTF::Vector<double> m_runTimes;
+    WTF::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);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 }
 
 TEST_F(TimerTest, StartOneShot_ZeroAndCancel)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(0, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
-    EXPECT_TRUE(m_runTimes.empty());
+    EXPECT_FALSE(m_runTimes.size());
 }
 
 TEST_F(TimerTest, StartOneShot_ZeroAndCancelThenRepost)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(0, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
-    EXPECT_TRUE(m_runTimes.empty());
+    EXPECT_FALSE(m_runTimes.size());
 
     timer.startOneShot(0, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 }
 
@@ skipping 33 matching lines @@
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(10, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
-    EXPECT_TRUE(m_runTimes.empty());
+    EXPECT_FALSE(m_runTimes.size());
 }
 
 TEST_F(TimerTest, StartOneShot_NonZeroAndCancelThenRepost)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(10, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
-    EXPECT_TRUE(m_runTimes.empty());
+    EXPECT_FALSE(m_runTimes.size());
 
     double secondPostTime = monotonicallyIncreasingTime();
     timer.startOneShot(10, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(secondPostTime + 10.0));
 }
@@ skipping 348 matching lines @@
         m_startTime + 6.0,
         m_startTime + 8.0,
         m_startTime + 10.0,
         m_startTime + 14.0,
         m_startTime + 18.0,
         m_startTime + 28.0));
 }
 
 } // namespace
 } // namespace blink