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 96 matching lines @@
 
 RenderLayer::RenderLayer(RenderLayerModelObject* renderer)
     : 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_canBePromotedToStackingContainer(false)
-    , m_canBePromotedToStackingContainerDirty(true)
+    , m_needsToBeStackingContainer(false)
+    , m_descendantsAreContiguousInStackingOrder(false)
+    , m_descendantsAreContiguousInStackingOrderDirty(true)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_childLayerHasBlendMode(false)
     , m_childLayerHasBlendModeStatusDirty(false)
     , m_paintingInsideReflection(false)
     , m_visibleContentStatusDirty(true)
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
     , m_hasVisibleDescendant(false)
     , m_isPaginated(false)
@@ skipping 271 matching lines @@
         return false;
 
     const Settings* settings = renderer()->document().settings();
     return settings && settings->isCompositorDrivenAcceleratedScrollingEnabled();
 }
 
 // Determine whether the current layer can be promoted to a stacking container.
 // We do this by computing what positive and negative z-order lists would look
 // like before and after promotion, and ensuring that proper stacking order is
 // preserved between the two sets of lists.
-void RenderLayer::updateCanBeStackingContainer()
+void RenderLayer::updateDescendantsAreContiguousInStackingOrder()
 {
-    TRACE_EVENT0("blink_rendering,comp-scroll", "RenderLayer::updateCanBeStackingContainer");
+    TRACE_EVENT0("blink_rendering,comp-scroll", "RenderLayer::updateDescendantsAreContiguousInStackingOrder");
 
-    if (isStackingContext() || !m_canBePromotedToStackingContainerDirty || !acceleratedCompositingForOverflowScrollEnabled())
+    if (isStackingContext() || !m_descendantsAreContiguousInStackingOrderDirty || !acceleratedCompositingForOverflowScrollEnabled())
         return;
 
     FrameView* frameView = renderer()->view()->frameView();
     if (!frameView || !frameView->containsScrollableArea(scrollableArea()))
         return;
 
     RenderLayer* ancestorStackingContext = this->ancestorStackingContext();
     if (!ancestorStackingContext)
         return;
 
     OwnPtr<Vector<RenderLayer*> > posZOrderListBeforePromote = adoptPtr(new Vector<RenderLayer*>);
     OwnPtr<Vector<RenderLayer*> > negZOrderListBeforePromote = adoptPtr(new Vector<RenderLayer*>);
     OwnPtr<Vector<RenderLayer*> > posZOrderListAfterPromote = adoptPtr(new Vector<RenderLayer*>);
     OwnPtr<Vector<RenderLayer*> > negZOrderListAfterPromote = adoptPtr(new Vector<RenderLayer*>);
 
     collectBeforePromotionZOrderList(ancestorStackingContext, posZOrderListBeforePromote, negZOrderListBeforePromote);
     collectAfterPromotionZOrderList(ancestorStackingContext, posZOrderListAfterPromote, negZOrderListAfterPromote);
 
     size_t maxIndex = std::min(posZOrderListAfterPromote->size() + negZOrderListAfterPromote->size(), posZOrderListBeforePromote->size() + negZOrderListBeforePromote->size());
 
-    m_canBePromotedToStackingContainerDirty = false;
-    m_canBePromotedToStackingContainer = false;
+    m_descendantsAreContiguousInStackingOrderDirty = false;
+    m_descendantsAreContiguousInStackingOrder = false;
 
     const RenderLayer* layerAfterPromote = 0;
     for (size_t i = 0; i < maxIndex && layerAfterPromote != this; ++i) {
         const RenderLayer* layerBeforePromote = i < negZOrderListBeforePromote->size()
             ? negZOrderListBeforePromote->at(i)
             : posZOrderListBeforePromote->at(i - negZOrderListBeforePromote->size());
         layerAfterPromote = i < negZOrderListAfterPromote->size()
             ? negZOrderListAfterPromote->at(i)
             : posZOrderListAfterPromote->at(i - negZOrderListAfterPromote->size());
 
         if (layerBeforePromote != layerAfterPromote && (layerAfterPromote != this || renderer()->hasBackground()))
             return;
     }
 
     layerAfterPromote = 0;
     for (size_t i = 0; i < maxIndex && layerAfterPromote != this; ++i) {
         const RenderLayer* layerBeforePromote = i < posZOrderListBeforePromote->size()
             ? posZOrderListBeforePromote->at(posZOrderListBeforePromote->size() - i - 1)
             : negZOrderListBeforePromote->at(negZOrderListBeforePromote->size() + posZOrderListBeforePromote->size() - i - 1);
         layerAfterPromote = i < posZOrderListAfterPromote->size()
             ? posZOrderListAfterPromote->at(posZOrderListAfterPromote->size() - i - 1)
             : negZOrderListAfterPromote->at(negZOrderListAfterPromote->size() + posZOrderListAfterPromote->size() - i - 1);
 
         if (layerBeforePromote != layerAfterPromote && layerAfterPromote != this)
             return;
     }
 
-    m_canBePromotedToStackingContainer = true;
+    m_descendantsAreContiguousInStackingOrder = true;
 }
 
 static inline bool isPositionedContainer(const RenderLayer* layer)
 {
     // FIXME: This is not in sync with containingBlock.
     // RenderObject::canContainFixedPositionedObject() should probably be used
     // instead.
     RenderLayerModelObject* layerRenderer = layer->renderer();
     return layer->isRootLayer() || layerRenderer->isPositioned() || layer->hasTransform();
 }
