Plumb border radius through when computing clip visual rects.

third_party/WebKit/Source/platform/graphics/paint/GeometryMapper.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/RuntimeEnabledFeatures.h"
 #include "platform/geometry/LayoutRect.h"
 
 namespace blink {
 
-FloatRect GeometryMapper::sourceToDestinationVisualRect(
+FloatClipRect GeometryMapper::sourceToDestinationVisualRect(
     const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState) {
   bool success = false;
-  FloatRect result = sourceToDestinationVisualRectInternal(
+  FloatClipRect result = sourceToDestinationVisualRectInternal(
       rect, sourceState, destinationState, success);
   DCHECK(success);
   return result;
 }
 
-FloatRect GeometryMapper::sourceToDestinationVisualRectInternal(
+FloatClipRect GeometryMapper::sourceToDestinationVisualRectInternal(
     const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success) {
-  FloatRect result = localToAncestorVisualRectInternal(
+  FloatClipRect result = localToAncestorVisualRectInternal(
       rect, sourceState, destinationState, success);
   // Success if destinationState is an ancestor state.
   if (success)
     return result;
 
   // Otherwise first map to the lowest common ancestor, then map to destination.
   const TransformPaintPropertyNode* lcaTransform = lowestCommonAncestor(
       sourceState.transform(), destinationState.transform());
   DCHECK(lcaTransform);
 
   // Assume that the clip of destinationState is an ancestor of the clip of
   // sourceState and is under the space of lcaTransform. Otherwise
   // localToAncestorVisualRect() will fail.
   PropertyTreeState lcaState = destinationState;
   lcaState.setTransform(lcaTransform);
 
-  FloatRect lcaVisualRect =
+  result =
       localToAncestorVisualRectInternal(rect, sourceState, lcaState, success);
   if (!success)
-    return lcaVisualRect;
-  return ancestorToLocalRect(lcaVisualRect, lcaTransform,
-                             destinationState.transform());
+    return result;
+  FloatRect final = ancestorToLocalRect(result.rect(), lcaTransform,
+                                        destinationState.transform());
+  result.setRect(final);
+  return result;
 }
 
 FloatRect GeometryMapper::sourceToDestinationRect(
     const FloatRect& rect,
     const TransformPaintPropertyNode* sourceTransformNode,
     const TransformPaintPropertyNode* destinationTransformNode) {
   bool success = false;
   FloatRect result = localToAncestorRectInternal(
       rect, sourceTransformNode, destinationTransformNode, success);
   // Success if destinationTransformNode is an ancestor of sourceTransformNode.
   if (success)
     return result;
 
   // Otherwise first map to the least common ancestor, then map to destination.
   const TransformPaintPropertyNode* lcaTransform =
       lowestCommonAncestor(sourceTransformNode, destinationTransformNode);
   DCHECK(lcaTransform);
 
   FloatRect lcaRect =
       localToAncestorRect(rect, sourceTransformNode, lcaTransform);
   return ancestorToLocalRect(lcaRect, lcaTransform, destinationTransformNode);
 }
 
-FloatRect GeometryMapper::localToAncestorVisualRect(
+FloatClipRect GeometryMapper::localToAncestorVisualRect(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState) {
   bool success = false;
-  FloatRect result = localToAncestorVisualRectInternal(rect, localState,
-                                                       ancestorState, success);
+  FloatClipRect result = localToAncestorVisualRectInternal(
+      rect, localState, ancestorState, success);
   DCHECK(success);
   return result;
 }
 
-FloatRect GeometryMapper::localToAncestorVisualRectInternal(
+FloatClipRect GeometryMapper::localToAncestorVisualRectInternal(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success) {
   if (localState == ancestorState) {
     success = true;
     return rect;
   }
 
   const auto& transformMatrix = localToAncestorMatrixInternal(
       localState.transform(), ancestorState.transform(), success);
   if (!success)
     return rect;
 
   FloatRect mappedRect = transformMatrix.mapRect(rect);
 
-  const auto clipRect =
+  FloatClipRect clipRect =
       localToAncestorClipRectInternal(localState, ancestorState, success);
 
   if (success) {
-    mappedRect.intersect(clipRect);
+    clipRect.intersect(mappedRect);
   } else if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     // On SPv1 we may fail when the paint invalidation container creates an
     // overflow clip (in ancestorState) which is not in localState of an
     // out-of-flow positioned descendant. See crbug.com/513108 and layout test
     // compositing/overflow/handle-non-ancestor-clip-parent.html (run with
     // --enable-prefer-compositing-to-lcd-text) for details.
     // Ignore it for SPv1 for now.
     success = true;
   }
 
-  return mappedRect;
+  return clipRect;
 }
 
 FloatRect GeometryMapper::localToAncestorRect(
     const FloatRect& rect,
     const TransformPaintPropertyNode* localTransformNode,
     const TransformPaintPropertyNode* ancestorTransformNode) {
   bool success = false;
   FloatRect result = localToAncestorRectInternal(
       rect, localTransformNode, ancestorTransformNode, success);
   DCHECK(success);
@@ skipping 50 matching lines @@
     const ClipPaintPropertyNode* clip) {
   PrecomputedDataForAncestor& precomputedData =
       getPrecomputedDataForAncestor(transform);
 
   auto addResult = precomputedData.precomputedClips.insert(clip, nullptr);
   if (addResult.isNewEntry)
     addResult.storedValue->value = WTF::makeUnique<ClipCache>();
   return *addResult.storedValue->value;
 }
 
-FloatRect GeometryMapper::localToAncestorClipRect(
+FloatClipRect GeometryMapper::localToAncestorClipRect(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState) {
   bool success = false;
-  FloatRect result =
+  FloatClipRect result =
       localToAncestorClipRectInternal(localState, ancestorState, success);
   DCHECK(success);
   return result;
 }
 
-FloatRect GeometryMapper::localToAncestorClipRectInternal(
+FloatClipRect GeometryMapper::localToAncestorClipRectInternal(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success) {
-  FloatRect clip(LayoutRect::infiniteIntRect());
+  FloatClipRect clip(LayoutRect::infiniteIntRect());
   if (localState.clip() == ancestorState.clip()) {
     success = true;
     return clip;
   }
 
   ClipCache& clipCache =
       getClipCache(ancestorState.transform(), ancestorState.clip());
   const ClipPaintPropertyNode* clipNode = localState.clip();
   Vector<const ClipPaintPropertyNode*> intermediateNodes;
 
@@ skipping 17 matching lines @@
   // computing and memoizing clip rects as we go.
   for (auto it = intermediateNodes.rbegin(); it != intermediateNodes.rend();
        ++it) {
     success = false;
     const TransformationMatrix& transformMatrix = localToAncestorMatrixInternal(
         (*it)->localTransformSpace(), ancestorState.transform(), success);
     if (!success)
       return clip;
     FloatRect mappedRect = transformMatrix.mapRect((*it)->clipRect().rect());
     clip.intersect(mappedRect);
+    if ((*it)->clipRect().isRounded())
+      clip.setHasRadius(true);
     clipCache.set(*it, clip);
   }
 
   success = true;
   return clipCache.find(localState.clip())->value;
 }
 
 const TransformationMatrix& GeometryMapper::localToAncestorMatrix(
     const TransformPaintPropertyNode* localTransformNode,
     const TransformPaintPropertyNode* ancestorTransformNode) {
@@ skipping 104 matching lines @@
     const TransformPaintPropertyNode*,
     const TransformPaintPropertyNode*);
 template const ClipPaintPropertyNode* GeometryMapper::lowestCommonAncestor(
     const ClipPaintPropertyNode*,
     const ClipPaintPropertyNode*);
 template const ScrollPaintPropertyNode* GeometryMapper::lowestCommonAncestor(
     const ScrollPaintPropertyNode*,
     const ScrollPaintPropertyNode*);
 
 }  // namespace blink