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

third_party/WebKit/Source/platform/animation/CompositorFloatAnimationCurveTest.cpp

 // Copyright 2016 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/animation/CompositorFloatAnimationCurve.h"
 
 #include "cc/animation/timing_function.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <memory>
@@ skipping 113 matching lines @@
   EXPECT_NEAR(curve->getValue(0.5), 0.5, 0.00015);
   EXPECT_LT(0.75, curve->getValue(0.75));
   EXPECT_GT(1, curve->getValue(0.75));
   EXPECT_FLOAT_EQ(1, curve->getValue(1));
 }
 
 // Tests that an ease timing function works as expected.
 TEST(WebFloatAnimationCurveTest, EaseTimingFunction) {
   std::unique_ptr<CompositorFloatAnimationCurve> curve =
       CompositorFloatAnimationCurve::create();
-  curve->addKeyframe(CompositorFloatKeyframe(
-      0, 0, *CubicBezierTimingFunction::preset(
-                CubicBezierTimingFunction::EaseType::EASE)));
+  curve->addKeyframe(
+      CompositorFloatKeyframe(0, 0,
+                              *CubicBezierTimingFunction::preset(
+                                  CubicBezierTimingFunction::EaseType::EASE)));
   curve->addKeyframe(
       CompositorFloatKeyframe(1, 1, *LinearTimingFunction::shared()));
 
   std::unique_ptr<cc::TimingFunction> timingFunction(
       cc::CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(timingFunction->GetValue(time), curve->getValue(time));
   }
@@ skipping 12 matching lines @@
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(time, curve->getValue(time));
   }
 }
 
 // Tests that an ease in timing function works as expected.
 TEST(WebFloatAnimationCurveTest, EaseInTimingFunction) {
   std::unique_ptr<CompositorFloatAnimationCurve> curve =
       CompositorFloatAnimationCurve::create();
   curve->addKeyframe(CompositorFloatKeyframe(
-      0, 0, *CubicBezierTimingFunction::preset(
-                CubicBezierTimingFunction::EaseType::EASE_IN)));
+      0, 0,
+      *CubicBezierTimingFunction::preset(
+          CubicBezierTimingFunction::EaseType::EASE_IN)));
   curve->addKeyframe(
       CompositorFloatKeyframe(1, 1, *LinearTimingFunction::shared()));
 
   std::unique_ptr<cc::TimingFunction> timingFunction(
       cc::CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE_IN));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(timingFunction->GetValue(time), curve->getValue(time));
   }
 }
 
 // Tests that an ease in timing function works as expected.
 TEST(WebFloatAnimationCurveTest, EaseOutTimingFunction) {
   std::unique_ptr<CompositorFloatAnimationCurve> curve =
       CompositorFloatAnimationCurve::create();
   curve->addKeyframe(CompositorFloatKeyframe(
-      0, 0, *CubicBezierTimingFunction::preset(
-                CubicBezierTimingFunction::EaseType::EASE_OUT)));
+      0, 0,
+      *CubicBezierTimingFunction::preset(
+          CubicBezierTimingFunction::EaseType::EASE_OUT)));
   curve->addKeyframe(
       CompositorFloatKeyframe(1, 1, *LinearTimingFunction::shared()));
 
   std::unique_ptr<cc::TimingFunction> timingFunction(
       cc::CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE_OUT));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(timingFunction->GetValue(time), curve->getValue(time));
   }
 }
 
 // Tests that an ease in timing function works as expected.
 TEST(WebFloatAnimationCurveTest, EaseInOutTimingFunction) {
   std::unique_ptr<CompositorFloatAnimationCurve> curve =
       CompositorFloatAnimationCurve::create();
   curve->addKeyframe(CompositorFloatKeyframe(
-      0, 0, *CubicBezierTimingFunction::preset(
-                CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
+      0, 0,
+      *CubicBezierTimingFunction::preset(
+          CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
   curve->addKeyframe(
       CompositorFloatKeyframe(1, 1, *LinearTimingFunction::shared()));
 
   std::unique_ptr<cc::TimingFunction> timingFunction(
       cc::CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE_IN_OUT));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(timingFunction->GetValue(time), curve->getValue(time));
   }
@@ skipping 18 matching lines @@
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(timingFunction->GetValue(time), curve->getValue(time));
   }
 }
 
 // Tests that the default timing function is indeed ease.
 TEST(WebFloatAnimationCurveTest, DefaultTimingFunction) {
   std::unique_ptr<CompositorFloatAnimationCurve> curve =
       CompositorFloatAnimationCurve::create();
-  curve->addKeyframe(CompositorFloatKeyframe(
-      0, 0, *CubicBezierTimingFunction::preset(
-                CubicBezierTimingFunction::EaseType::EASE)));
+  curve->addKeyframe(
+      CompositorFloatKeyframe(0, 0,
+                              *CubicBezierTimingFunction::preset(
+                                  CubicBezierTimingFunction::EaseType::EASE)));
   curve->addKeyframe(
       CompositorFloatKeyframe(1, 1, *LinearTimingFunction::shared()));
 
   std::unique_ptr<cc::TimingFunction> timingFunction(
       cc::CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE));
   for (int i = 0; i <= 4; ++i) {
     const double time = i * 0.25;
     EXPECT_FLOAT_EQ(timingFunction->GetValue(time), curve->getValue(time));
   }
 }
 
 }  // namespace blink