@@ skipping 420 matching lines @@
     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
         if (curr->renderer()->hasColumns()) {
             m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->renderBox());
             return;
         }
         if (curr == ancestorStackingContainer)
             return;
     }
 }
 
-bool RenderLayer::canBeStackingContainer() const
+bool RenderLayer::descendantsAreContiguousInStackingOrder() const
 {
     if (isStackingContext() || !ancestorStackingContainer())
         return true;
 
-    ASSERT(!m_canBePromotedToStackingContainerDirty);
-    return m_canBePromotedToStackingContainer;
+    ASSERT(!m_descendantsAreContiguousInStackingOrderDirty);
+    return m_descendantsAreContiguousInStackingOrder;
 }
 
 void RenderLayer::setHasVisibleContent()
 {
     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
         ASSERT(!parent() || parent()->hasVisibleDescendant());
         return;
     }
 
     m_visibleContentStatusDirty = false;
@@ skipping 753 matching lines @@
         // requirements since we may be able to mark more layers as having
         // an 'unclipped' descendant.
         compositor()->setNeedsUpdateCompositingRequirementsState();
         setAncestorChainHasOutOfFlowPositionedDescendant();
     }
 
     // When we first dirty a layer, we will also dirty all the siblings in that
     // layer's stacking context. We need to manually do it here as well, in case
     // we're adding this layer after the stacking context has already been
     // updated.
