reflow comments in platform/

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 "platform/Timer.h"
 
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/child/web_task_runner_impl.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/testing/TestingPlatformSupport.h"
@@ skipping 34 matching lines @@
   void runUntilDeadline(double deadline) {
     double period = deadline - monotonicallyIncreasingTime();
     EXPECT_GE(period, 0.0);
     m_platform.runForPeriodSeconds(period);
 
     // We may have stopped before the clock advanced to |deadline|.
     double timeToAdvance = deadline - monotonicallyIncreasingTime();
     m_platform.advanceClockSeconds(timeToAdvance);
   }
 
-  // Returns false if there are no pending delayed tasks, otherwise sets |time| to
-  // the delay in seconds till the next pending delayed task is scheduled to fire.
+  // Returns false if there are no pending delayed tasks, otherwise sets |time|
+  // to the delay in seconds till the next pending delayed task is scheduled to
+  // fire.
   bool timeTillNextDelayedTask(double* time) const {
     base::TimeTicks nextRunTime;
     if (!m_platform.rendererScheduler()
              ->TimerTaskRunner()
              ->GetTimeDomain()
              ->NextScheduledRunTime(&nextRunTime))
       return false;
     *time = (nextRunTime -
              m_platform.rendererScheduler()
                  ->TimerTaskRunner()
@@ skipping 337 matching lines @@
   timer.startRepeating(10, BLINK_FROM_HERE);
   EXPECT_FLOAT_EQ(10.0, timer.repeatInterval());
   EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());
 
   m_platform.advanceClockSeconds(2.0);
   timer.augmentRepeatInterval(10);
 
   EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());
   EXPECT_FLOAT_EQ(18.0, timer.nextFireInterval());
 
-  // NOTE setAutoAdvanceNowToPendingTasks(true) (which uses cc::OrderedSimpleTaskRunner)
-  // results in somewhat strange behavior of the test clock which breaks this test.
-  // Specifically the test clock advancing logic ignores newly posted delayed tasks and
-  // advances too far.
+  // NOTE setAutoAdvanceNowToPendingTasks(true) (which uses
+  // cc::OrderedSimpleTaskRunner) results in somewhat strange behavior of the
+  // test clock which breaks this test.  Specifically the test clock advancing
+  // logic ignores newly posted delayed tasks and advances too far.
   runUntilDeadline(m_startTime + 50.0);
   EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 20.0, m_startTime + 40.0));
 }
 
 TEST_F(TimerTest, AugmentRepeatInterval_TimerFireDelayed) {
   m_platform.setAutoAdvanceNowToPendingTasks(false);
 
   Timer<TimerTest> timer(this, &TimerTest::countingTask);
   timer.startRepeating(10, BLINK_FROM_HERE);
   EXPECT_FLOAT_EQ(10.0, timer.repeatInterval());
   EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());
 
   m_platform.advanceClockSeconds(123.0);  // Make the timer long overdue.
   timer.augmentRepeatInterval(10);
 
   EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());
   // The timer is overdue so it should be scheduled to fire immediatly.
   EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
 }
 
 TEST_F(TimerTest, RepeatingTimerDoesNotDrift) {
   m_platform.setAutoAdvanceNowToPendingTasks(false);
 
   Timer<TimerTest> timer(this, &TimerTest::recordNextFireTimeTask);
   timer.startRepeating(2.0, BLINK_FROM_HERE);
 
   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
+  // Simulate timer firing early. Next scheduled task to run at
+  // m_startTime + 4.0
   m_platform.advanceClockSeconds(1.9);
   runUntilDeadline(monotonicallyIncreasingTime() + 0.2);
 
-  m_platform.runForPeriodSeconds(
-      2.0);  // Next scheduled task to run at m_startTime + 6.0
-  m_platform.runForPeriodSeconds(
-      2.1);  // Next scheduled task to run at m_startTime + 8.0
-  m_platform.runForPeriodSeconds(
-      2.9);  // Next scheduled task to run at m_startTime + 10.0
-  m_platform.runForPeriodSeconds(
-      3.1);  // Next scheduled task to run at m_startTime + 14.0 (skips a beat)
-  m_platform.runForPeriodSeconds(
-      4.0);  // Next scheduled task to run at m_startTime + 18.0 (skips a beat)
-  m_platform.runForPeriodSeconds(
-      10.0);  // Next scheduled task to run at m_startTime + 28.0 (skips 5 beats)
+  // Next scheduled task to run at m_startTime + 6.0
+  m_platform.runForPeriodSeconds(2.0);
+  // Next scheduled task to run at m_startTime + 8.0
+  m_platform.runForPeriodSeconds(2.1);
+  // Next scheduled task to run at m_startTime + 10.0
+  m_platform.runForPeriodSeconds(2.9);
+  // Next scheduled task to run at m_startTime + 14.0 (skips a beat)
+  m_platform.runForPeriodSeconds(3.1);
+  // Next scheduled task to run at m_startTime + 18.0 (skips a beat)
+  m_platform.runForPeriodSeconds(4.0);
+  // Next scheduled task to run at m_startTime + 28.0 (skips 5 beats)
+  m_platform.runForPeriodSeconds(10.0);
 
   EXPECT_THAT(
       m_nextFireTimes,
       ElementsAre(m_startTime + 2.0, m_startTime + 4.0, m_startTime + 6.0,
                   m_startTime + 8.0, m_startTime + 10.0, m_startTime + 14.0,
                   m_startTime + 18.0, m_startTime + 28.0));
 }
 
 template <typename TimerFiredClass>
 class TimerForTest : public TaskRunnerTimer<TimerFiredClass> {
@@ skipping 17 matching lines @@
   scheduler::WebTaskRunnerImpl webTaskRunner(taskRunner);
   TimerForTest<TimerTest> timer(&webTaskRunner, this, &TimerTest::countingTask);
   timer.startOneShot(0, BLINK_FROM_HERE);
 
   // Make sure the task was posted on taskRunner.
   EXPECT_FALSE(taskRunner->IsEmpty());
 }
 
 }  // namespace
 }  // namespace blink