Make composited scrolling codepaths co-operate.

Source/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 113 matching lines @@
 RenderLayer::RenderLayer(RenderLayerModelObject* renderer)
     : m_inResizeMode(false)
     , m_normalFlowListDirty(true)
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_hasOutOfFlowPositionedDescendant(false)
     , m_hasOutOfFlowPositionedDescendantDirty(true)
     , m_hasUnclippedDescendant(false)
     , m_isUnclippedDescendant(false)
     , m_needsCompositedScrolling(false)
-    , m_needsCompositedScrollingHasBeenRecorded(false)
+    , m_needsToBeStackingContainerHasBeenRecorded(false)
     , m_willUseCompositedScrollingHasBeenRecorded(false)
     , m_isScrollableAreaHasBeenRecorded(false)
+    , m_needsToBeStackingContainer(false)
     , m_canBePromotedToStackingContainer(false)
     , m_canBePromotedToStackingContainerDirty(true)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_paintingInsideReflection(false)
     , m_inOverflowRelayout(false)
     , m_repaintStatus(NeedsNormalRepaint)
     , m_visibleContentStatusDirty(true)
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
@@ skipping 323 matching lines @@
         }
     }
 }
 
 bool RenderLayer::acceleratedCompositingForOverflowScrollEnabled() const
 {
     const Settings* settings = renderer()->document().settings();
     return settings && settings->acceleratedCompositingForOverflowScrollEnabled();
 }
 
+bool RenderLayer::useCompositorDrivenAcceleratedScrolling() const

[Ian Vollick, 2013/09/06 02:01:05]

It looks like there's some repeated logic here in hasScrollParent. Perhaps we
could ditch this function and add the m_canBePromoted check there, too?

[hartmanng, 2013/09/06 20:18:36]

Yeah, I guess we can... I thought we needed it from RLC, but apparently not
anymore.

+{
+    if (!compositorDrivenAcceleratedScrollingEnabled())
+        return false;
+
+    const RenderLayer* scrollingLayer = ancestorScrollingLayer();
+    if (!scrollingLayer || scrollingLayer->isStackingContainer())
+        return false;
+
+    if (scrollingLayer->m_canBePromotedToStackingContainerDirty) {
+        // We don't know if it's safe to promote to stacking container, and
+        // aren't in a position to find out, so we have to assume the worst.
+        return true;
+    }
+
+    return !scrollingLayer->needsToBeStackingContainer();
+}
+
 // FIXME: This is a temporary flag and should be removed once accelerated
 // overflow scroll is ready (crbug.com/254111).
 bool RenderLayer::compositorDrivenAcceleratedScrollingEnabled() const
 {
     if (!acceleratedCompositingForOverflowScrollEnabled())
         return false;
 
     const Settings* settings = renderer()->document().settings();
     return settings && settings->isCompositorDrivenAcceleratedScrollingEnabled();
 }
@@ skipping 1541 matching lines @@
 {
     RenderBox* box = renderBox();
 
     // Scroll form controls on the main thread so they exhibit correct touch scroll event bubbling
     if (box && (box->isIntristicallyScrollable(VerticalScrollbar) || box->isIntristicallyScrollable(HorizontalScrollbar)))
         return false;
 
     return isComposited() && backing()->scrollingLayer();
 }
 
