Rename FROM_HERE to BLINK_FROM_HERE.

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 337 matching lines @@
     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);
+    timer.startOneShot(0, BLINK_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);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
     EXPECT_FALSE(m_runTimes.size());
 }
 
 TEST_F(TimerTest, StartOneShot_ZeroAndCancelThenRepost)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
     EXPECT_FALSE(m_runTimes.size());
 
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 }
 
 TEST_F(TimerTest, StartOneShot_Zero_RepostingAfterRunning)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));
 
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime, m_startTime));
 }
 
 TEST_F(TimerTest, StartOneShot_NonZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10.0, FROM_HERE);
+    timer.startOneShot(10.0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 }
 
 TEST_F(TimerTest, StartOneShot_NonZeroAndCancel)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
     EXPECT_FALSE(m_runTimes.size());
 }
 
 TEST_F(TimerTest, StartOneShot_NonZeroAndCancelThenRepost)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
     EXPECT_FALSE(m_runTimes.size());
 
     double secondPostTime = monotonicallyIncreasingTime();
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(secondPostTime + 10.0));
 }
 
 TEST_F(TimerTest, StartOneShot_NonZero_RepostingAfterRunning)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 
-    timer.startOneShot(20, FROM_HERE);
+    timer.startOneShot(20, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(20.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0, m_startTime + 30.0));
 }
 
 TEST_F(TimerTest, PostingTimerTwiceWithSameRunTimeDoesNothing)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 }
 
 TEST_F(TimerTest, PostingTimerTwiceWithNewerRunTimeCancelsOriginalTask)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 0.0));
 }
 
 TEST_F(TimerTest, PostingTimerTwiceWithLaterRunTimeCancelsOriginalTask)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));
 }
 
 TEST_F(TimerTest, StartRepeatingTask)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(1.0, FROM_HERE);
+    timer.startRepeating(1.0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(1.0, nextTimerTaskDelaySecs());
 
     runUntilIdleOrDeadlinePassed(m_startTime + 5.5);
     EXPECT_THAT(m_runTimes, ElementsAre(
         m_startTime + 1.0, m_startTime + 2.0, m_startTime + 3.0, m_startTime + 4.0, m_startTime + 5.0));
 }
 
 TEST_F(TimerTest, StartRepeatingTask_ThenCancel)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(1.0, FROM_HERE);
+    timer.startRepeating(1.0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(1.0, nextTimerTaskDelaySecs());
 
     runUntilIdleOrDeadlinePassed(m_startTime + 2.5);
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));
 
     timer.stop();
     runUntilIdle();
 
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));
 }
 
 TEST_F(TimerTest, StartRepeatingTask_ThenPostOneShot)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(1.0, FROM_HERE);
+    timer.startRepeating(1.0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(1.0, nextTimerTaskDelaySecs());
 
     runUntilIdleOrDeadlinePassed(m_startTime + 2.5);
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));
 
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
     runUntilIdle();
 
     EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0, m_startTime + 2.5));
 }
 
 TEST_F(TimerTest, IsActive_NeverPosted)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 
     EXPECT_FALSE(timer.isActive());
 }
 
 TEST_F(TimerTest, IsActive_AfterPosting_OneShotZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     EXPECT_TRUE(timer.isActive());
 }
 
 TEST_F(TimerTest, IsActive_AfterPosting_OneShotNonZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     EXPECT_TRUE(timer.isActive());
 }
 
 TEST_F(TimerTest, IsActive_AfterPosting_Repeating)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(1.0, FROM_HERE);
+    timer.startRepeating(1.0, BLINK_FROM_HERE);
 
     EXPECT_TRUE(timer.isActive());
 }
 
 TEST_F(TimerTest, IsActive_AfterRunning_OneShotZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     runUntilIdle();
     EXPECT_FALSE(timer.isActive());
 }
 
 TEST_F(TimerTest, IsActive_AfterRunning_OneShotNonZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     runUntilIdle();
     EXPECT_FALSE(timer.isActive());
 }
 
 TEST_F(TimerTest, IsActive_AfterRunning_Repeating)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(1.0, FROM_HERE);
