Remove position: sticky

Source/core/rendering/RenderBoxModelObject.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 129 matching lines @@
 
     RenderStyle* styleToUse = style();
     setHasBoxDecorations(calculateHasBoxDecorations());
     setInline(styleToUse->isDisplayInlineType());
     setPositionState(styleToUse->position());
     setHorizontalWritingMode(styleToUse->isHorizontalWritingMode());
 }
 
 static LayoutSize accumulateInFlowPositionOffsets(const RenderObject* child)
 {
-    if (!child->isAnonymousBlock() || !child->isInFlowPositioned())
+    if (!child->isAnonymousBlock() || !child->isRelPositioned())
         return LayoutSize();
     LayoutSize offset;
     RenderObject* p = toRenderBlock(child)->inlineElementContinuation();
     while (p && p->isRenderInline()) {
-        if (p->isInFlowPositioned()) {
+        if (p->isRelPositioned()) {
             RenderInline* renderInline = toRenderInline(p);
             offset += renderInline->offsetForInFlowPosition();
         }
         p = p->parent();
     }
     return offset;
 }
 
 bool RenderBoxModelObject::hasAutoHeightOrContainingBlockWithAutoHeight() const
 {
@@ skipping 87 matching lines @@
     Element* element = offsetParent();
     if (!element)
         return referencePoint;
 
     if (const RenderBoxModelObject* offsetParent = element->renderBoxModelObject()) {
         if (offsetParent->isBox() && !offsetParent->isBody())
             referencePoint.move(-toRenderBox(offsetParent)->borderLeft(), -toRenderBox(offsetParent)->borderTop());
         if (!isOutOfFlowPositioned() || flowThreadContainingBlock()) {
             if (isRelPositioned())
                 referencePoint.move(relativePositionOffset());
-            else if (isStickyPositioned())
-                referencePoint.move(stickyPositionOffset());
 
             RenderObject* current;
             for (current = parent(); current != offsetParent && current->parent(); current = current->parent()) {
                 // FIXME: What are we supposed to do inside SVG content?
                 if (!isOutOfFlowPositioned()) {
                     if (current->isBox() && !current->isTableRow())
                         referencePoint.moveBy(toRenderBox(current)->topLeftLocation());
                     referencePoint.move(current->parent()->columnOffset(referencePoint));
                 }
             }
 
             if (offsetParent->isBox() && offsetParent->isBody() && !offsetParent->isPositioned())
                 referencePoint.moveBy(toRenderBox(offsetParent)->topLeftLocation());
         }
     }
 
     return referencePoint;
 }
 
-void RenderBoxModelObject::computeStickyPositionConstraints(StickyPositionViewportConstraints& constraints, const FloatRect& constrainingRect) const
-{
-    RenderBlock* containingBlock = this->containingBlock();
-
-    LayoutRect containerContentRect = containingBlock->contentBoxRect();
-    LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
-
-    // 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.
-    LayoutBoxExtent minMargin(minimumValueForLength(style()->marginTop(), maxWidth),
-        minimumValueForLength(style()->marginRight(), maxWidth),
-        minimumValueForLength(style()->marginBottom(), maxWidth),
-        minimumValueForLength(style()->marginLeft(), maxWidth));
-
-    // Compute the container-relative area within which the sticky element is allowed to move.
-    containerContentRect.contract(minMargin);
-    // Map to the view to avoid including page scale factor.
-    constraints.setAbsoluteContainingBlockRect(containingBlock->localToContainerQuad(FloatRect(containerContentRect), view()).boundingBox());
-
-    LayoutRect stickyBoxRect = frameRectForStickyPositioning();
-    LayoutRect flippedStickyBoxRect = stickyBoxRect;
-    containingBlock->flipForWritingMode(flippedStickyBoxRect);
-    LayoutPoint stickyLocation = flippedStickyBoxRect.location();
-
-    // FIXME: sucks to call localToAbsolute again, but we can't just offset from the previously computed rect if there are transforms.
-    // Map to the view to avoid including page scale factor.
-    FloatRect absContainerFrame = containingBlock->localToContainerQuad(FloatRect(FloatPoint(), containingBlock->size()), view()).boundingBox();
-
-    if (containingBlock->hasOverflowClip()) {
-        IntSize scrollOffset = containingBlock->layer()->scrollableArea()->adjustedScrollOffset();
-        stickyLocation -= scrollOffset;
-    }
-
-    // We can't call localToAbsolute on |this| because that will recur. FIXME: For now, assume that |this| is not transformed.
-    FloatRect absoluteStickyBoxRect(absContainerFrame.location() + stickyLocation, flippedStickyBoxRect.size());
-    constraints.setAbsoluteStickyBoxRect(absoluteStickyBoxRect);
-
-    float horizontalOffsets = constraints.rightOffset() + constraints.leftOffset();
-    bool skipRight = false;
-    bool skipLeft = false;
-    if (!style()->left().isAuto() && !style()->right().isAuto()) {
-        if (horizontalOffsets > containerContentRect.width().toFloat()
-            || horizontalOffsets + containerContentRect.width().toFloat() > constrainingRect.width()) {
-            skipRight = style()->isLeftToRightDirection();
-            skipLeft = !skipRight;
-        }
-    }
-
-    if (!style()->left().isAuto() && !skipLeft) {
-        constraints.setLeftOffset(floatValueForLength(style()->left(), constrainingRect.width()));
-        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeLeft);
-    }
-
-    if (!style()->right().isAuto() && !skipRight) {
-        constraints.setRightOffset(floatValueForLength(style()->right(), constrainingRect.width()));
-        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeRight);
-    }
-
-    bool skipBottom = false;
-    // FIXME(ostap): 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
-    float verticalOffsets = constraints.topOffset() + constraints.bottomOffset();
-    if (!style()->top().isAuto() && !style()->bottom().isAuto()) {
-        if (verticalOffsets > containerContentRect.height().toFloat()
-            || verticalOffsets + containerContentRect.height().toFloat() > constrainingRect.height()) {
-            skipBottom = true;
-        }
-    }
-
-    if (!style()->top().isAuto()) {
-        constraints.setTopOffset(floatValueForLength(style()->top(), constrainingRect.height()));
-        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeTop);
-    }
-
-    if (!style()->bottom().isAuto() && !skipBottom) {
-        constraints.setBottomOffset(floatValueForLength(style()->bottom(), constrainingRect.height()));
-        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeBottom);
-    }
-}
-
-LayoutSize RenderBoxModelObject::stickyPositionOffset() const
-{
-    FloatRect constrainingRect;
-
-    ASSERT(hasLayer());
-    RenderLayer* enclosingClippingLayer = layer()->enclosingOverflowClipLayer(ExcludeSelf);
-    if (enclosingClippingLayer) {
-        RenderBox* enclosingClippingBox = toRenderBox(enclosingClippingLayer->renderer());
-        LayoutRect clipRect = enclosingClippingBox->overflowClipRect(LayoutPoint());
-        clipRect.move(enclosingClippingBox->paddingLeft(), enclosingClippingBox->paddingTop());
-        clipRect.contract(LayoutSize(enclosingClippingBox->paddingLeft() + enclosingClippingBox->paddingRight(),
-            enclosingClippingBox->paddingTop() + enclosingClippingBox->paddingBottom()));
-        constrainingRect = enclosingClippingBox->localToContainerQuad(FloatRect(clipRect), view()).boundingBox();
-    } else {
-        LayoutRect viewportRect = view()->frameView()->viewportConstrainedVisibleContentRect();
-        constrainingRect = viewportRect;
-    }
-
-    StickyPositionViewportConstraints constraints;
-    computeStickyPositionConstraints(constraints, constrainingRect);
-
-    // The sticky offset is physical, so we can just return the delta computed in absolute coords (though it may be wrong with transforms).
-    return LayoutSize(constraints.computeStickyOffset(constrainingRect));
-}
-
 LayoutSize RenderBoxModelObject::offsetForInFlowPosition() const
 {
-    if (isRelPositioned())
-        return relativePositionOffset();
-
-    if (isStickyPositioned())
-        return stickyPositionOffset();
-
-    return LayoutSize();
+    return isRelPositioned() ? relativePositionOffset() : LayoutSize();
 }
 
 LayoutUnit RenderBoxModelObject::offsetLeft() const
 {
     // Note that RenderInline and RenderBox override this to pass a different
     // startPoint to adjustedPositionRelativeToOffsetParent.
     return adjustedPositionRelativeToOffsetParent(LayoutPoint()).x();
 }
 
 LayoutUnit RenderBoxModelObject::offsetTop() const
@@ skipping 2433 matching lines @@
     ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
     for (RenderObject* child = startChild; child && child != endChild; ) {
         // Save our next sibling as moveChildTo will clear it.
         RenderObject* nextSibling = child->nextSibling();
         moveChildTo(toBoxModelObject, child, beforeChild, fullRemoveInsert);
         child = nextSibling;
     }
 }
 
 } // namespace WebCore