Implement position: sticky updates on compositor

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 32 matching lines @@
 #include "core/layout/LayoutHTMLCanvas.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutVideo.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
+#include "core/page/scrolling/StickyPositionScrollingConstraints.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayerPainter.h"
 #include "core/paint/PaintLayerStackingNodeIterator.h"
 #include "core/paint/PaintTiming.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "core/paint/TransformRecorder.h"
 #include "core/plugins/PluginView.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/ClipDisplayItem.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/PaintController.h"
 #include "platform/graphics/paint/SkPictureBuilder.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
+#include "public/platform/WebLayerStickyPositionConstraint.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 #include <memory>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static IntRect clipBox(LayoutBox* layoutObject);
 
@@ skipping 140 matching lines @@
 }
 
 void CompositedLayerMapping::createPrimaryGraphicsLayer()
 {
     m_graphicsLayer = createGraphicsLayer(m_owningLayer.getCompositingReasons(), m_owningLayer.getSquashingDisallowedReasons());
 
     updateOpacity(layoutObject()->styleRef());
     updateTransform(layoutObject()->styleRef());
     updateFilters(layoutObject()->styleRef());
     updateBackdropFilters(layoutObject()->styleRef());
+    updateStickyConstraints(layoutObject()->styleRef());
     updateLayerBlendMode(layoutObject()->styleRef());
     updateIsRootForIsolatedGroup();
 }
 
 void CompositedLayerMapping::destroyGraphicsLayers()
 {
     if (m_graphicsLayer)
         m_graphicsLayer->removeFromParent();
 
     m_ancestorClippingLayer = nullptr;
@@ skipping 30 matching lines @@
 void CompositedLayerMapping::updateFilters(const ComputedStyle& style)
 {
     m_graphicsLayer->setFilters(owningLayer().computeFilterOperations(style));
 }
 
 void CompositedLayerMapping::updateBackdropFilters(const ComputedStyle& style)
 {
     m_graphicsLayer->setBackdropFilters(owningLayer().computeBackdropFilterOperations(style));
 }
 
+void CompositedLayerMapping::updateStickyConstraints(const ComputedStyle& style)
+{
+    bool sticky = style.position() == EPosition::StickyPosition;
+    const PaintLayer* ancestorOverflowLayer = m_owningLayer.ancestorOverflowLayer();
+    // TODO(flackr): Do we still need this?
+    if (sticky) {
+        if (!ancestorOverflowLayer->isRootLayer()) {
+            sticky = ancestorOverflowLayer->needsCompositedScrolling();
+        } else {
+            sticky = layoutObject()->view()->frameView()->isScrollable();
+        }
+    }
+
+    WebLayerStickyPositionConstraint webConstraint;
+    if (sticky) {
+        const StickyPositionScrollingConstraints& constraints = ancestorOverflowLayer->getScrollableArea()->stickyConstraintsMap().get(&m_owningLayer);
+        webConstraint.isSticky = true;
+        webConstraint.isAnchoredLeft = constraints.anchorEdges() & StickyPositionScrollingConstraints::AnchorEdgeLeft;
+        webConstraint.isAnchoredRight = constraints.anchorEdges() & StickyPositionScrollingConstraints::AnchorEdgeRight;
+        webConstraint.isAnchoredTop = constraints.anchorEdges() & StickyPositionScrollingConstraints::AnchorEdgeTop;
+        webConstraint.isAnchoredBottom = constraints.anchorEdges() & StickyPositionScrollingConstraints::AnchorEdgeBottom;
+        webConstraint.leftOffset = constraints.leftOffset();
+        webConstraint.rightOffset = constraints.rightOffset();
+        webConstraint.topOffset = constraints.topOffset();
+        webConstraint.bottomOffset = constraints.bottomOffset();
+        webConstraint.absoluteStickyBoxRect = enclosingIntRect(constraints.scrollContainerRelativeStickyBoxRect());
+        webConstraint.absoluteContainingBlockRect = enclosingIntRect(constraints.scrollContainerRelativeContainingBlockRect());
+    }
+
+    m_graphicsLayer->setStickyPositionConstraint(webConstraint);
+}
+
 void CompositedLayerMapping::updateLayerBlendMode(const ComputedStyle& style)
 {
     setBlendMode(style.blendMode());
 }
 
 void CompositedLayerMapping::updateIsRootForIsolatedGroup()
 {
     bool isolate = m_owningLayer.shouldIsolateCompositedDescendants();
 
     // non stacking context layers should never isolate
@@ skipping 434 matching lines @@
     // Set opacity, if it is not animating.
     if (!layoutObject()->style()->isRunningOpacityAnimationOnCompositor())
         updateOpacity(layoutObject()->styleRef());
 
     if (!layoutObject()->style()->isRunningFilterAnimationOnCompositor())
         updateFilters(layoutObject()->styleRef());
 
     if (!layoutObject()->style()->isRunningBackdropFilterAnimationOnCompositor())
         updateBackdropFilters(layoutObject()->styleRef());
 
+    updateStickyConstraints(layoutObject()->styleRef());
+
     // We compute everything relative to the enclosing compositing layer.
     IntRect ancestorCompositingBounds;
     if (compositingContainer) {
         ASSERT(compositingContainer->hasCompositedLayerMapping());
         ancestorCompositingBounds = compositingContainer->compositedLayerMapping()->pixelSnappedCompositedBounds();
     }
 
     IntRect localCompositingBounds;
     IntRect relativeCompositingBounds;
     LayoutPoint offsetFromCompositedAncestor;
@@ skipping 1956 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink