Plumb border radius through when computing clip visual rects.

third_party/WebKit/Source/platform/graphics/paint/GeometryMapper.h

 // 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.
 
 #ifndef GeometryMapper_h
 #define GeometryMapper_h
 
-#include "platform/geometry/FloatRect.h"
+#include "platform/graphics/paint/FloatClipRect.h"
 #include "platform/graphics/paint/PropertyTreeState.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "wtf/HashMap.h"
 
 namespace blink {
 
 // Maps from a descendant clip node to its equivalent "clip visual rect" in
 // the space of the ancestor. The clip visual rect is defined as the
 // intersection of all clips between the descendant and the ancestor (*not*
 // including the ancestor) in the clip tree, individually transformed from
 // their localTransformSpace into the ancestor's localTransformSpace.
-typedef HashMap<const ClipPaintPropertyNode*, FloatRect> ClipCache;
+// If one of the clip that contributes to it has a border radius, the
+// hasRadius() field is set to true.
+typedef HashMap<const ClipPaintPropertyNode*, FloatClipRect> ClipCache;
 
 // Maps from a transform node that is a descendant of the ancestor to the
 // combined transform between the descendant's and the ancestor's coordinate
 typedef HashMap<const TransformPaintPropertyNode*, TransformationMatrix>
     TransformCache;
 
 struct PrecomputedDataForAncestor {
   TransformCache toAncestorTransforms;
 
   // There can be multiple clips within the same transform space. This
@@ skipping 29 matching lines @@
   // If the clips and transforms of |sourceState| are equal to or descendants of
   // those of |destinationState|, returns the same value as
   // localToAncestorVisualRect. Otherwise, maps the input rect to the
   // transform state which is the lowest common ancestor of
   // |sourceState.transform| and |destinationState.transform|, then multiplies
   // it by the the inverse transform mapping from the lowest common ancestor to
   // |destinationState.transform|.
   //
   // DCHECK fails if the clip of |destinationState| is not an ancestor of the
   // clip of |sourceState|, or the inverse transform is not invertible.
-  FloatRect sourceToDestinationVisualRect(
+  FloatClipRect sourceToDestinationVisualRect(
       const FloatRect&,
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState);
 
   // Same as sourceToDestinationVisualRect() except that only transforms are
   // applied.
   FloatRect sourceToDestinationRect(
       const FloatRect&,
       const TransformPaintPropertyNode* sourceTransformNode,
       const TransformPaintPropertyNode* destinationTransformNode);
 
   // Maps from a rect in |localTransformSpace| to its visual rect in
   // |ancestorState|. This is computed by multiplying the rect by its combined
   // transform between |localTransformSpace| and |ancestorSpace|, then
   // flattening into 2D space, then intersecting by the "clip visual rect" for
   // |localTransformState|'s clips. See above for the definition of "clip visual
   // rect".
   //
   // Note that the clip of |ancestorState| is *not* applied.
   //
   // DCHECK fails if any of the paint property tree nodes in
   // |localTransformState| are not equal to or a descendant of that in
   // |ancestorState|.
-  FloatRect localToAncestorVisualRect(
+  FloatClipRect localToAncestorVisualRect(
       const FloatRect&,
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState);
 
   // Maps from a rect in |localTransformNode| space to its transformed rect in
   // |ancestorTransformNode| space. This is computed by multiplying the rect by
   // the combined transform between |localTransformNode| and
   // |ancestorTransformNode|, then flattening into 2D space.
   //
   // DCHECK fails if |localTransformNode| is not equal to or a descendant of
@@ skipping 18 matching lines @@
 
   // Returns the matrix used in |LocalToAncestorRect|. DCHECK fails iff
   // |localTransformNode| is not equal to or a descendant of
   // |ancestorTransformNode|.
   const TransformationMatrix& localToAncestorMatrix(
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode);
 
   // Returns the "clip visual rect" between |localTransformState| and
   // |ancestorState|. See above for the definition of "clip visual rect".
-  FloatRect localToAncestorClipRect(
+  FloatClipRect localToAncestorClipRect(
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState);
 
   // Returns the lowest common ancestor in the paint property tree.
   template <typename NodeType>
   static PLATFORM_EXPORT const NodeType* lowestCommonAncestor(const NodeType*,
                                                               const NodeType*);
 
   void clearCache();
 
  private:
   // The internal methods do the same things as their public counterparts, but
   // take an extra |success| parameter which indicates if the function is
   // successful on return. See comments of the public functions for failure
   // conditions.
 
-  FloatRect sourceToDestinationVisualRectInternal(
+  FloatClipRect sourceToDestinationVisualRectInternal(
       const FloatRect&,
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
       bool& success);
 
-  FloatRect localToAncestorVisualRectInternal(
+  FloatClipRect localToAncestorVisualRectInternal(
       const FloatRect&,
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState,
       bool& success);
 
   FloatRect localToAncestorRectInternal(
       const FloatRect&,
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
       bool& success);
 
   const TransformationMatrix& localToAncestorMatrixInternal(
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
       bool& success);
 
-  FloatRect localToAncestorClipRectInternal(
+  FloatClipRect localToAncestorClipRectInternal(
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState,
       bool& success);
 
   // Returns the precomputed data if already set, or adds and memoizes a new
   // PrecomputedDataForAncestor otherwise.
   PrecomputedDataForAncestor& getPrecomputedDataForAncestor(
       const TransformPaintPropertyNode*);
 
   // Returns the transform cache for the given ancestor transform node.
@@ skipping 11 matching lines @@
       m_data;
 
   const TransformationMatrix m_identity;
 
   DISALLOW_COPY_AND_ASSIGN(GeometryMapper);
 };
 
 }  // namespace blink
 
 #endif  // GeometryMapper_h