Adapt and reland old position sticky implementation

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

Index: third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp b/third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp
index 2f409916a65e75e0d963871d065a6d4d542076e1..f9d9f7c7514b8422968e8ca064ad8925dd9386fa 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp
@@ -38,7 +38,7 @@ LayoutGeometryMap::LayoutGeometryMap(MapCoordinatesFlags flags)
     : m_insertionPosition(kNotFound)
     , m_nonUniformStepsCount(0)
     , m_transformedStepsCount(0)
-    , m_fixedStepsCount(0)
+    , m_viewportConstrainedStepsCount(0)
     , m_mapCoordinatesFlags(flags)
 {
 }
@@ -64,7 +64,7 @@ void LayoutGeometryMap::mapToContainer(TransformState& transformState, const Lay
     for (int i = m_mapping.size() - 1; i >= 0; --i) {
         const LayoutGeometryMapStep& currentStep = m_mapping[i];
 
-        // If container is the root LayoutView (step 0) we want to apply its fixed position offset.
+        // If container is the root LayoutView (step 0) we want to apply its viewport constrained position offset.

[chrishtr, 2015/11/04 01:55:18]

Sticky elements are not quite viewport constrained, they are containing scroller
constrained. Doesn't this mean that the changes here are not correct in those
cases?

[flackr, 2015/11/25 20:47:52]

Yes, I rethought this and it seems we can get by with simply passing the sticky
offset. This field can be re-used if and when other cases occur.

         if (i > 0 && currentStep.m_layoutObject == container) {
 #if ENABLE(ASSERT)
             foundContainer = true;
@@ -72,12 +72,13 @@ void LayoutGeometryMap::mapToContainer(TransformState& transformState, const Lay
             break;
         }
 
-        // If this box has a transform, it acts as a fixed position container
-        // for fixed descendants, which prevents the propagation of 'fixed'
-        // unless the layer itself is also fixed position.
-        if (i && currentStep.m_hasTransform && !currentStep.m_isFixedPosition)
+        // If this box has a transform, it acts as a viewport constrained position container
+        // for viewport constrained descendants, which prevents the propagation of viewport constrained
+        // unless the layer itself is also a viewport constrained position.
+        // TODO(flackr): Verify how fixed and sticky elements should interact with each other.

[chrishtr, 2015/11/04 01:55:18]

Meaning: what should happen with a sticky element below a fixed one?

[flackr, 2015/11/25 20:47:52]

Correct. FWIW I have now tested both of these and they have reasonable behavior
(what you'd expect to happen) under Firefox and this patch matches Firefox's
behavior so I've removed the comment.

+        if (i && currentStep.m_hasTransform && !currentStep.m_isViewportConstrained)
             inFixed = false;
-        else if (currentStep.m_isFixedPosition)
+        else if (currentStep.m_isViewportConstrained)
             inFixed = true;
 
         ASSERT(!i == isTopmostLayoutView(currentStep.m_layoutObject));
@@ -94,9 +95,9 @@ void LayoutGeometryMap::mapToContainer(TransformState& transformState, const Lay
                 transformState.move(currentStep.m_offset.width(), currentStep.m_offset.height(), accumulate);
         }
 
-        if (inFixed && !currentStep.m_offsetForFixedPosition.isZero()) {
+        if (inFixed && !currentStep.m_offsetForViewportConstrained.isZero()) {
             ASSERT(currentStep.m_layoutObject->isLayoutView());
-            transformState.move(currentStep.m_offsetForFixedPosition);
+            transformState.move(currentStep.m_offsetForViewportConstrained);
         }
     }
 
@@ -108,7 +109,7 @@ FloatPoint LayoutGeometryMap::mapToContainer(const FloatPoint& p, const LayoutBo
 {
     FloatPoint result;
 
-    if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_layoutObject))) {
+    if (!hasViewportConstrainedStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_layoutObject))) {
         result = p + m_accumulatedOffset;
     } else {
         TransformState transformState(TransformState::ApplyTransformDirection, p);
@@ -156,7 +157,7 @@ FloatQuad LayoutGeometryMap::mapToContainer(const FloatRect& rect, const LayoutB
 {
     FloatQuad result;
 
-    if (!hasFixedPositionStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_layoutObject))) {
+    if (!hasViewportConstrainedStep() && !hasTransformStep() && !hasNonUniformStep() && (!container || (m_mapping.size() && container == m_mapping[0].m_layoutObject))) {
         result = rect;
         result.move(m_accumulatedOffset);
     } else {
@@ -241,40 +242,40 @@ void LayoutGeometryMap::pushMappingsToAncestor(const PaintLayer* layer, const Pa
 
         TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
         bool accumulatingTransform = layer->layoutObject()->style()->preserves3D() || ancestorLayer->layoutObject()->style()->preserves3D();
-        push(layoutObject, toLayoutSize(layerOffset), accumulatingTransform, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
+        push(layoutObject, toLayoutSize(layerOffset), accumulatingTransform, /*isNonUniform*/ false, /*isViewportConstrained*/ false, /*hasTransform*/ false);
         return;
     }
     const LayoutBoxModelObject* ancestorLayoutObject = ancestorLayer ? ancestorLayer->layoutObject() : 0;
     pushMappingsToAncestor(layoutObject, ancestorLayoutObject);
 }
 
-void LayoutGeometryMap::push(const LayoutObject* layoutObject, const LayoutSize& offsetFromContainer, bool accumulatingTransform, bool isNonUniform, bool isFixedPosition, bool hasTransform, LayoutSize offsetForFixedPosition)
+void LayoutGeometryMap::push(const LayoutObject* layoutObject, const LayoutSize& offsetFromContainer, bool accumulatingTransform, bool isNonUniform, bool isViewportConstrained, bool hasTransform, LayoutSize offsetForViewportConstrained)
 {
 //    fprintf(stderr, "LayoutGeometryMap::push %p %d,%d isNonUniform=%d\n", layoutObject, offsetFromContainer.width().toInt(), offsetFromContainer.height().toInt(), isNonUniform);
 
     ASSERT(m_insertionPosition != kNotFound);
     ASSERT(!layoutObject->isLayoutView() || !m_insertionPosition || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
-    ASSERT(offsetForFixedPosition.isZero() || layoutObject->isLayoutView());
+    ASSERT(offsetForViewportConstrained.isZero() || layoutObject->isLayoutView());
 
-    m_mapping.insert(m_insertionPosition, LayoutGeometryMapStep(layoutObject, accumulatingTransform, isNonUniform, isFixedPosition, hasTransform));
+    m_mapping.insert(m_insertionPosition, LayoutGeometryMapStep(layoutObject, accumulatingTransform, isNonUniform, isViewportConstrained, hasTransform));
 
     LayoutGeometryMapStep& step = m_mapping[m_insertionPosition];
     step.m_offset = offsetFromContainer;
-    step.m_offsetForFixedPosition = offsetForFixedPosition;
+    step.m_offsetForViewportConstrained = offsetForViewportConstrained;
 
     stepInserted(step);
 }
 
-void LayoutGeometryMap::push(const LayoutObject* layoutObject, const TransformationMatrix& t, bool accumulatingTransform, bool isNonUniform, bool isFixedPosition, bool hasTransform, LayoutSize offsetForFixedPosition)
+void LayoutGeometryMap::push(const LayoutObject* layoutObject, const TransformationMatrix& t, bool accumulatingTransform, bool isNonUniform, bool isViewportConstrained, bool hasTransform, LayoutSize offsetForViewportConstrained)
 {
     ASSERT(m_insertionPosition != kNotFound);
     ASSERT(!layoutObject->isLayoutView() || !m_insertionPosition || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
-    ASSERT(offsetForFixedPosition.isZero() || layoutObject->isLayoutView());
+    ASSERT(offsetForViewportConstrained.isZero() || layoutObject->isLayoutView());
 
-    m_mapping.insert(m_insertionPosition, LayoutGeometryMapStep(layoutObject, accumulatingTransform, isNonUniform, isFixedPosition, hasTransform));
+    m_mapping.insert(m_insertionPosition, LayoutGeometryMapStep(layoutObject, accumulatingTransform, isNonUniform, isViewportConstrained, hasTransform));
 
     LayoutGeometryMapStep& step = m_mapping[m_insertionPosition];
-    step.m_offsetForFixedPosition = offsetForFixedPosition;
+    step.m_offsetForViewportConstrained = offsetForViewportConstrained;
 
     if (!t.isIntegerTranslation())
         step.m_transform = adoptPtr(new TransformationMatrix(t));
@@ -310,8 +311,8 @@ void LayoutGeometryMap::stepInserted(const LayoutGeometryMapStep& step)
     if (step.m_transform)
         ++m_transformedStepsCount;
 
-    if (step.m_isFixedPosition)
-        ++m_fixedStepsCount;
+    if (step.m_isViewportConstrained)
+        ++m_viewportConstrainedStepsCount;
 }
 
 void LayoutGeometryMap::stepRemoved(const LayoutGeometryMapStep& step)
@@ -328,9 +329,9 @@ void LayoutGeometryMap::stepRemoved(const LayoutGeometryMapStep& step)
         --m_transformedStepsCount;
     }
 
-    if (step.m_isFixedPosition) {
-        ASSERT(m_fixedStepsCount);
-        --m_fixedStepsCount;
+    if (step.m_isViewportConstrained) {
+        ASSERT(m_viewportConstrainedStepsCount);
+        --m_viewportConstrainedStepsCount;
     }
 }