ABANDONED CL: Changes needed to make things compile after running rewrite_to_chrome_style tool.

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 92 matching lines @@
         << ", expected: " << expected.width();                                 \
     EXPECT_TRUE(GeometryTest::ApproximatelyEqual(                              \
         expected.height(), actualRect.height(), kTestEpsilon))                 \
         << "actual: " << actualRect.height()                                   \
         << ", expected: " << expected.height();                                \
   } while (false)
 
 #define CHECK_MAPPINGS(inputRect, expectedVisualRect, expectedTransformedRect, \
                        expectedTransformToAncestor,                            \
                        expectedClipInAncestorSpace, localPropertyTreeState,    \
-                       ancestorPropertyTreeState, hasRadius)                   \
+                       ancestorPropertyTreeState)                              \
   do {                                                                         \
     FloatClipRect clipRect = geometryMapper->localToAncestorVisualRect(        \
         inputRect, localPropertyTreeState, ancestorPropertyTreeState);         \
-    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
+    EXPECT_EQ(has_radius, clipRect.HasRadius());                                \
     EXPECT_RECT_EQ(expectedVisualRect, clipRect.rect());                       \
     clipRect = geometryMapper->localToAncestorClipRect(                        \
         localPropertyTreeState, ancestorPropertyTreeState);                    \
-    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
+    EXPECT_EQ(has_radius, clipRect.HasRadius());                                \
     EXPECT_RECT_EQ(expectedClipInAncestorSpace, clipRect.rect());              \
     clipRect = geometryMapper->sourceToDestinationVisualRect(                  \
         inputRect, localPropertyTreeState, ancestorPropertyTreeState);         \
-    EXPECT_EQ(hasRadius, clipRect.hasRadius());                                \
+    EXPECT_EQ(has_radius, clipRect.HasRadius());                                \
     EXPECT_RECT_EQ(expectedVisualRect, clipRect.rect());                       \
     EXPECT_RECT_EQ(expectedTransformedRect,                                    \
                    geometryMapper->localToAncestorRect(                        \
                        inputRect, localPropertyTreeState.transform(),          \
                        ancestorPropertyTreeState.transform()));                \
     EXPECT_RECT_EQ(expectedTransformedRect,                                    \
                    geometryMapper->sourceToDestinationRect(                    \
                        inputRect, localPropertyTreeState.transform(),          \
                        ancestorPropertyTreeState.transform()));                \
     if (ancestorPropertyTreeState.transform() !=                               \
@@ skipping 10 matching lines @@
     }                                                                          \
   } while (false)
 
 TEST_F(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, input, input,
                  TransformPaintPropertyNode::root()->matrix(),
                  ClipPaintPropertyNode::root()->clipRect().rect(),
-                 rootPropertyTreeState(), rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState(), rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, IdentityTransform) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, input, input, transform->matrix(),
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, TranslationTransform) {
   TransformationMatrix transformMatrix;
   transformMatrix.translate(20, 10);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix, FloatPoint3D());
   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(),
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 
   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));
   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, transformMatrix,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, RotationAndScaleTransformWithTransformOrigin) {
   TransformationMatrix transformMatrix;
   transformMatrix.rotate(45);
   transformMatrix.scale(2);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          transformMatrix,
                                          FloatPoint3D(50, 50, 0));
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   transformMatrix.applyTransformOrigin(50, 50, 0);
   FloatRect output = transformMatrix.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, transformMatrix,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, NestedTransforms) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, scaleTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   FloatRect input(0, 0, 100, 100);
   TransformationMatrix final = rotateTransform * scaleTransform;
   FloatRect output = final.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, final,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(rotateTransform,
             getTransformCache(rootPropertyTreeState()).get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform1 =
@@ skipping 11 matching lines @@
 
   FloatRect input(0, 0, 100, 100);
   // 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,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(scaleTransform, getTransformCache(rootPropertyTreeState())
 
                                 .get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
@@ skipping 12 matching lines @@
 
   PropertyTreeState intermediateState = rootPropertyTreeState();
   intermediateState.setTransform(transform1.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output = scaleTransform.mapRect(input);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(input, output, output, scaleTransform,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 intermediateState, hasRadius);
+                 intermediateState);
 }
 
 TEST_F(GeometryMapperTest, SimpleClip) {
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(10, 10, 50, 50));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
 
   FloatRect input(0, 0, 100, 100);
   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
                  clip->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 }
 
 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);
 
   bool hasRadius = true;
   CHECK_MAPPINGS(input,   // Input
                  output,  // Visual rect
                  input,   // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),           // Transform matrix to ancestor space
                  clip->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 }
 
 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 11 matching lines @@
   FloatRect output1(10, 10, 30, 40);
 
   bool hasRadius = true;
   CHECK_MAPPINGS(input,    // Input
                  output1,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clip1->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 ancestorState, hasRadius);