-    child->m_canBePromotedToStackingContainerDirty = true;
+    child->m_descendantsAreContiguousInStackingOrderDirty = true;
     compositor()->layerWasAdded(this, child);
 }
 
 RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)
 {
     if (!renderer()->documentBeingDestroyed())
         compositor()->layerWillBeRemoved(this, oldChild);
 
     // remove the child
     if (oldChild->previousSibling())
@@ skipping 244 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 compositedLayerMapping() && compositedLayerMapping()->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);
 }
 
 RenderLayer* RenderLayer::scrollParent() const
 {
     if (!compositorDrivenAcceleratedScrollingEnabled())
         return 0;
 
     // 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())
+    if (!scrollParent || scrollParent->isStackingContainer())
         return 0;
 
     // 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())
+        if (ancestor->isStackingContainer())
             return 0;
     }
 
     return scrollParent;
 }
 
 RenderLayer* RenderLayer::clipParent() const
 {
     const bool needsAncestorClip = compositor()->clippedByAncestor(this);
 
     RenderLayer* clipParent = 0;
     if ((compositingReasons() & CompositingReasonOutOfFlowClipping) && !needsAncestorClip) {
         if (RenderObject* containingBlock = renderer()->containingBlock())
             clipParent = containingBlock->enclosingLayer()->enclosingCompositingLayer(true);
     }
 
     return clipParent;
 }
 
 void RenderLayer::updateNeedsCompositedScrolling()
 {
     TRACE_EVENT0("comp-scroll", "RenderLayer::updateNeedsCompositedScrolling");
 
-    updateCanBeStackingContainer();
+    updateDescendantsAreContiguousInStackingOrder();
     updateDescendantDependentFlags();
 
     ASSERT(renderer()->view()->frameView() && renderer()->view()->frameView()->containsScrollableArea(scrollableArea()));
-    bool needsCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()
-        && canBeStackingContainer()
+    const bool needsToBeStackingContainer = acceleratedCompositingForOverflowScrollEnabled()
+        && descendantsAreContiguousInStackingOrder()
         && !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_descendantsAreContiguousInStackingOrder 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 2542 matching lines @@
 }
 
 // Helper for the sorting of layers by z-index.
 static inline bool compareZIndex(RenderLayer* first, RenderLayer* second)
 {
     return first->zIndex() < second->zIndex();
 }
 
 void RenderLayer::dirtyNormalFlowListCanBePromotedToStackingContainer()
 {
-    m_canBePromotedToStackingContainerDirty = true;
+    m_descendantsAreContiguousInStackingOrderDirty = true;
 
     if (m_normalFlowListDirty || !normalFlowList())
         return;
 
     for (size_t index = 0; index < normalFlowList()->size(); ++index)
         normalFlowList()->at(index)->dirtyNormalFlowListCanBePromotedToStackingContainer();
 }
 
 void RenderLayer::dirtySiblingStackingContextCanBePromotedToStackingContainer()
 {
     RenderLayer* ancestorStackingContext = this->ancestorStackingContext();
     if (!ancestorStackingContext)
         return;
 
     if (!ancestorStackingContext->m_zOrderListsDirty && ancestorStackingContext->posZOrderList()) {
         for (size_t index = 0; index < ancestorStackingContext->posZOrderList()->size(); ++index)
-            ancestorStackingContext->posZOrderList()->at(index)->m_canBePromotedToStackingContainerDirty = true;
+            ancestorStackingContext->posZOrderList()->at(index)->m_descendantsAreContiguousInStackingOrderDirty = true;
     }
 
     ancestorStackingContext->dirtyNormalFlowListCanBePromotedToStackingContainer();
 
     if (!ancestorStackingContext->m_zOrderListsDirty && ancestorStackingContext->negZOrderList()) {
         for (size_t index = 0; index < ancestorStackingContext->negZOrderList()->size(); ++index)
-            ancestorStackingContext->negZOrderList()->at(index)->m_canBePromotedToStackingContainerDirty = true;
+            ancestorStackingContext->negZOrderList()->at(index)->m_descendantsAreContiguousInStackingOrderDirty = true;
     }
 }
 
 void RenderLayer::dirtyZOrderLists()
 {
     ASSERT(m_layerListMutationAllowed);
     ASSERT(isStackingContainer());
 
     if (m_posZOrderList)
         m_posZOrderList->clear();
     if (m_negZOrderList)
         m_negZOrderList->clear();
     m_zOrderListsDirty = true;
 
-    m_canBePromotedToStackingContainerDirty = true;
+    m_descendantsAreContiguousInStackingOrderDirty = true;
 
     if (!renderer()->documentBeingDestroyed()) {
         compositor()->setNeedsUpdateCompositingRequirementsState();
         compositor()->setCompositingLayersNeedRebuild();
         if (acceleratedCompositingForOverflowScrollEnabled())
             compositor()->setShouldReevaluateCompositingAfterLayout();
     }
 }
 
 void RenderLayer::dirtyStackingContainerZOrderLists()
 {
     // Any siblings in the ancestor stacking context could also be affected.
     // Changing z-index, for example, could cause us to stack in between a
     // sibling's descendants, meaning that we have to recompute
-    // m_canBePromotedToStackingContainer for that sibling.
+    // m_descendantsAreContiguousInStackingOrder for that sibling.
     dirtySiblingStackingContextCanBePromotedToStackingContainer();
 
     RenderLayer* stackingContainer = this->ancestorStackingContainer();
     if (stackingContainer)
         stackingContainer->dirtyZOrderLists();
 
     // Any change that could affect our stacking container's z-order list could
     // cause other RenderLayers in our stacking context to either opt in or out
     // of composited scrolling. It is important that we make our stacking
     // context aware of these z-order changes so the appropriate updating can
@@ skipping 864 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif