Fix clip caching bug in GeometryMapper.

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/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
@@ skipping 11 matching lines @@
 
   std::unique_ptr<GeometryMapper> geometryMapper;
 
   PropertyTreeState rootPropertyTreeState() {
     PropertyTreeState state(TransformPaintPropertyNode::root(),
                             ClipPaintPropertyNode::root(),
                             EffectPaintPropertyNode::root());
     return state;
   }
 
-  PrecomputedDataForAncestor& getPrecomputedDataForAncestor(
+  TransformCache& getTransformCache(
       const PropertyTreeState& propertyTreeState) {
-    return geometryMapper->getPrecomputedDataForAncestor(
-        propertyTreeState.transform());
+    return geometryMapper->getTransformCache(propertyTreeState.transform());
+  }
+
+  ClipCache& getClipCache(const PropertyTreeState& propertyTreeState) {
+    return geometryMapper->getClipCache(propertyTreeState.transform(),
+                                        propertyTreeState.clip());
   }
 
   const TransformPaintPropertyNode* lowestCommonAncestor(
       const TransformPaintPropertyNode* a,
       const TransformPaintPropertyNode* b) {
     return GeometryMapper::lowestCommonAncestor(a, b);
   }
 
   FloatRect sourceToDestinationVisualRectInternal(
       const FloatRect& rect,
@@ skipping 70 matching lines @@
     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() !=                               \
         localPropertyTreeState.transform()) {                                  \
-      EXPECT_EQ(                                                               \
-          expectedTransformToAncestor,                                         \
-          getPrecomputedDataForAncestor(ancestorPropertyTreeState)             \
-              .toAncestorTransforms.get(localPropertyTreeState.transform()));  \
+      EXPECT_EQ(expectedTransformToAncestor,                                   \
+                getTransformCache(ancestorPropertyTreeState)                   \
+                    .get(localPropertyTreeState.transform()));                 \
     }                                                                          \
     if (ancestorPropertyTreeState.clip() != localPropertyTreeState.clip()) {   \
       EXPECT_EQ(expectedClipInAncestorSpace,                                   \
-                getPrecomputedDataForAncestor(ancestorPropertyTreeState)       \
-                    .toAncestorClipRects.get(localPropertyTreeState.clip()));  \
+                getClipCache(ancestorPropertyTreeState)                        \
+                    .get(localPropertyTreeState.clip()));                      \
     }                                                                          \
   } while (false)
 
 TEST_F(GeometryMapperTest, Root) {
   FloatRect input(0, 0, 100, 100);
 
   CHECK_MAPPINGS(input, input, input,
                  TransformPaintPropertyNode::root()->matrix(),
                  ClipPaintPropertyNode::root()->clipRect().rect(),
                  rootPropertyTreeState(), rootPropertyTreeState());
@@ skipping 93 matching lines @@
   FloatRect input(0, 0, 100, 100);
   TransformationMatrix final = rotateTransform * scaleTransform;
   FloatRect output = final.mapRect(input);
 
   CHECK_MAPPINGS(input, output, output, final,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
   EXPECT_EQ(rotateTransform,
-            getPrecomputedDataForAncestor(rootPropertyTreeState())
-                .toAncestorTransforms.get(transform1.get()));
+            getTransformCache(rootPropertyTreeState()).get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsScaleAndTranslation) {
   TransformationMatrix scaleTransform;
   scaleTransform.scale(2);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          scaleTransform, FloatPoint3D());
 
   TransformationMatrix translateTransform;
   translateTransform.translate(100, 0);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, translateTransform,
                                          FloatPoint3D());
 
   PropertyTreeState localState = rootPropertyTreeState();
   localState.setTransform(transform2.get());
 
   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);
 
   CHECK_MAPPINGS(input, output, output, final,
                  ClipPaintPropertyNode::root()->clipRect().rect(), localState,
                  rootPropertyTreeState());
 
   // Check the cached matrix for the intermediate transform.
-  EXPECT_EQ(scaleTransform,
-            getPrecomputedDataForAncestor(rootPropertyTreeState())
-                .toAncestorTransforms.get(transform1.get()));
+  EXPECT_EQ(scaleTransform, getTransformCache(rootPropertyTreeState())
+
+                                .get(transform1.get()));
 }
 
 TEST_F(GeometryMapperTest, NestedTransformsIntermediateDestination) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   TransformationMatrix scaleTransform;
@@ skipping 30 matching lines @@
   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());
 }
 
+TEST_F(GeometryMapperTest, TwoClips) {
+  RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(10, 10, 30, 40));
+
+  RefPtr<ClipPaintPropertyNode> clip2 =
+      ClipPaintPropertyNode::create(clip1, TransformPaintPropertyNode::root(),
+                                    FloatRoundedRect(10, 10, 50, 50));
+
+  PropertyTreeState localState = rootPropertyTreeState();
+  PropertyTreeState ancestorState = rootPropertyTreeState();
+  localState.setClip(clip2.get());
+
+  FloatRect input(0, 0, 100, 100);
+  FloatRect output1(10, 10, 30, 40);
+
+  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);
+
+  ancestorState.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
+                 clip2->clipRect().rect(),  // Clip rect in ancestor space
+                 localState,
+                 ancestorState);
+}
+
 TEST_F(GeometryMapperTest, ClipBeforeTransform) {
   TransformationMatrix rotateTransform;
   rotateTransform.rotate(45);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(rootPropertyTreeState().transform(),
                                          rotateTransform, FloatPoint3D());
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), transform.get(),
       FloatRoundedRect(10, 10, 50, 50));
@@ skipping 258 matching lines @@
   EXPECT_EQ(rootPropertyTreeState().transform(),
             lowestCommonAncestor(childOfChild2.get(),
                                  rootPropertyTreeState().transform()));
   EXPECT_EQ(child2, lowestCommonAncestor(childOfChild2.get(), child2.get()));
 
   EXPECT_EQ(rootPropertyTreeState().transform(),
             lowestCommonAncestor(child1.get(), child2.get()));
 }
 
 }  // namespace blink