Compute sticky position constraints without considering transforms.

third_party/WebKit/Source/core/layout/LayoutBoxModelObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 23 matching lines @@
 #include "core/layout/LayoutGeometryMap.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ShadowList.h"
 #include "platform/LengthFunctions.h"
+#include "platform/geometry/TransformState.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 class FloatStateForStyleChange {
 public:
     static void setWasFloating(LayoutBoxModelObject* boxModelObject, bool wasFloating)
     {
         s_wasFloating = wasFloating;
         s_boxModelObject = boxModelObject;
@@ skipping 632 matching lines @@
     StickyPositionScrollingConstraints constraints;
     FloatSize skippedContainersOffset;
     LayoutBlock* containingBlock = this->containingBlock();
     // Skip anonymous containing blocks.
     while (containingBlock->isAnonymous()) {
         skippedContainersOffset += toFloatSize(FloatPoint(containingBlock->frameRect().location()));
         containingBlock = containingBlock->containingBlock();
     }
     LayoutBox* scrollAncestor = layer()->ancestorOverflowLayer()->isRootLayer() ? nullptr : toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject());
 
-    LayoutRect containerContentRect = containingBlock->layoutOverflowRect();
     LayoutUnit maxContainerWidth = containingBlock->isLayoutView() ? containingBlock->logicalWidth() : containingBlock->containingBlockLogicalWidthForContent();
     // Sticky positioned element ignore any override logical width on the containing block (as they don't call
     // containingBlockLogicalWidthForContent). It's unclear whether this is totally fine.
     // Compute the container-relative area within which the sticky element is allowed to move.
     LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
 
+    // Map the containing block to the scroll ancestor without transforms.
+    FloatRect scrollContainerRelativePaddingBoxRect(containingBlock->layoutOverflowRect());
+    if (containingBlock != scrollAncestor) {
+        FloatQuad localQuad(FloatRect(containingBlock->paddingBoxRect()));
+        TransformState transformState(TransformState::ApplyTransformDirection, localQuad.boundingBox().center(), localQuad);
+        containingBlock->mapLocalToAncestor(scrollAncestor, transformState, ApplyContainerFlip);
+        transformState.flatten();
+        scrollContainerRelativePaddingBoxRect = transformState.lastPlanarQuad().boundingBox();
+
+        // The sticky position constraint rects should be independent of the current scroll position, so after
+        // mapping we add in the scroll position to get the container's position within the ancestor scroller's
+        // unscrolled layout overflow.
+        FloatSize scrollOffset(scrollAncestor ? toFloatSize(scrollAncestor->getScrollableArea()->adjustedScrollOffset()) : FloatSize());
+        scrollContainerRelativePaddingBoxRect.move(scrollOffset);
+    }
+
+    LayoutRect scrollContainerRelativeContainingBlockRect(scrollContainerRelativePaddingBoxRect);
     // This is removing the padding of the containing block's overflow rect to get the flow
     // box rectangle and removing the margin of the sticky element to ensure that space between
     // the sticky element and its containing flow box. It is an open issue whether the margin
     // should collapse (See https://www.w3.org/TR/css-position-3/#sticky-pos).
-    containerContentRect.contractEdges(
+    scrollContainerRelativeContainingBlockRect.contractEdges(
         minimumValueForLength(containingBlock->style()->paddingTop(), maxContainerWidth) + minimumValueForLength(style()->marginTop(), maxWidth),
         minimumValueForLength(containingBlock->style()->paddingRight(), maxContainerWidth) + minimumValueForLength(style()->marginRight(), maxWidth),
         minimumValueForLength(containingBlock->style()->paddingBottom(), maxContainerWidth) + minimumValueForLength(style()->marginBottom(), maxWidth),
         minimumValueForLength(containingBlock->style()->paddingLeft(), maxContainerWidth) + minimumValueForLength(style()->marginLeft(), maxWidth));
 
-    // Map to the scroll ancestor.
-    FloatRect scrollContainerRelativeContainingBlockRect(containingBlock->localToAncestorQuad(FloatRect(containerContentRect), scrollAncestor).boundingBox());
-    FloatSize scrollOffset(scrollAncestor ? toFloatSize(scrollAncestor->getScrollableArea()->adjustedScrollOffset()) : FloatSize());
-
-    // The sticky position constraint rects should be independent of the current scroll position, so after
-    // mapping we add in the scroll position to get the container's position within the ancestor scroller's
-    // unscrolled layout overflow.
-    if (containingBlock != scrollAncestor)
-        scrollContainerRelativeContainingBlockRect.move(scrollOffset);
-    constraints.setScrollContainerRelativeContainingBlockRect(scrollContainerRelativeContainingBlockRect);
+    constraints.setScrollContainerRelativeContainingBlockRect(FloatRect(scrollContainerRelativeContainingBlockRect));
 
     FloatRect stickyBoxRect = isLayoutInline()
         ? FloatRect(toLayoutInline(this)->linesBoundingBox())
         : FloatRect(toLayoutBox(this)->frameRect());
     FloatRect flippedStickyBoxRect = stickyBoxRect;
     containingBlock->flipForWritingMode(flippedStickyBoxRect);
     FloatPoint stickyLocation = flippedStickyBoxRect.location() + skippedContainersOffset;
 
-    // TODO(flackr): Unfortunate to call localToAncestorQuad again, but we can't just offset from the previously computed rect if there are transforms.
-    // Map to the scroll ancestor.
-    FloatRect scrollContainerRelativeContainerFrame = containingBlock->localToAncestorQuad(FloatRect(FloatPoint(), FloatSize(containingBlock->size())), scrollAncestor).boundingBox();
-    // The sticky position constraint rects should be independent of the current scroll position, so after
-    // mapping we add in the scroll position to get the container's position within the ancestor scroller's
-    // unscrolled layout overflow.
-    if (containingBlock != scrollAncestor)
-        scrollContainerRelativeContainerFrame.move(scrollOffset);
-
-    constraints.setScrollContainerRelativeStickyBoxRect(FloatRect(scrollContainerRelativeContainerFrame.location() + toFloatSize(stickyLocation), flippedStickyBoxRect.size()));
+    // The scrollContainerRelativePaddingBoxRect's position is the padding box so we need to remove the border when finding
+    // the position of the sticky box within the scroll ancestor if the container is not our scroll ancestor.
+    if (containingBlock != scrollAncestor) {
+        FloatSize containerBorderOffset(containingBlock->borderLeft(), containingBlock->borderTop());
+        stickyLocation -= containerBorderOffset;
+    }
+    constraints.setScrollContainerRelativeStickyBoxRect(FloatRect(scrollContainerRelativePaddingBoxRect.location() + toFloatSize(stickyLocation), flippedStickyBoxRect.size()));
 
     // We skip the right or top sticky offset if there is not enough space to honor both the left/right or top/bottom offsets.
     LayoutUnit horizontalOffsets = minimumValueForLength(style()->right(), LayoutUnit(constrainingSize.width())) +
         minimumValueForLength(style()->left(), LayoutUnit(constrainingSize.width()));
     bool skipRight = false;
     bool skipLeft = false;
     if (!style()->left().isAuto() && !style()->right().isAuto()) {
-        if (horizontalOffsets > containerContentRect.width()
-            || horizontalOffsets + containerContentRect.width() > constrainingSize.width()) {
+        if (horizontalOffsets > scrollContainerRelativeContainingBlockRect.width()
+            || horizontalOffsets + scrollContainerRelativeContainingBlockRect.width() > constrainingSize.width()) {
             skipRight = style()->isLeftToRightDirection();
             skipLeft = !skipRight;
         }
     }
 
     if (!style()->left().isAuto() && !skipLeft) {
         constraints.setLeftOffset(minimumValueForLength(style()->left(), LayoutUnit(constrainingSize.width())));
         constraints.addAnchorEdge(StickyPositionScrollingConstraints::AnchorEdgeLeft);
     }
 
     if (!style()->right().isAuto() && !skipRight) {
         constraints.setRightOffset(minimumValueForLength(style()->right(), LayoutUnit(constrainingSize.width())));
         constraints.addAnchorEdge(StickyPositionScrollingConstraints::AnchorEdgeRight);
     }
 
     bool skipBottom = false;
     // TODO(flackr): Exclude top or bottom edge offset depending on the writing mode when related
     // sections are fixed in spec: http://lists.w3.org/Archives/Public/www-style/2014May/0286.html
     LayoutUnit verticalOffsets = minimumValueForLength(style()->top(), LayoutUnit(constrainingSize.height())) +
         minimumValueForLength(style()->bottom(), LayoutUnit(constrainingSize.height()));
     if (!style()->top().isAuto() && !style()->bottom().isAuto()) {
-        if (verticalOffsets > containerContentRect.height()
-            || verticalOffsets + containerContentRect.height() > constrainingSize.height()) {
+        if (verticalOffsets > scrollContainerRelativeContainingBlockRect.height()
+            || verticalOffsets + scrollContainerRelativeContainingBlockRect.height() > constrainingSize.height()) {
             skipBottom = true;
         }
     }
 
     if (!style()->top().isAuto()) {
         constraints.setTopOffset(minimumValueForLength(style()->top(), LayoutUnit(constrainingSize.height())));
         constraints.addAnchorEdge(StickyPositionScrollingConstraints::AnchorEdgeTop);
     }
 
     if (!style()->bottom().isAuto() && !skipBottom) {
@@ skipping 400 matching lines @@
     if (rootElementStyle->hasBackground())
         return false;
 
     if (node() != document().firstBodyElement())
         return false;
 
     return true;
 }
 
 } // namespace blink