-bool RenderLayer::needsCompositedScrolling() const
-{
-    if (!compositorDrivenAcceleratedScrollingEnabled())
-        return needsToBeStackingContainer();
-    if (FrameView* frameView = renderer()->view()->frameView())
-        return frameView->containsScrollableArea(scrollableArea());
-    return false;
-}
-
-bool RenderLayer::needsToBeStackingContainer() const
+bool RenderLayer::adjustForForceCompositedScrollingMode(bool value) const
 {
     switch (m_forceNeedsCompositedScrolling) {
     case DoNotForceCompositedScrolling:
-        return m_needsCompositedScrolling;
+        return value;
     case CompositedScrollingAlwaysOn:
         return true;
     case CompositedScrollingAlwaysOff:
         return false;
     }
 
     ASSERT_NOT_REACHED();
-    return m_needsCompositedScrolling;
+    return value;
+}
+
+bool RenderLayer::needsCompositedScrolling() const
+{
+    return adjustForForceCompositedScrollingMode(m_needsCompositedScrolling);
+}
+
+bool RenderLayer::needsToBeStackingContainer() const
+{
+    return adjustForForceCompositedScrollingMode(m_needsToBeStackingContainer);
 }
 
 bool RenderLayer::hasScrollParent() const
 {
-    if (!compositorDrivenAcceleratedScrollingEnabled())
+    if (!useCompositorDrivenAcceleratedScrolling())
         return false;
 
     // A layer scrolls with its containing block. So to find the overflow scrolling layer
     // that we scroll with respect to, we must ascend the layer tree until we reach the
     // first overflow scrolling div at or above our containing block. I will refer to this
     // layer as our 'scrolling ancestor'.
     //
     // Now, if we reside in a normal flow list, then we will naturally scroll with our scrolling
     // ancestor, and we need not be composited. If, on the other hand, we reside in a z-order
     // list, and on our walk upwards to our scrolling ancestor we find no layer that is a stacking
     // context, then we know that in the stacking tree, we will not be in the subtree rooted at
     // our scrolling ancestor, and we will therefore not scroll with it. In this case, we must
     // be a composited layer since the compositor will need to take special measures to ensure
     // that we scroll with our scrolling ancestor and it cannot do this if we do not promote.
     RenderLayer* scrollParent = ancestorScrollingLayer();
 
     if (!scrollParent || scrollParent->isStackingContext())

[Ian Vollick, 2013/09/06 02:01:05]

Could this be changed to (scrollParent->needsToBeStackingContainer() &&
!scrollParent->m_canBePromotedToStackingContainerDirty) ?

[hartmanng, 2013/09/06 20:18:36]

That would exclude stacking contexts, are you sure we want to do that?

Also I realize that isStackingContainer() already takes
needsToBeStackingContainer() into account. I think the logic from
useCompositorDriven...() originally relied on canBeStackingContainer() (not
needsToBeStackingContainer()), which is why we needed to check
m_canBePromotedToStackingContainerDirty.

As far as I can tell, just checking scrollParent->isStackingContainer() is
sufficient here.

         return false;
 
     // If we hit a stacking context on our way up to the ancestor scrolling layer, it will already
     // be composited due to an overflow scrolling parent, so we don't need to.
     for (RenderLayer* ancestor = parent(); ancestor && ancestor != scrollParent; ancestor = ancestor->parent()) {
         if (ancestor->isStackingContext())

[Ian Vollick, 2013/09/06 02:01:05]

Should this be ancestor->stackingContainer()?

[hartmanng, 2013/09/06 20:18:36]

yeah, I think so. Done.

             return false;
     }
 
     return true;
 }
 
 void RenderLayer::updateNeedsCompositedScrolling()
 {
     TRACE_EVENT0("comp-scroll", "RenderLayer::updateNeedsCompositedScrolling");
 
     updateCanBeStackingContainer();
     updateDescendantDependentFlags();
 
     ASSERT(renderer()->view()->frameView() && renderer()->view()->frameView()->containsScrollableArea(scrollableArea()));
-    bool needsCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()
+    const bool needsToBeStackingContainer = acceleratedCompositingForOverflowScrollEnabled()
         && canBeStackingContainer()
         && !hasUnclippedDescendant();
 
+    const bool needsToBeStackingContainerDidChange = setNeedsToBeStackingContainer(needsToBeStackingContainer);
+
+    const bool needsCompositedScrolling = needsToBeStackingContainer
+        || compositorDrivenAcceleratedScrollingEnabled();
+
     // We gather a boolean value for use with Google UMA histograms to
     // quantify the actual effects of a set of patches attempting to
     // relax composited scrolling requirements, thereby increasing the
     // number of composited overflow divs.
     if (acceleratedCompositingForOverflowScrollEnabled())
         HistogramSupport::histogramEnumeration("Renderer.NeedsCompositedScrolling", needsCompositedScrolling, 2);
 
-    setNeedsCompositedScrolling(needsCompositedScrolling);
+    const bool needsCompositedScrollingDidChange = setNeedsCompositedScrolling(needsCompositedScrolling);
+
+    if (needsToBeStackingContainerDidChange || needsCompositedScrollingDidChange) {
+        // Note, the z-order lists may need to be rebuilt, but our code guarantees
+        // that we have not affected stacking, so we will not dirty
+        // m_canBePromotedToStackingContainer for either us or our stacking context
+        // or container.
+        didUpdateNeedsCompositedScrolling();
+    }
 }
 
 enum CompositedScrollingHistogramBuckets {
     IsScrollableAreaBucket = 0,
     NeedsToBeStackingContainerBucket = 1,
     WillUseCompositedScrollingBucket = 2,
     CompositedScrollingHistogramMax = 3
 };
 