+    timer.startRepeating(1.0, BLINK_FROM_HERE);
 
     runUntilIdleOrDeadlinePassed(m_startTime + 10);
     EXPECT_TRUE(timer.isActive()); // It should run until cancelled.
 }
 
 TEST_F(TimerTest, NextFireInterval_OneShotZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
 }
 
 TEST_F(TimerTest, NextFireInterval_OneShotNonZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());
 }
 
 TEST_F(TimerTest, NextFireInterval_OneShotNonZero_AfterAFewSeconds)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     advanceTimeBy(2.0);
     EXPECT_FLOAT_EQ(8.0, timer.nextFireInterval());
 }
 
 TEST_F(TimerTest, NextFireInterval_Repeating)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(20, FROM_HERE);
+    timer.startRepeating(20, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(20.0, timer.nextFireInterval());
 }
 
 TEST_F(TimerTest, RepeatInterval_NeverStarted)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
 
     EXPECT_FLOAT_EQ(0.0, timer.repeatInterval());
 }
 
 TEST_F(TimerTest, RepeatInterval_OneShotZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(0, FROM_HERE);
+    timer.startOneShot(0, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(0.0, timer.repeatInterval());
 }
 
 TEST_F(TimerTest, RepeatInterval_OneShotNonZero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startOneShot(10, FROM_HERE);
+    timer.startOneShot(10, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(0.0, timer.repeatInterval());
 }
 
 TEST_F(TimerTest, RepeatInterval_Repeating)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(20, FROM_HERE);
+    timer.startRepeating(20, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());
 }
 
 TEST_F(TimerTest, AugmentRepeatInterval)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
-    timer.startRepeating(10, FROM_HERE);
+    timer.startRepeating(10, BLINK_FROM_HERE);
     EXPECT_FLOAT_EQ(10.0, timer.repeatInterval());
     EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());
 
     advanceTimeBy(2.0);
     timer.augmentRepeatInterval(10);
 
     EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());
     EXPECT_FLOAT_EQ(18.0, timer.nextFireInterval());
 
     runUntilIdleOrDeadlinePassed(m_startTime + 50.0);
@@ skipping 27 matching lines @@
 private:
     mutable double m_lastFireTime;
     double m_alignedFireTime;
 };
 
 TEST_F(TimerTest, TimerAlignment_OneShotZero)
 {
     MockTimerWithAlignment timer;
     timer.setAlignedFireTime(m_startTime + 1.0);
 
-    timer.start(0.0, 0.0, FROM_HERE);
+    timer.start(0.0, 0.0, BLINK_FROM_HERE);
 
     // The nextFireInterval gets overrriden.
     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 }
 
 TEST_F(TimerTest, TimerAlignment_OneShotNonZero)
 {
     MockTimerWithAlignment timer;
     timer.setAlignedFireTime(m_startTime + 1.0);
 
-    timer.start(0.5, 0.0, FROM_HERE);
+    timer.start(0.5, 0.0, BLINK_FROM_HERE);
 
     // The nextFireInterval gets overrriden.
     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.5, timer.nextUnalignedFireInterval());
     EXPECT_FLOAT_EQ(m_startTime + 0.5, timer.lastFireTime());
 }
 
 TEST_F(TimerTest, DidChangeAlignmentInterval)
 {
     MockTimerWithAlignment timer;
     timer.setAlignedFireTime(m_startTime + 1.0);
 
-    timer.start(0.0, 0.0, FROM_HERE);
+    timer.start(0.0, 0.0, BLINK_FROM_HERE);
 
     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
     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);
+    timer.startRepeating(2.0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     recordNextFireTimeTask(&timer); // Next scheduled task to run at m_startTime + 2.0
 
     // Simulate timer firing early. Next scheduled task to run at m_startTime + 4.0
     advanceTimeBy(1.9);
     runUntilIdleOrDeadlinePassed(gCurrentTimeSecs + 0.2);
 
     advanceTimeBy(2.0);
     runPendingTasks(); // Next scheduled task to run at m_startTime + 6.0
@@ skipping 20 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