DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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 105 matching lines @@
   EXPECT_EQ(35, calculateScaledActiveTime(40, 10, 5, timing));
 
   // otherwise
   timing.playbackRate = 0;
   EXPECT_EQ(5, calculateScaledActiveTime(40, 10, 5, timing));
   timing.playbackRate = 1;
   EXPECT_EQ(15, calculateScaledActiveTime(40, 10, 5, timing));
 
   // infinte activeTime
   timing.playbackRate = 0;
-  EXPECT_EQ(0, calculateScaledActiveTime(
-                   std::numeric_limits<double>::infinity(),
-                   std::numeric_limits<double>::infinity(), 0, timing));
+  EXPECT_EQ(0,
+            calculateScaledActiveTime(std::numeric_limits<double>::infinity(),
+                                      std::numeric_limits<double>::infinity(),
+                                      0, timing));
   timing.playbackRate = 1;
   EXPECT_EQ(std::numeric_limits<double>::infinity(),
             calculateScaledActiveTime(std::numeric_limits<double>::infinity(),
                                       std::numeric_limits<double>::infinity(),
                                       0, timing));
   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)
 
   // 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));
+  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));
+  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));
+  EXPECT_EQ(8,
+            calculateIterationTime(
+                12, 120, 20, 7, AnimationEffectReadOnly::PhaseActive, timing));
 }
 
 TEST(AnimationTimingCalculationsTest, CurrentIteration) {
   Timing timing;
 
   // calculateCurrentIteration(
   //     iterationDuration, iterationTime, scaledActiveTime, timing)
 
   // if the scaled active time is null
   EXPECT_TRUE(isNull(calculateCurrentIteration(1, 1, nullValue(), timing)));
@@ skipping 70 matching lines @@
   timing.timingFunction =
       StepsTimingFunction::create(4, StepsTimingFunction::StepPosition::END);
   EXPECT_EQ(5, calculateTransformedTime(0, 20, 12, timing));
   EXPECT_EQ(5, calculateTransformedTime(1, 20, 12, timing));
 
   // Timing function when directed time is null.
   EXPECT_TRUE(isNull(calculateTransformedTime(1, 2, nullValue(), timing)));
 
   // Timing function when iterationDuration is infinity
   timing.direction = Timing::PlaybackDirection::NORMAL;
-  EXPECT_EQ(0, calculateTransformedTime(
-                   0, std::numeric_limits<double>::infinity(), 0, timing));
-  EXPECT_EQ(1, calculateTransformedTime(
-                   0, std::numeric_limits<double>::infinity(), 1, timing));
+  EXPECT_EQ(0,
+            calculateTransformedTime(0, std::numeric_limits<double>::infinity(),
+                                     0, timing));
+  EXPECT_EQ(1,
+            calculateTransformedTime(0, std::numeric_limits<double>::infinity(),
+                                     1, timing));
   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