+                 ancestorState);
 
   ancestorState.setClip(clip1.get());
   FloatRect output2(10, 10, 50, 50);
 
   hasRadius = false;
   CHECK_MAPPINGS(input,    // Input
                  output2,  // Visual rect
                  input,    // Transformed rect (not clipped).
                  TransformPaintPropertyNode::root()
                      ->matrix(),  // Transform matrix to ancestor space
                  clip2->clipRect().rect(),  // Clip rect in ancestor space
                  localState,
-                 ancestorState, hasRadius);
+                 ancestorState);
 }
 
 TEST_F(GeometryMapperTest, ClipBeforeTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
@@ skipping 11 matching lines @@
 
   bool hasRadius = false;
   CHECK_MAPPINGS(
       input,                           // Input
       output,                          // Visual rect
       rotateTransform.mapRect(input),  // Transformed rect (not clipped).
       rotateTransform,                 // Transform matrix to ancestor space
       rotateTransform.mapRect(
           clip->clipRect().rect()),  // Clip rect in ancestor space
       localState,
-      rootPropertyTreeState(), hasRadius);
+      rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, ClipAfterTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(10, 10, 200, 200));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setClip(clip.get());
   localState.setTransform(transform.get());
 
   FloatRect input(0, 0, 100, 100);
   FloatRect output(input);
   output = rotateTransform.mapRect(output);
   output.intersect(clip->clipRect().rect());
 
   bool hasRadius = false;
   CHECK_MAPPINGS(
       input,                           // Input
       output,                          // Visual rect
       rotateTransform.mapRect(input),  // Transformed rect (not clipped)
       rotateTransform,                 // Transform matrix to ancestor space
       clip->clipRect().rect(),         // Clip rect in ancestor space
-      localState, rootPropertyTreeState(), hasRadius);
+      localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, TwoClipsWithTransformBetween) {
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(10, 10, 200, 200));
 
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
@@ skipping 14 matching lines @@
     FloatRect output(input);
     output = rotateTransform.mapRect(output);
     output.intersect(clip1->clipRect().rect());
 
     CHECK_MAPPINGS(
         input,                           // Input
         output,                          // Visual rect
         rotateTransform.mapRect(input),  // Transformed rect (not clipped)
         rotateTransform,                 // Transform matrix to ancestor space
         clip1->clipRect().rect(),        // Clip rect in ancestor space
-        localState, rootPropertyTreeState(), hasRadius);
+        localState, rootPropertyTreeState());
   }
 
   {
     PropertyTreeState localState = rootPropertyTreeState();
     localState.setClip(clip2.get());
     localState.setTransform(transform.get());
 
     FloatRect mappedClip = rotateTransform.mapRect(clip2->clipRect().rect());
     mappedClip.intersect(clip1->clipRect().rect());
 
     // All clips are performed in the space of the ancestor. In cases such as
     // this, this means the clip is a bit lossy.
     FloatRect output(input);
     // Map to transformed rect in ancestor space.
     output = rotateTransform.mapRect(output);
     // Intersect with all clips between local and ancestor, independently mapped
     // to ancestor space.
     output.intersect(mappedClip);
 
     CHECK_MAPPINGS(
         input,                           // Input
         output,                          // Visual rect
         rotateTransform.mapRect(input),  // Transformed rect (not clipped)
         rotateTransform,                 // Transform matrix to ancestor space
         mappedClip,                      // Clip rect in ancestor space
-        localState, rootPropertyTreeState(), hasRadius);
+        localState, rootPropertyTreeState());
   }
 }
 
 TEST_F(GeometryMapperTest, SiblingTransforms) {
   // These transforms are siblings. Thus mapping from one to the other requires
   // going through the root.
   TransformationMatrix rotateTransform1;
   rotateTransform1.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
@@ skipping 191 matching lines @@
   output.intersect(clipAboveEffect->clipRect().rect());
   EXPECT_EQ(FloatRect(-50, -50, 150, 150), output);
   // 5. transformAboveEffect
   output = transformAboveEffect->matrix().mapRect(output);
   EXPECT_EQ(FloatRect(-150, -150, 450, 450), output);
 
   bool hasRadius = false;
   CHECK_MAPPINGS(
       input, output, FloatRect(0, 0, 300, 300),
       transformAboveEffect->matrix() * transformBelowEffect->matrix(),
-      FloatRect(30, 30, 270, 270), localState, rootPropertyTreeState(),
-      hasRadius);
+      FloatRect(30, 30, 270, 270), localState, rootPropertyTreeState());
 }
 
 TEST_F(GeometryMapperTest, ReflectionWithPaintOffset) {
   CompositorFilterOperations filters;
   filters.appendReferenceFilter(SkiaImageFilterBuilder::buildBoxReflectFilter(
       BoxReflection(BoxReflection::HorizontalReflection, 0), nullptr));
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
       rootPropertyTreeState().effect(), rootPropertyTreeState().transform(),
       rootPropertyTreeState().clip(), filters, 1.0, SkBlendMode::kSrcOver,
       CompositingReasonNone, CompositorElementId(), FloatPoint(100, 100));
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setEffect(effect);
 
   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(),
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
-                 rootPropertyTreeState(), hasRadius);
+                 rootPropertyTreeState());
 }
 
 }  // namespace blink