Compute rounded-ness of 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 {
 
 const TransformationMatrix& GeometryMapper::identityMatrix() {
   DEFINE_STATIC_LOCAL(TransformationMatrix, identity, (TransformationMatrix()));
   return identity;
 }
 
 const FloatClipRect& GeometryMapper::infiniteClip() {
   DEFINE_STATIC_LOCAL(FloatClipRect, infinite, (FloatClipRect()));
   return infinite;
 }
 
 FloatClipRect& GeometryMapper::tempRect() {
   DEFINE_STATIC_LOCAL(FloatClipRect, temp, (FloatClipRect()));
   return temp;
 }
 
 void GeometryMapper::sourceToDestinationVisualRect(
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
-    FloatRect& rect) {
+    FloatClipRect& rect) {
   bool success = false;
   sourceToDestinationVisualRectInternal(sourceState, destinationState, rect,
                                         success);
   DCHECK(success);
 }
 
 void GeometryMapper::sourceToDestinationVisualRectInternal(
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
-    FloatRect& mappingRect,
+    FloatClipRect& mappingRect,
     bool& success) {
   localToAncestorVisualRectInternal(sourceState, destinationState, mappingRect,
                                     success);
   // Success if destinationState is an ancestor state.
   if (success)
     return;
 
   // 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);
 
   localToAncestorVisualRectInternal(sourceState, lcaState, mappingRect,
                                     success);
   if (!success)
     return;
 
-  ancestorToLocalRect(lcaTransform, destinationState.transform(), mappingRect);
+  ancestorToLocalRect(lcaTransform, destinationState.transform(),
+                      mappingRect.rect());
 }
 
 void GeometryMapper::sourceToDestinationRect(
     const TransformPaintPropertyNode* sourceTransformNode,
     const TransformPaintPropertyNode* destinationTransformNode,
     FloatRect& mappingRect) {
   bool success = false;
   localToAncestorRectInternal(sourceTransformNode, destinationTransformNode,
                               mappingRect, success);
   // Success if destinationTransformNode is an ancestor of sourceTransformNode.
   if (success)
     return;
 
   // Otherwise first map to the least common ancestor, then map to destination.
   const TransformPaintPropertyNode* lcaTransform =
       lowestCommonAncestor(sourceTransformNode, destinationTransformNode);
   DCHECK(lcaTransform);
 
   localToAncestorRect(sourceTransformNode, lcaTransform, mappingRect);
   ancestorToLocalRect(lcaTransform, destinationTransformNode, mappingRect);
 }
 
 void GeometryMapper::localToAncestorVisualRect(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
-    FloatRect& mappingRect) {
+    FloatClipRect& mappingRect) {
   bool success = false;
   localToAncestorVisualRectInternal(localState, ancestorState, mappingRect,
                                     success);
   DCHECK(success);
 }
 
 void GeometryMapper::localToAncestorVisualRectInternal(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
-    FloatRect& rectToMap,
+    FloatClipRect& rectToMap,
     bool& success) {
   if (localState == ancestorState) {
     success = true;
     return;
   }
 
   if (localState.effect() != ancestorState.effect()) {
     slowLocalToAncestorVisualRectWithEffects(localState, ancestorState,
                                              rectToMap, success);
     return;
   }
 
   const auto& transformMatrix = localToAncestorMatrixInternal(
       localState.transform(), ancestorState.transform(), success);
   if (!success) {
     return;
   }
 
-  FloatRect mappedRect = transformMatrix.mapRect(rectToMap);
+  FloatRect mappedRect = transformMatrix.mapRect(rectToMap.rect());
 
-  const FloatClipRect& clipRect =
+  FloatClipRect clipRect =
       localToAncestorClipRectInternal(localState.clip(), ancestorState.clip(),
                                       ancestorState.transform(), success);
 
   if (success) {
-    rectToMap = clipRect.rect();
+    rectToMap = clipRect;

[wkorman, 2017/04/05 20:06:47]

It looks like (but please confirm) this is the critical bit where we end up
propagating has-radius to the original callsites. Perhaps worth adding a comment
to call this out, since we work with just FloatRect in some places vs
FloatClipRect here, so reader might wonder why.

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

Done.

     rectToMap.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;
   }
 }
 
 void GeometryMapper::slowLocalToAncestorVisualRectWithEffects(
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
-    FloatRect& mappingRect,
+    FloatClipRect& mappingRect,
     bool& success) {
   PropertyTreeState lastTransformAndClipState(localState.transform(),
                                               localState.clip(), nullptr);
 
   for (const auto* effect = localState.effect();
        effect && effect != ancestorState.effect(); effect = effect->parent()) {
     if (!effect->hasFilterThatMovesPixels())
       continue;
 
     PropertyTreeState transformAndClipState(effect->localTransformSpace(),
                                             effect->outputClip(), nullptr);
     sourceToDestinationVisualRectInternal(
         lastTransformAndClipState, transformAndClipState, mappingRect, success);
     if (!success)
       return;
 
-    mappingRect = effect->mapRect(mappingRect);
+    mappingRect.setRect(effect->mapRect(mappingRect.rect()));
     lastTransformAndClipState = transformAndClipState;
   }
 
   PropertyTreeState finalTransformAndClipState(ancestorState.transform(),
                                                ancestorState.clip(), nullptr);
   sourceToDestinationVisualRectInternal(lastTransformAndClipState,
                                         finalTransformAndClipState, mappingRect,
                                         success);
 }
 
@@ skipping 295 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