Reflow comments in core/animation and subdirs

third_party/WebKit/Source/core/animation/TimingCalculationsTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #include "core/animation/TimingCalculations.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 TEST(AnimationTimingCalculationsTest, ActiveTime) {
   Timing timing;
 
-  // calculateActiveTime(activeDuration, fillMode, localTime, parentPhase, phase, timing)
+  // calculateActiveTime(
+  //     activeDuration, fillMode, localTime, parentPhase, phase, timing)
 
   // Before Phase
   timing.startDelay = 10;
   EXPECT_TRUE(isNull(calculateActiveTime(
       20, Timing::FillMode::FORWARDS, 0, AnimationEffectReadOnly::PhaseActive,
       AnimationEffectReadOnly::PhaseBefore, timing)));
   EXPECT_TRUE(isNull(calculateActiveTime(
       20, Timing::FillMode::NONE, 0, AnimationEffectReadOnly::PhaseActive,
       AnimationEffectReadOnly::PhaseBefore, timing)));
   EXPECT_EQ(0,
@@ skipping 82 matching lines @@
   timing.playbackRate = -1;
   EXPECT_EQ(std::numeric_limits<double>::infinity(),
             calculateScaledActiveTime(std::numeric_limits<double>::infinity(),
                                       std::numeric_limits<double>::infinity(),
                                       0, timing));
 }
 
 TEST(AnimationTimingCalculationsTest, IterationTime) {
   Timing timing;
 
-  // calculateIterationTime(iterationDuration, repeatedDuration, scaledActiveTime, startOffset, phase, timing)
+  // calculateIterationTime(
+  //     iterationDuration, repeatedDuration, scaledActiveTime, startOffset,
+  //     phase, timing)
 
   // if the scaled active time is null
   EXPECT_TRUE(isNull(calculateIterationTime(
       1, 1, nullValue(), 1, AnimationEffectReadOnly::PhaseActive, timing)));
 
   // if (complex-conditions)...
   EXPECT_EQ(
       12, calculateIterationTime(12, 12, 12, 0,
                                  AnimationEffectReadOnly::PhaseActive, timing));
 
   // otherwise
   timing.iterationCount = 10;
   EXPECT_EQ(
       5, calculateIterationTime(10, 100, 25, 4,
                                 AnimationEffectReadOnly::PhaseActive, timing));
   EXPECT_EQ(
       7, calculateIterationTime(11, 110, 29, 1,
                                 AnimationEffectReadOnly::PhaseActive, timing));
   timing.iterationStart = 1.1;
   EXPECT_EQ(
       8, calculateIterationTime(12, 120, 20, 7,
                                 AnimationEffectReadOnly::PhaseActive, timing));
 }
 
 TEST(AnimationTimingCalculationsTest, CurrentIteration) {
   Timing timing;
 
-  // calculateCurrentIteration(iterationDuration, iterationTime, scaledActiveTime, timing)
+  // calculateCurrentIteration(
+  //     iterationDuration, iterationTime, scaledActiveTime, timing)
 
   // if the scaled active time is null
   EXPECT_TRUE(isNull(calculateCurrentIteration(1, 1, nullValue(), timing)));
 
   // if the scaled active time is zero
   EXPECT_EQ(0, calculateCurrentIteration(1, 1, 0, timing));
 
   // if the iteration time equals the iteration duration
   timing.iterationStart = 4;
   timing.iterationCount = 7;
   EXPECT_EQ(10, calculateCurrentIteration(5, 5, 9, timing));
 
   // otherwise
   EXPECT_EQ(3, calculateCurrentIteration(3.2, 3.1, 10, timing));
 }
 
 TEST(AnimationTimingCalculationsTest, DirectedTime) {
   Timing timing;
 
-  // calculateDirectedTime(currentIteration, iterationDuration, iterationTime, timing)
+  // calculateDirectedTime(
+  //     currentIteration, iterationDuration, iterationTime, timing)
 
   // if the iteration time is null
   EXPECT_TRUE(isNull(calculateDirectedTime(1, 2, nullValue(), timing)));
 
   // forwards
   EXPECT_EQ(17, calculateDirectedTime(0, 20, 17, timing));
   EXPECT_EQ(17, calculateDirectedTime(1, 20, 17, timing));
   timing.direction = Timing::PlaybackDirection::ALTERNATE_NORMAL;
   EXPECT_EQ(17, calculateDirectedTime(0, 20, 17, timing));
   EXPECT_EQ(17, calculateDirectedTime(2, 20, 17, timing));
   timing.direction = Timing::PlaybackDirection::ALTERNATE_REVERSE;
   EXPECT_EQ(17, calculateDirectedTime(1, 20, 17, timing));
   EXPECT_EQ(17, calculateDirectedTime(3, 20, 17, timing));
 
   // reverse
   timing.direction = Timing::PlaybackDirection::REVERSE;
   EXPECT_EQ(3, calculateDirectedTime(0, 20, 17, timing));
   EXPECT_EQ(3, calculateDirectedTime(1, 20, 17, timing));
   timing.direction = Timing::PlaybackDirection::ALTERNATE_NORMAL;
   EXPECT_EQ(3, calculateDirectedTime(1, 20, 17, timing));
   EXPECT_EQ(3, calculateDirectedTime(3, 20, 17, timing));
   timing.direction = Timing::PlaybackDirection::ALTERNATE_REVERSE;
   EXPECT_EQ(3, calculateDirectedTime(0, 20, 17, timing));
   EXPECT_EQ(3, calculateDirectedTime(2, 20, 17, timing));
 }
 
 TEST(AnimationTimingCalculationsTest, TransformedTime) {
   Timing timing;
 
-  // calculateTransformedTime(currentIteration, iterationDuration, iterationTime, timing)
+  // calculateTransformedTime(
+  //     currentIteration, iterationDuration, iterationTime, timing)
 
   // Iteration time is null
   EXPECT_TRUE(isNull(calculateTransformedTime(1, 2, nullValue(), timing)));
 
   // PlaybackDirectionForwards
   EXPECT_EQ(12, calculateTransformedTime(0, 20, 12, timing));
   EXPECT_EQ(12, calculateTransformedTime(1, 20, 12, timing));
 
   // PlaybackDirectionForwards with timing function
   timing.timingFunction =
@@ skipping 25 matching lines @@
   timing.direction = Timing::PlaybackDirection::REVERSE;
   EXPECT_EQ(std::numeric_limits<double>::infinity(),
             calculateTransformedTime(0, std::numeric_limits<double>::infinity(),
                                      0, timing));
   EXPECT_EQ(std::numeric_limits<double>::infinity(),
             calculateTransformedTime(0, std::numeric_limits<double>::infinity(),
                                      1, timing));
 }
 
 }  // namespace blink