-void RenderLayer::setNeedsCompositedScrolling(bool needsCompositedScrolling)
+bool RenderLayer::setNeedsCompositedScrolling(bool needsCompositedScrolling)
 {
     if (m_needsCompositedScrolling == needsCompositedScrolling)
-        return;
-
-    // Count the total number of RenderLayers which need to be stacking
-    // containers some point. This should be recorded at most once per
-    // RenderLayer, so we check m_needsCompositedScrollingHasBeenRecorded.
-    if (acceleratedCompositingForOverflowScrollEnabled() && !m_needsCompositedScrollingHasBeenRecorded) {
-        HistogramSupport::histogramEnumeration("Renderer.CompositedScrolling", NeedsToBeStackingContainerBucket, CompositedScrollingHistogramMax);
-        m_needsCompositedScrollingHasBeenRecorded = true;
-    }
+        return false;
 
     // Count the total number of RenderLayers which need composited scrolling at
     // some point. This should be recorded at most once per RenderLayer, so we
     // check m_willUseCompositedScrollingHasBeenRecorded.
-    //
-    // FIXME: Currently, this computes the exact same value as the above.
-    // However, it will soon be expanded to cover more than just stacking
-    // containers (see crbug.com/249354). When this happens, we should see a
-    // spike in "WillUseCompositedScrolling", while "NeedsToBeStackingContainer"
-    // will remain relatively static.
     if (acceleratedCompositingForOverflowScrollEnabled() && !m_willUseCompositedScrollingHasBeenRecorded) {
         HistogramSupport::histogramEnumeration("Renderer.CompositedScrolling", WillUseCompositedScrollingBucket, CompositedScrollingHistogramMax);
         m_willUseCompositedScrollingHasBeenRecorded = true;
     }
 
     m_needsCompositedScrolling = needsCompositedScrolling;
 
-    // Note, the z-order lists may need to be rebuilt, but our code guarantees
-    // that we have not affected stacking, so we will not dirty
-    // m_canBePromotedToStackingContainer for either us or our stacking context
-    // or container.
-    didUpdateNeedsCompositedScrolling();
+    return true;
+}
+
+bool RenderLayer::setNeedsToBeStackingContainer(bool needsToBeStackingContainer)
+{
+    if (m_needsToBeStackingContainer == needsToBeStackingContainer)
+        return false;
+
+    // Count the total number of RenderLayers which need to be stacking
+    // containers some point. This should be recorded at most once per
+    // RenderLayer, so we check m_needsToBeStackingContainerHasBeenRecorded.
+    if (acceleratedCompositingForOverflowScrollEnabled() && !m_needsToBeStackingContainerHasBeenRecorded) {
+        HistogramSupport::histogramEnumeration("Renderer.CompositedScrolling", NeedsToBeStackingContainerBucket, CompositedScrollingHistogramMax);
+        m_needsToBeStackingContainerHasBeenRecorded = true;
+    }
+
+    m_needsToBeStackingContainer = needsToBeStackingContainer;
+
+    return true;
 }
 
 void RenderLayer::setForceNeedsCompositedScrolling(RenderLayer::ForceNeedsCompositedScrollingMode mode)
 {
     if (m_forceNeedsCompositedScrolling == mode)
         return;
 
     m_forceNeedsCompositedScrolling = mode;
     didUpdateNeedsCompositedScrolling();
 }
@@ skipping 4247 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif