Add position: sticky as supported position value when CSSStickyPosition is enabled.

Source/core/layout/LayoutBox.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, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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 1228 matching lines @@
 {
     if (!maxDepthToTest)
         return false;
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->isBox())
             continue;
         LayoutBox* childBox = toLayoutBox(child);
         if (!isCandidateForOpaquenessTest(*childBox))
             continue;
         LayoutPoint childLocation = childBox->location();
-        if (childBox->isRelPositioned())
-            childLocation.move(childBox->relativePositionOffset());
+        if (childBox->isInFlowPositioned())
+            childLocation.move(childBox->offsetForInFlowPosition());
         LayoutRect childLocalRect = localRect;
         childLocalRect.moveBy(-childLocation);
         if (childLocalRect.y() < 0 || childLocalRect.x() < 0) {
             // If there is unobscured area above/left of a static positioned box then the rect is probably not covered.
             if (childBox->style()->position() == StaticPosition)
                 return false;
             continue;
         }
         if (childLocalRect.maxY() > childBox->size().height() || childLocalRect.maxX() > childBox->size().width())
             continue;
@@ skipping 369 matching lines @@
     }
 
     LayoutBoxModelObject::mapAbsoluteToLocalPoint(mode, transformState);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(o == container());
 
     LayoutSize offset;
-    if (isRelPositioned())
+    if (isInFlowPositioned())
         offset += offsetForInFlowPosition();
 
     if (!isInline() || isReplaced()) {
         offset += topLeftLocationOffset();
         if (o->isLayoutFlowThread()) {
             // So far the point has been in flow thread coordinates (i.e. as if everything in
             // the fragmentation context lived in one tall single column). Convert it to a
             // visual point now.
             LayoutPoint pointInContainer = point + offset;
             offset += o->columnOffset(pointInContainer);
             if (offsetDependsOnPoint)
                 *offsetDependsOnPoint = true;
         }
     }
 
     if (o->hasOverflowClip())
         offset -= toLayoutBox(o)->scrolledContentOffset();
 
-    if (style()->position() == AbsolutePosition && o->isRelPositioned() && o->isLayoutInline())
+    if (style()->position() == AbsolutePosition && o->isInFlowPositioned() && o->isLayoutInline())
         offset += toLayoutInline(o)->offsetForInFlowPositionedInline(*this);
 
     return offset;
 }
 
 InlineBox* LayoutBox::createInlineBox()
 {
     return new InlineBox(*this);
 }
 
@@ skipping 38 matching lines @@
     } else if (isReplaced()) {
         // FIXME: the call to roundedLayoutPoint() below is temporary and should be removed once
         // the transition to LayoutUnit-based types is complete (crbug.com/321237)
         setLocationAndUpdateOverflowControlsIfNeeded(box->topLeft());
         setInlineBoxWrapper(box);
     }
 }
 
 void LayoutBox::moveWithEdgeOfInlineContainerIfNecessary(bool isHorizontal)
 {
-    ASSERT(isOutOfFlowPositioned() && container()->isLayoutInline() && container()->isRelPositioned());
+    ASSERT(isOutOfFlowPositioned() && container()->isLayoutInline() && container()->isInFlowPositioned());
     // If this object is inside a relative positioned inline and its inline position is an explicit offset from the edge of its container
     // then it will need to move if its inline container has changed width. We do not track if the width has changed
     // but if we are here then we are laying out lines inside it, so it probably has - mark our object for layout so that it can
     // move to the new offset created by the new width.
     if (!normalChildNeedsLayout() && !style()->hasStaticInlinePosition(isHorizontal))
         setChildNeedsLayout(MarkOnlyThis);
 }
 
 void LayoutBox::deleteLineBoxWrapper()
 {
@@ skipping 85 matching lines @@
     topLeft.move(locationOffset());
 
     // We are now in our parent container's coordinate space.  Apply our transform to obtain a bounding box
     // in the parent's coordinate space that encloses us.
     if (hasLayer() && layer()->transform()) {
         rect = LayoutRect(layer()->transform()->mapRect(pixelSnappedIntRect(rect)));
         topLeft = rect.location();
         topLeft.move(locationOffset());
     }
 
-    if (position == AbsolutePosition && o->isRelPositioned() && o->isLayoutInline()) {
+    if (position == AbsolutePosition && o->isInFlowPositioned() && o->isLayoutInline()) {
         topLeft += toLayoutInline(o)->offsetForInFlowPositionedInline(*this);
     } else if (styleToUse.hasInFlowPosition() && layer()) {
         // Apply the relative position offset when invalidating a rectangle.  The layer
         // is translated, but the layout box isn't, so we need to do this to get the
         // right dirty rect.  Since this is called from LayoutObject::setStyle, the relative position
         // flag on the LayoutObject has been cleared, so use the one on the style().
         topLeft += layer()->offsetForInFlowPosition();
     }
 
     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
@@ skipping 901 matching lines @@
             return containingBlock->isHorizontalWritingMode() ? viewportRect.width() : viewportRect.height();
         }
     }
 
     if (hasOverrideContainingBlockLogicalWidth())
         return overrideContainingBlockContentLogicalWidth();
 
     if (containingBlock->isBox())
         return toLayoutBox(containingBlock)->clientLogicalWidth();
 
-    ASSERT(containingBlock->isLayoutInline() && containingBlock->isRelPositioned());
+    ASSERT(containingBlock->isLayoutInline() && containingBlock->isInFlowPositioned());
 
     const LayoutInline* flow = toLayoutInline(containingBlock);
     InlineFlowBox* first = flow->firstLineBox();
     InlineFlowBox* last = flow->lastLineBox();
 
     // If the containing block is empty, return a width of 0.
     if (!first || !last)
         return LayoutUnit();
 
     LayoutUnit fromLeft;
@@ skipping 25 matching lines @@
 
     if (hasOverrideContainingBlockLogicalHeight())
         return overrideContainingBlockContentLogicalHeight();
 
     if (containingBlock->isBox()) {
         const LayoutBlock* cb = containingBlock->isLayoutBlock() ?
             toLayoutBlock(containingBlock) : containingBlock->containingBlock();
         return cb->clientLogicalHeight();
     }
 
-    ASSERT(containingBlock->isLayoutInline() && containingBlock->isRelPositioned());
+    ASSERT(containingBlock->isLayoutInline() && containingBlock->isInFlowPositioned());
 
     const LayoutInline* flow = toLayoutInline(containingBlock);
     InlineFlowBox* first = flow->firstLineBox();
     InlineFlowBox* last = flow->lastLineBox();
 
     // If the containing block is empty, return a height of 0.
     if (!first || !last)
         return LayoutUnit();
 
     LayoutUnit heightResult;
@@ skipping 10 matching lines @@
 {
     if (!logicalLeft.isAuto() || !logicalRight.isAuto())
         return;
 
     // FIXME: The static distance computation has not been patched for mixed writing modes yet.
     if (child->parent()->style()->direction() == LTR) {
         LayoutUnit staticPosition = child->layer()->staticInlinePosition() - containerBlock->borderLogicalLeft();
         for (LayoutObject* curr = child->parent(); curr && curr != containerBlock; curr = curr->container()) {
             if (curr->isBox()) {
                 staticPosition += toLayoutBox(curr)->logicalLeft();
-                if (toLayoutBox(curr)->isRelPositioned())
-                    staticPosition += toLayoutBox(curr)->relativePositionOffset().width();
+                if (toLayoutBox(curr)->isInFlowPositioned())
+                    staticPosition += toLayoutBox(curr)->offsetForInFlowPosition().width();
             } else if (curr->isInline()) {
-                if (curr->isRelPositioned()) {
+                if (curr->isInFlowPositioned()) {
                     if (!curr->style()->logicalLeft().isAuto())
                         staticPosition += valueForLength(curr->style()->logicalLeft(), curr->containingBlock()->availableWidth());
                     else
                         staticPosition -= valueForLength(curr->style()->logicalRight(), curr->containingBlock()->availableWidth());
                 }
             }
         }
         logicalLeft.setValue(Fixed, staticPosition);
     } else {
         LayoutBox* enclosingBox = child->parent()->enclosingBox();
         LayoutUnit staticPosition = child->layer()->staticInlinePosition() + containerLogicalWidth + containerBlock->borderLogicalLeft();
         for (LayoutObject* curr = child->parent(); curr; curr = curr->container()) {
             if (curr->isBox()) {
                 if (curr != containerBlock) {
                     staticPosition -= toLayoutBox(curr)->logicalLeft();
-                    if (toLayoutBox(curr)->isRelPositioned())
-                        staticPosition -= toLayoutBox(curr)->relativePositionOffset().width();
+                    if (toLayoutBox(curr)->isInFlowPositioned())
+                        staticPosition -= toLayoutBox(curr)->offsetForInFlowPosition().width();
                 }
                 if (curr == enclosingBox)
                     staticPosition -= enclosingBox->logicalWidth();
             } else if (curr->isInline()) {
-                if (curr->isRelPositioned()) {
+                if (curr->isInFlowPositioned()) {
                     if (!curr->style()->logicalLeft().isAuto())
                         staticPosition -= valueForLength(curr->style()->logicalLeft(), curr->containingBlock()->availableWidth());
                     else
                         staticPosition += valueForLength(curr->style()->logicalRight(), curr->containingBlock()->availableWidth());
                 }
             }
             if (curr == containerBlock)
                 break;
         }
         logicalRight.setValue(Fixed, staticPosition);
@@ skipping 1560 matching lines @@
     LayoutRect rect = borderBoxRect();
     // We want to include the margin, but only when it adds height. Quirky margins don't contribute height
     // nor do the margins of self-collapsing blocks.
     if (!styleRef().hasMarginAfterQuirk() && !isSelfCollapsingBlock())
         rect.expand(isHorizontalWritingMode() ? LayoutSize(LayoutUnit(), marginAfter()) : LayoutSize(marginAfter(), LayoutUnit()));
 
     if (!hasOverflowClip())
         rect.unite(layoutOverflowRect());
 
     bool hasTransform = hasLayer() && layer()->transform();
-    if (isRelPositioned() || hasTransform) {
+    if (isInFlowPositioned() || hasTransform) {
         // If we are relatively positioned or if we have a transform, then we have to convert
         // this rectangle into physical coordinates, apply relative positioning and transforms
         // to it, and then convert it back.
         flipForWritingMode(rect);
 
         if (hasTransform)
             rect = layer()->currentTransform().mapRect(rect);
 
-        if (isRelPositioned())
+        if (isInFlowPositioned())
             rect.move(offsetForInFlowPosition());
 
         // Now we need to flip back.
         flipForWritingMode(rect);
     }
 
     // If the writing modes of the child and parent match, then we don't have to
     // do anything fancy. Just return the result.
     if (parentStyle.writingMode() == style()->writingMode())
         return rect;
@@ skipping 322 matching lines @@
 bool LayoutBox::canRenderBorderImage() const
 {
     if (!style()->hasBorderDecoration())
         return false;
 
     StyleImage* borderImage = style()->borderImage().image();
     return borderImage && borderImage->canRender(*this, style()->effectiveZoom()) && borderImage->isLoaded();
 }
 
 } // namespace blink