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

third_party/WebKit/Source/platform/graphics/paint/GeometryMapperTest.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/graphics/paint/GeometryMapper.h"
 
 #include "platform/geometry/GeometryTestHelpers.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/BoxReflection.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
@@ skipping 178 matching lines @@
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = transformMatrix.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, transform->matrix(), FloatClipRect(),
                  localState, rootPropertyTreeState(), hasRadius);
 
-  EXPECT_RECT_EQ(input, geometryMapper->ancestorToLocalRect(
-                            output, rootPropertyTreeState().transform(),
-                            localState.transform()));
+  EXPECT_RECT_EQ(
+      input,
+      geometryMapper->ancestorToLocalRect(
+          output, rootPropertyTreeState().transform(), localState.transform()));
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(0, 0, 0));
@@ skipping 77 matching lines @@
   // Note: unlike NestedTransforms, the order of these transforms matters. This
   // tests correct order of matrix multiplication.
   TransformationMatrix final = scaleTransform * translateTransform;
   FloatRect output = final.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, final, FloatClipRect(), localState,
                  rootPropertyTreeState(), hasRadius);
 
   // Check the cached matrix for the intermediate transform.
-  EXPECT_EQ(scaleTransform, getTransformCache(rootPropertyTreeState())
+  EXPECT_EQ(scaleTransform,
+            getTransformCache(rootPropertyTreeState())
 
-                                .get(transform1.get()));
+                .get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
@@ skipping 28 matching lines @@
   FloatRect output(10, 10, 50, 50);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input,   // Input
                  output,  // Visual rect
                  input,   // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  FloatClipRect(clip->clipRect().rect()),  // Clip rect in
                                                           // ancestor space
-                 localState,
-                 rootPropertyTreeState(), hasRadius);
+                 localState, rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, RoundedClip) {
   FloatRoundedRect rect(FloatRect(10, 10, 50, 50),
                         FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(),
                                                 FloatSize(), FloatSize()));
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(), rect);
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(10, 10, 50, 50);
 
   FloatClipRect expectedClip(clip->clipRect().rect());
   expectedClip.setHasRadius();
 
   bool hasRadius = true;
   CHECK_MAPPINGS(input,   // Input
                  output,  // Visual rect
                  input,   // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  expectedClip,    // Clip rect in ancestor space
-                 localState,
-                 rootPropertyTreeState(), hasRadius);
+                 localState, rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, TwoClips) {
   FloatRoundedRect clipRect1(
       FloatRect(10, 10, 30, 40),
       FloatRoundedRect::Radii(FloatSize(1, 1), FloatSize(), FloatSize(),
                               FloatSize()));
 
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
@@ skipping 13 matching lines @@
   FloatClipRect clipRect(clip1->clipRect().rect());
   clipRect.setHasRadius();
 
   bool hasRadius = true;
   CHECK_MAPPINGS(input,    // Input
                  output1,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clipRect,        // Clip rect in ancestor space
-                 localState,
-                 ancestorState, hasRadius);
+                 localState, ancestorState, hasRadius);
 
   ancestorState.setClip(clip1.get());
   FloatRect output2(10, 10, 50, 50);
 
   clipRect.setRect(clip2->clipRect().rect());
 
   hasRadius = false;
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clipRect,        // Clip rect in ancestor space
-                 localState,
-                 ancestorState, hasRadius);
+                 localState, ancestorState, hasRadius);
 }
 
 TEST_F(GeometryMapperTest, TwoClipsTransformAbove) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
 
   FloatRoundedRect clipRect1(
       FloatRect(10, 10, 50, 50),
@@ skipping 16 matching lines @@
   FloatClipRect expectedClip(clip2->clipRect().rect());
   expectedClip.setHasRadius();
 
   bool hasRadius = true;
   CHECK_MAPPINGS(input,    // Input
                  output1,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  expectedClip,    // Clip rect in ancestor space
-                 localState,
-                 ancestorState, hasRadius);
+                 localState, ancestorState, hasRadius);
 
   expectedClip.setRect(clip1->clipRect().rect());
   localState.setClip(clip1.get());
   FloatRect output2(10, 10, 50, 50);
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  expectedClip,    // Clip rect in ancestor space
-                 localState,
-                 ancestorState, hasRadius);
+                 localState, ancestorState, hasRadius);
 }
 
 TEST_F(GeometryMapperTest, ClipBeforeTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
@@ skipping 10 matching lines @@
   output = rotateTransform.mapRect(output);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(
       input,                           // Input
       output,                          // Visual rect
       rotateTransform.mapRect(input),  // Transformed rect (not clipped).
       rotateTransform,                 // Transform matrix to ancestor space
       FloatClipRect(rotateTransform.mapRect(
           clip->clipRect().rect())),  // Clip rect in ancestor space
-      localState,
-      rootPropertyTreeState(), hasRadius);
+      localState, rootPropertyTreeState(), hasRadius);
 }
 
 TEST_F(GeometryMapperTest, ClipAfterTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
@@ skipping 308 matching lines @@
   FloatRect input(100, 100, 50, 50);
   // Reflection is at (50, 100, 50, 50).
   FloatRect output(50, 100, 100, 50);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, input, TransformationMatrix(), FloatClipRect(),
                  localState, rootPropertyTreeState(), hasRadius);
 }
 
 }  // namespace blink