Support css clip on fixed-position GeometryMapper

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/geometry/LayoutRect.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 
 namespace blink {
 
 FloatRect GeometryMapper::mapToVisualRectInDestinationSpace(const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success)
 {
     FloatRect result = localToVisualRectInAncestorSpace(rect, sourceState, destinationState, success);
     if (success)
         return result;
-    return slowMapRectToDestinationSpace(rect, sourceState, destinationState, success);
+    return slowMapToVisualRectInDestinationSpace(rect, sourceState, destinationState, success);
 }
 
 FloatRect GeometryMapper::mapRectToDestinationSpace(const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success)
 {
     FloatRect result = localToAncestorRect(rect, sourceState, destinationState, success);
     if (success)
         return result;
     return slowMapRectToDestinationSpace(rect, sourceState, destinationState, success);
 }
 
+FloatRect GeometryMapper::slowMapToVisualRectInDestinationSpace(const FloatRect& rect,
+    const PropertyTreeState& sourceState,
+    const PropertyTreeState& destinationState,
+    bool& success)
+{
+    const TransformPaintPropertyNode* lcaTransform = propertyTreeNearestCommonAncestor<TransformPaintPropertyNode>(sourceState.transform.get(), destinationState.transform.get());
+    DCHECK(lcaTransform);
+    PropertyTreeState lcaState = sourceState;
+    lcaState.transform = lcaTransform;
+
+    FloatRect result = localToAncestorRect(rect, sourceState, lcaState, success);
+    DCHECK(success);
+
+    // It's a failure if the clip of destinationState is not an ancestor of the clip of sourceState,
+    // because otherwise we can't undo the clips from the common ancestor to destinationState.
+    const auto clipRect = localToAncestorClipRect(sourceState, destinationState, success);
+    if (!success)
+        return result;
+    result.intersect(clipRect);
+
+    const TransformationMatrix& destinationToLca = localToAncestorMatrix(destinationState.transform.get(), lcaState, success);
+    DCHECK(success);
+    if (destinationToLca.isInvertible()) {
+        success = true;
+        return destinationToLca.inverse().mapRect(result);
+    }
+    success = false;
+    return rect;
+}
+
 FloatRect GeometryMapper::slowMapRectToDestinationSpace(const FloatRect& rect,
     const PropertyTreeState& sourceState,
     const PropertyTreeState& destinationState,
     bool& success)
 {
     const TransformPaintPropertyNode* lcaTransform = propertyTreeNearestCommonAncestor<TransformPaintPropertyNode>(sourceState.transform.get(), destinationState.transform.get());
     DCHECK(lcaTransform);
     PropertyTreeState lcaState = sourceState;
     lcaState.transform = lcaTransform;
 
     FloatRect result = localToAncestorRect(rect, sourceState, lcaState, success);
     DCHECK(success);
 
     const TransformationMatrix& destinationToLca = localToAncestorMatrix(destinationState.transform.get(), lcaState, success);
     DCHECK(success);
     if (destinationToLca.isInvertible()) {
         success = true;
         return destinationToLca.inverse().mapRect(result);
     }
     success = false;
     return rect;
 }
 
 FloatRect GeometryMapper::localToVisualRectInAncestorSpace(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState, bool& success)
 {
-    const auto transformMatrix = localToAncestorMatrix(localState.transform.get(), ancestorState, success);
+    const auto& transformMatrix = localToAncestorMatrix(localState.transform.get(), ancestorState, success);
     if (!success)
         return rect;
 
     FloatRect mappedRect = transformMatrix.mapRect(rect);
 
-    const auto clipRect = localToAncestorClipRect(localState, ancestorState);
+    const auto clipRect = localToAncestorClipRect(localState, ancestorState, success);
+    DCHECK(success);
 
     mappedRect.intersect(clipRect);
     return mappedRect;
 }
 
 FloatRect GeometryMapper::localToAncestorRect(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState,
     bool& success)
 {
-    const auto transformMatrix = localToAncestorMatrix(localState.transform.get(), ancestorState, success);
+    const auto& transformMatrix = localToAncestorMatrix(localState.transform.get(), ancestorState, success);
     if (!success)
         return rect;
     return transformMatrix.mapRect(rect);
 }
 
 FloatRect GeometryMapper::ancestorToLocalRect(
     const FloatRect& rect,
     const PropertyTreeState& localState,
     const PropertyTreeState& ancestorState, bool& success)
 {
@@ skipping 12 matching lines @@
 }
 
 PrecomputedDataForAncestor& GeometryMapper::getPrecomputedDataForAncestor(const PropertyTreeState& ancestorState)
 {
     auto addResult = m_data.add(ancestorState.transform.get(), nullptr);
     if (addResult.isNewEntry)
         addResult.storedValue->value = PrecomputedDataForAncestor::create();
     return *addResult.storedValue->value;
 }
 
-const FloatRect& GeometryMapper::localToAncestorClipRect(
+FloatRect GeometryMapper::localToAncestorClipRect(
     const PropertyTreeState& localState,
-    const PropertyTreeState& ancestorState)
+    const PropertyTreeState& ancestorState,
+    bool& success)
 {
     PrecomputedDataForAncestor& precomputedData = getPrecomputedDataForAncestor(ancestorState);
     const ClipPaintPropertyNode* clipNode = localState.clip.get();
     Vector<const ClipPaintPropertyNode*> intermediateNodes;
     FloatRect clip(LayoutRect::infiniteIntRect());
 
     bool found = false;
     // Iterate over the path from localState.clip to ancestorState.clip. Stop if we've found a memoized (precomputed) clip
     // for any particular node.
     while (clipNode) {
         auto it = precomputedData.toAncestorClipRects.find(clipNode);
         if (it != precomputedData.toAncestorClipRects.end()) {
             clip = it->value;
             found = true;
             break;
         }
         intermediateNodes.append(clipNode);
 
         if (clipNode == ancestorState.clip)
             break;
 
         clipNode = clipNode->parent();
     }
     // It's illegal to ask for a local-to-ancestor clip when the ancestor is not an ancestor.

[chrishtr, 2016/08/22 22:27:31]

Remove this comment.

[Xianzhu, 2016/08/22 23:30:20]

Done.

-    DCHECK(clipNode == ancestorState.clip || found);
+    if (clipNode != ancestorState.clip && !found) {
+        success = false;
+        return LayoutRect::infiniteIntRect();
+    }
 
     // Iterate down from the top intermediate node found in the previous loop, computing and memoizing clip rects as we go.
     for (auto it = intermediateNodes.rbegin(); it != intermediateNodes.rend(); ++it) {
         if ((*it) != ancestorState.clip) {
-            bool success = false;

[chrishtr, 2016/08/22 22:27:31]

Why remove this line? Reset success to false each time at least right?

[Xianzhu, 2016/08/22 23:30:20]

Changed to
       success = false;
       const TransformationMatrix transformMatrix =
localToAncestorMatrix((*it)->localTransformSpace(), ancestorState, success);
       if (!success)
           return clip;

and added
  success = true before new line 191.

             const TransformationMatrix transformMatrix = localToAncestorMatrix((*it)->localTransformSpace(), ancestorState, success);
             DCHECK(success);
             FloatRect mappedRect = transformMatrix.mapRect((*it)->clipRect().rect());
             clip.intersect(mappedRect);
         }
 
         precomputedData.toAncestorClipRects.set(*it, clip);
     }
 
     return precomputedData.toAncestorClipRects.find(localState.clip.get())->value;
 }
 
-
 const TransformationMatrix& GeometryMapper::localToAncestorMatrix(
     const TransformPaintPropertyNode* localTransformNode,
     const PropertyTreeState& ancestorState, bool& success) {
     PrecomputedDataForAncestor& precomputedData = getPrecomputedDataForAncestor(ancestorState);
 
     const TransformPaintPropertyNode* transformNode = localTransformNode;
     Vector<const TransformPaintPropertyNode*> intermediateNodes;
     TransformationMatrix transformMatrix;
 
     bool found = false;
@@ skipping 27 matching lines @@
             transformMatrix =  transformMatrix * localTransformMatrix;
         }
 
         precomputedData.toAncestorTransforms.set(*it, transformMatrix);
     }
     success = true;
     return precomputedData.toAncestorTransforms.find(localTransformNode)->value;
 }
 
 } // namespace blink