Compute rounded-ness of 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/graphics/paint/FloatClipRect.h"
 #include "platform/graphics/paint/PropertyTreeState.h"
 #include "platform/transforms/TransformationMatrix.h"
@@ skipping 29 matching lines @@
   // 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.
   //
   // |mappingRect| is both input and output.

[trchen, 2017/04/05 20:10:36]

As discussed, could you add a TODO here, stating that the output FloatClipRect
can contains false positive if there are non-trivial transforms in between, and
such false positive is not signaled by hasRadius, and why it is okay for current
implementation? e.g. something like this:

// TODO(crbug.com/xxxxxx): Need a way to signal false positive from
// non-trivial transforms. The visual rect functions can return rects
// bigger than the actual mapped regions, due to border radius and
// non-trivial transforms. This is fine for invalidation purposes,
// but would be an error for clipping purposes that requires an exact
// mapping. Rounded corners are signaled by hasRadius() bit on the
// output. Currently all callers that requires a exact clip rect
// never maps over non-trivial transforms. We need to add a DCHECK
// to ensure that stays the way.

[chrishtr, 2017/04/05 20:22:15]

Done. I put some of the comments here and some in PaintLayerClipper.

   static void sourceToDestinationVisualRect(
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
-      FloatRect& mappingRect);
+      FloatClipRect& mappingRect);
 
   // Same as sourceToDestinationVisualRect() except that only transforms are
   // applied.
   //
   // |mappingRect| is both input and output.
   static void sourceToDestinationRect(
       const TransformPaintPropertyNode* sourceTransformNode,
       const TransformPaintPropertyNode* destinationTransformNode,
       FloatRect& mappingRect);
 
   // 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|.
   //
   // |mappingRect| is both input and output.
   static void localToAncestorVisualRect(
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState,
-      FloatRect& mappingRect);
+      FloatClipRect& mappingRect);
 
   // 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
   // |ancestorTransformNode|.
   //
   //|mappingRect| is both input and output.
@@ skipping 49 matching lines @@
 
  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.
 
   static void sourceToDestinationVisualRectInternal(
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
-      FloatRect& mappingRect,
+      FloatClipRect& mappingRect,
       bool& success);
 
   static void localToAncestorVisualRectInternal(
       const PropertyTreeState& localTransformState,
       const PropertyTreeState& ancestorState,
-      FloatRect& mappingRect,
+      FloatClipRect& mappingRect,
       bool& success);
 
   static void localToAncestorRectInternal(
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
       FloatRect&,
       bool& success);
 
   static const TransformationMatrix& localToAncestorMatrixInternal(
       const TransformPaintPropertyNode* localTransformNode,
       const TransformPaintPropertyNode* ancestorTransformNode,
       bool& success);
 
   static const FloatClipRect& localToAncestorClipRectInternal(
       const ClipPaintPropertyNode* descendant,
       const ClipPaintPropertyNode* ancestorClip,
       const TransformPaintPropertyNode* ancestorTransform,
       bool& success);
 
   static const FloatClipRect& sourceToDestinationClipRectInternal(
       const PropertyTreeState& sourceState,
       const PropertyTreeState& destinationState,
       bool& success);
 
   static void slowLocalToAncestorVisualRectWithEffects(
       const PropertyTreeState& localState,
       const PropertyTreeState& ancestorState,
-      FloatRect& mappingRect,
+      FloatClipRect& mappingRect,
       bool& success);
 
   static const TransformationMatrix& identityMatrix();
   static const FloatClipRect& infiniteClip();
   static FloatClipRect& tempRect();
 
   friend class GeometryMapperTest;
   friend class PaintLayerClipperTest;
 };
 
 }  // namespace blink
 
 #endif  // GeometryMapper_h