Do not promote position sticky or fixed elements unless they move with scroll.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/compositing/CompositingReasonFinder.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/dom/Document.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
@@ skipping 19 matching lines @@
     m_compositingTriggers |= OverflowScrollTrigger;
     m_compositingTriggers |= ViewportConstrainedPositionedTrigger;
   }
 }
 
 bool CompositingReasonFinder::isMainFrame() const {
   return m_layoutView.document().isInMainFrame();
 }
 
 CompositingReasons CompositingReasonFinder::directReasons(
-    const PaintLayer* layer) const {
+    const PaintLayer* layer,
+    bool ignoreLCDText) const {
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return CompositingReasonNone;
 
   DCHECK_EQ(potentialCompositingReasonsFromStyle(layer->layoutObject()),
             layer->potentialCompositingReasonsFromStyle());
   CompositingReasons styleDeterminedDirectCompositingReasons =
       layer->potentialCompositingReasonsFromStyle() &
       CompositingReasonComboAllDirectStyleDeterminedReasons;
 
   return styleDeterminedDirectCompositingReasons |
-         nonStyleDeterminedDirectReasons(layer);
+         nonStyleDeterminedDirectReasons(layer, ignoreLCDText);
 }
 
 // This information doesn't appear to be incorporated into CompositingReasons.
 bool CompositingReasonFinder::requiresCompositingForScrollableFrame() const {
   // Need this done first to determine overflow.
   DCHECK(!m_layoutView.needsLayout());
   if (isMainFrame())
     return false;
 
   if (!(m_compositingTriggers & ScrollableInnerFrameTrigger))
@@ skipping 72 matching lines @@
 bool CompositingReasonFinder::requiresCompositingForTransform(
     const LayoutObject& layoutObject) {
   // Note that we ask the layoutObject if it has a transform, because the style
   // may have transforms, but the layoutObject may be an inline that doesn't
   // support them.
   return layoutObject.hasTransformRelatedProperty() &&
          layoutObject.styleRef().has3DTransform();
 }
 
 CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(
-    const PaintLayer* layer) const {
+    const PaintLayer* layer,
+    bool ignoreLCDText) const {
   CompositingReasons directReasons = CompositingReasonNone;
   LayoutObject& layoutObject = layer->layoutObject();
 
   if (m_compositingTriggers & OverflowScrollTrigger && layer->clipParent())
     directReasons |= CompositingReasonOutOfFlowClipping;
 
   if (layer->needsCompositedScrolling())
     directReasons |= CompositingReasonOverflowScrollingTouch;
 
   // Composite |layer| if it is inside of an ancestor scrolling layer, but that
   // scrolling layer is not on the stacking context ancestor chain of |layer|.
   // See the definition of the scrollParent property in Layer for more detail.
   if (const PaintLayer* scrollingAncestor = layer->ancestorScrollingLayer()) {
     if (scrollingAncestor->needsCompositedScrolling() && layer->scrollParent())
       directReasons |= CompositingReasonOverflowScrollingParent;
   }
 
-  // TODO(flackr): Rename functions and variables to include sticky position
-  // (i.e. ScrollDependentPosition rather than PositionFixed).
-  if (requiresCompositingForScrollDependentPosition(layer))
+  if (requiresCompositingForScrollDependentPosition(layer, ignoreLCDText))
     directReasons |= CompositingReasonScrollDependentPosition;
 
   directReasons |= layoutObject.additionalCompositingReasons();
 
   DCHECK(!(directReasons & CompositingReasonComboAllStyleDeterminedReasons));
   return directReasons;
 }
 
 bool CompositingReasonFinder::requiresCompositingForAnimation(
     const ComputedStyle& style) {
@@ skipping 32 matching lines @@
 }
 
 bool CompositingReasonFinder::requiresCompositingForTransformAnimation(
     const ComputedStyle& style) {
   return style.subtreeWillChangeContents()
              ? style.isRunningTransformAnimationOnCompositor()
              : style.hasCurrentTransformAnimation();
 }
 
 bool CompositingReasonFinder::requiresCompositingForScrollDependentPosition(
-    const PaintLayer* layer) const {
-  if (layer->layoutObject().style()->position() != EPosition::kFixed &&
-      layer->layoutObject().style()->position() != EPosition::kSticky)
+    const PaintLayer* layer,
+    bool ignoreLCDText) const {
+  if (!layer->layoutObject().style()->hasViewportConstrainedPosition() &&
+      !layer->layoutObject().style()->hasStickyConstrainedPosition())
     return false;
 
-  if (!(m_compositingTriggers & ViewportConstrainedPositionedTrigger) &&
+  if (!(ignoreLCDText ||
+        (m_compositingTriggers & ViewportConstrainedPositionedTrigger)) &&
       (!RuntimeEnabledFeatures::compositeOpaqueFixedPositionEnabled() ||
        !layer->backgroundIsKnownToBeOpaqueInRect(
            LayoutRect(layer->boundingBoxForCompositing())) ||
        layer->compositesWithTransform() || layer->compositesWithOpacity())) {
     return false;
   }
   // Don't promote fixed position elements that are descendants of a non-view
   // container, e.g. transformed elements.  They will stay fixed wrt the
   // container rather than the enclosing frame.
-  if (layer->sticksToViewport())
-    return m_layoutView.frameView()->isScrollable();
-
-  if (layer->layoutObject().style()->position() != EPosition::kSticky)
-    return false;
+  EPosition position = layer->layoutObject().style()->position();
+  if (position == EPosition::kFixed)
+    return layer->fixedToViewport() && m_layoutView.frameView()->isScrollable();
+  DCHECK(position == EPosition::kSticky);
 
   // Don't promote nested sticky elements; the compositor can't handle them.
   // TODO(smcgruer): Add cc nested sticky support (http://crbug.com/672710)
   PaintLayerScrollableArea* scrollableArea =
       layer->ancestorOverflowLayer()->getScrollableArea();
   DCHECK(scrollableArea->stickyConstraintsMap().contains(
       const_cast<PaintLayer*>(layer)));
+  if (scrollableArea->stickyConstraintsMap()
+          .at(const_cast<PaintLayer*>(layer))
+          .hasAncestorStickyElement())
+    return false;
 
-  return layer->ancestorOverflowLayer()->scrollsOverflow() &&
-         !scrollableArea->stickyConstraintsMap()
-              .at(const_cast<PaintLayer*>(layer))
-              .hasAncestorStickyElement();
+  // Don't promote sticky position elements that cannot move with scrolls.
+  if (!layer->sticksToScroller())
+    return false;
+  if (layer->ancestorOverflowLayer()->isRootLayer())
+    return m_layoutView.frameView()->isScrollable();
+  return layer->ancestorOverflowLayer()->scrollsOverflow();
 }
 
 }  // namespace blink