Only update composited scrolling state when necessary

Source/WebCore/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 131 matching lines @@
 RenderLayer::RenderLayer(RenderLayerModelObject* renderer)
     : m_inResizeMode(false)
     , m_scrollDimensionsDirty(true)
     , m_normalFlowListDirty(true)
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_hasOutOfFlowPositionedDescendant(false)
     , m_hasOutOfFlowPositionedDescendantDirty(true)
     , m_needsCompositedScrolling(false)
     , m_descendantsAreContiguousInStackingOrder(false)
+    , m_descendantsAreContiguousInStackingOrderDirty(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)
     , m_hasVisibleDescendant(false)
     , m_isPaginated(false)
@@ skipping 82 matching lines @@
         removeReflection();
     
 #if ENABLE(CSS_FILTERS)
     removeFilterInfoIfNeeded();
 #endif
 
     // Child layers will be deleted by their corresponding render objects, so
     // we don't need to delete them ourselves.
 
     clearBacking(true);
+    cancelScheduledCompositedScrollingUpdates();
 
     if (m_scrollCorner)
         m_scrollCorner->destroy();
     if (m_resizer)
         m_resizer->destroy();
 }
 
 String RenderLayer::name() const
 {
     StringBuilder name;
@@ skipping 324 matching lines @@
 //   numSCDecendants = 3
 //
 // and so,
 //       maxStackIndex - minStackIndex == numSCDescendants
 //  ===>                         3 - 0 == 3
 //  ===>                             3 == 3
 //
 //  And we would conclude that C could be promoted.
 void RenderLayer::updateDescendantsAreContiguousInStackingOrder()
 {
-    if (!isStackingContext() || !acceleratedCompositingForOverflowScrollEnabled())
+    if (!m_descendantsAreContiguousInStackingOrderDirty || !isStackingContext() || !acceleratedCompositingForOverflowScrollEnabled())
         return;
 
     ASSERT(!m_normalFlowListDirty);
     ASSERT(!m_zOrderListsDirty);
 
     OwnPtr<Vector<RenderLayer*> > posZOrderList;
     OwnPtr<Vector<RenderLayer*> > negZOrderList;
     rebuildZOrderLists(StopAtStackingContexts, posZOrderList, negZOrderList);
 
     // Create a reverse lookup.
@@ skipping 19 matching lines @@
                 continue;
             lookup.set(currentLayer, stackingOrderIndex++);
         }
     }
 
     int minIndex = 0;
     int maxIndex = 0;
     int count = 0;
     bool firstIteration = true;
     updateDescendantsAreContiguousInStackingOrderRecursive(lookup, minIndex, maxIndex, count, firstIteration);
+
+    m_descendantsAreContiguousInStackingOrderDirty = false;
 }
 
 void RenderLayer::updateDescendantsAreContiguousInStackingOrderRecursive(const HashMap<const RenderLayer*, int>& lookup, int& minIndex, int& maxIndex, int& count, bool firstIteration)
 {
     if (isStackingContext() && !firstIteration) {
         if (lookup.contains(this)) {
             minIndex = std::min(minIndex, lookup.get(this));
             maxIndex = std::max(maxIndex, lookup.get(this));
             count++;
         }
@@ skipping 10 matching lines @@
             minIndex = std::min(minIndex, childMinIndex);
             maxIndex = std::max(maxIndex, childMaxIndex);
         }
     }
 
     if (!isStackingContext()) {
         bool newValue = maxIndex - minIndex == count;
         bool didUpdate = newValue != m_descendantsAreContiguousInStackingOrder;
         m_descendantsAreContiguousInStackingOrder = newValue;
         if (didUpdate)
-            updateNeedsCompositedScrolling();
+            requestNeedsCompositedScrollingUpdate();
     }
 }
 
 void RenderLayer::computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* geometryMap)
 {
     ASSERT(!m_visibleContentStatusDirty);
 
     m_repaintRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
     m_outlineBox = renderer()->outlineBoundsForRepaint(repaintContainer, geometryMap);
 }
@@ skipping 344 matching lines @@
             break;
 
         layer->m_hasVisibleDescendant = true;
         layer->m_visibleDescendantStatusDirty = false;
     }
 }
 
 void RenderLayer::updateDescendantDependentFlags(HashSet<const RenderObject*>* outOfFlowDescendantContainingBlocks)
 {
     if (m_visibleDescendantStatusDirty || m_hasSelfPaintingLayerDescendantDirty || m_hasOutOfFlowPositionedDescendantDirty) {
+        const bool hadVisibleDescendant = m_hasVisibleDescendant;
+        const bool hadOutOfFlowPositionedDescendant = m_hasOutOfFlowPositionedDescendant;
+
         m_hasVisibleDescendant = false;
         m_hasSelfPaintingLayerDescendant = false;
         m_hasOutOfFlowPositionedDescendant = false;
 
         HashSet<const RenderObject*> childOutOfFlowDescendantContainingBlocks;
         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
             childOutOfFlowDescendantContainingBlocks.clear();
             child->updateDescendantDependentFlags(&childOutOfFlowDescendantContainingBlocks);
 
             bool childIsOutOfFlowPositioned = child->renderer() && child->renderer()->isOutOfFlowPositioned();
             if (childIsOutOfFlowPositioned)
                 childOutOfFlowDescendantContainingBlocks.add(child->renderer()->containingBlock());
 
             if (outOfFlowDescendantContainingBlocks) {
                 HashSet<const RenderObject*>::const_iterator it = childOutOfFlowDescendantContainingBlocks.begin();
                 for (; it != childOutOfFlowDescendantContainingBlocks.end(); ++it)
                     outOfFlowDescendantContainingBlocks->add(*it);
             }
 
             bool hasVisibleDescendant = child->m_hasVisibleContent || child->m_hasVisibleDescendant;
             bool hasSelfPaintingLayerDescendant = child->isSelfPaintingLayer() || child->hasSelfPaintingLayerDescendant();
-            bool hasOutOfFlowPositionedDescendant = !childOutOfFlowDescendantContainingBlocks.isEmpty();
+            bool hasOutOfFlowPositionedDescendant = !childOutOfFlowDescendantContainingBlocks.isEmpty() || child->hasOutOfFlowPositionedDescendant();
 
             m_hasVisibleDescendant |= hasVisibleDescendant;
             m_hasSelfPaintingLayerDescendant |= hasSelfPaintingLayerDescendant;
             m_hasOutOfFlowPositionedDescendant |= hasOutOfFlowPositionedDescendant;
 
             if (m_hasVisibleDescendant && m_hasSelfPaintingLayerDescendant && m_hasOutOfFlowPositionedDescendant)
                 break;
         }
 
         if (outOfFlowDescendantContainingBlocks && renderer())
             outOfFlowDescendantContainingBlocks->remove(renderer());
 
         m_visibleDescendantStatusDirty = false;
         m_hasSelfPaintingLayerDescendantDirty = false;
+        m_hasOutOfFlowPositionedDescendantDirty = false;
 
-        if (m_hasOutOfFlowPositionedDescendantDirty)
-            updateNeedsCompositedScrolling();
-
-        m_hasOutOfFlowPositionedDescendantDirty = false;
+        if (m_hasVisibleDescendant != hadVisibleDescendant || m_hasOutOfFlowPositionedDescendant != hadOutOfFlowPositionedDescendant)
+            requestNeedsCompositedScrollingUpdate();
     }
 
     if (m_visibleContentStatusDirty) {
+        const bool hadVisibleContent = m_hasVisibleContent;
         if (renderer()->style()->visibility() == VISIBLE)
             m_hasVisibleContent = true;
         else {
             // layer may be hidden but still have some visible content, check for this
             m_hasVisibleContent = false;
             RenderObject* r = renderer()->firstChild();
             while (r) {
                 if (r->style()->visibility() == VISIBLE && !r->hasLayer()) {
                     m_hasVisibleContent = true;
                     break;
                 }
                 if (r->firstChild() && !r->hasLayer())
                     r = r->firstChild();
                 else if (r->nextSibling())
                     r = r->nextSibling();
                 else {
                     do {
                         r = r->parent();
                         if (r == renderer())
                             r = 0;
                     } while (r && !r->nextSibling());
                     if (r)
                         r = r->nextSibling();
                 }
             }
         }    
         m_visibleContentStatusDirty = false; 
+        if (hadVisibleContent != m_hasVisibleContent)
+            requestNeedsCompositedScrollingUpdate();
     }
 }
 
 void RenderLayer::dirty3DTransformedDescendantStatus()
 {
     RenderLayer* curr = stackingContainer();
     if (curr)
         curr->m_3DTransformedDescendantStatusDirty = true;
         
     // This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
@@ skipping 166 matching lines @@
 RenderLayer* RenderLayer::stackingContainer() const
 {
     RenderLayer* layer = parent();
     while (layer && !layer->isStackingContainer())
         layer = layer->parent();
 
     ASSERT(!layer || layer->isStackingContainer());
     return layer;
 }
 
+RenderLayer* RenderLayer::stackingContext() const
+{
+    RenderLayer* layer = parent();
+    while (layer && !layer->isStackingContext())
+        layer = layer->parent();
+
+    ASSERT(!layer || layer->isStackingContext());
+    return layer;
+}
+
 static inline bool isPositionedContainer(RenderLayer* layer)
 {
     RenderLayerModelObject* layerRenderer = layer->renderer();
     return layer->isRootLayer() || layerRenderer->isPositioned() || layer->hasTransform();
 }
 
 static inline bool isFixedPositionedContainer(RenderLayer* layer)
 {
     return layer->isRootLayer() || layer->hasTransform();
 }
@@ skipping 372 matching lines @@
     child->setParent(this);
 
     if (child->isNormalFlowOnly())
         dirtyNormalFlowList();
 
     if (!child->isNormalFlowOnly() || child->firstChild()) {
         // Dirty the z-order list in which we are contained. The stackingContainer() can be null in the
         // case where we're building up generated content layers. This is ok, since the lists will start
         // off dirty in that case anyway.
         child->dirtyStackingContainerZOrderLists();
+        child->requestDescendantsAreContiguousInStackingOrderUpdate();
+
+        // Adding an out of flow positioned descendant can only affect
+        // the opt-in decision for layers beneath and including our
+        // containing block.
+        RenderObject* containingBlock = child->renderer()->containingBlock();
+        for (RenderLayer* layer = child; layer; layer = layer->parent()) {
+            layer->requestNeedsCompositedScrollingUpdate();
+            if (layer->renderer() == containingBlock)
+                break;
+        }
     }
 
     child->updateDescendantDependentFlags();
     if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
         setAncestorChainHasVisibleDescendant();
 
     if (child->isSelfPaintingLayer() || child->hasSelfPaintingLayerDescendant())
         setAncestorChainHasSelfPaintingLayerDescendant();
 
     if (child->renderer() && (child->renderer()->isOutOfFlowPositioned() || child->hasOutOfFlowPositionedDescendant()))
@@ skipping 11 matching lines @@
     if (oldChild->previousSibling())
         oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
     if (oldChild->nextSibling())
         oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
 
     if (m_first == oldChild)
         m_first = oldChild->nextSibling();
     if (m_last == oldChild)
         m_last = oldChild->previousSibling();
 
+    oldChild->cancelScheduledCompositedScrollingUpdates();
+
     if (oldChild->isNormalFlowOnly())
         dirtyNormalFlowList();
-    if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) { 
+    if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) {
         // Dirty the z-order list in which we are contained.  When called via the
         // reattachment process in removeOnlyThisLayer, the layer may already be disconnected
         // from the main layer tree, so we need to null-check the |stackingContainer| value.
         oldChild->dirtyStackingContainerZOrderLists();
+        requestDescendantsAreContiguousInStackingOrderUpdate();
+
+        // This could affect whether or not a layer has an out of flow
+        // positioned descendant so we need to schedule some updates.
+        for (RenderLayer* layer = this; layer; layer = layer->parent())
+            layer->requestNeedsCompositedScrollingUpdate();
     }
 
     if ((oldChild->renderer() && oldChild->renderer()->isOutOfFlowPositioned()) || oldChild->hasOutOfFlowPositionedDescendant())
         dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
 
     oldChild->setPreviousSibling(0);
     oldChild->setNextSibling(0);
     oldChild->setParent(0);
-    
+
     oldChild->updateDescendantDependentFlags();
     if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
         dirtyAncestorChainVisibleDescendantStatus();
 
     if (oldChild->isSelfPaintingLayer() || oldChild->hasSelfPaintingLayerDescendant())
         dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     return oldChild;
 }
 
@@ skipping 200 matching lines @@
     return isComposited() && backing()->scrollingLayer();
 }
 
 bool RenderLayer::needsCompositedScrolling() const
 {
     return m_needsCompositedScrolling;
 }
 
 void RenderLayer::updateNeedsCompositedScrolling()
 {
-    bool oldNeedsCompositedScrolling = m_needsCompositedScrolling;
+    bool needsCompositedScrolling = false;
 
     FrameView* frameView = renderer()->view()->frameView();
-    if (!frameView || !frameView->containsScrollableArea(this))
-        m_needsCompositedScrolling = false;
-    else {
+    if (frameView && frameView->containsScrollableArea(this)) {
+        updateDescendantDependentFlags();
+
         bool forceUseCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()
             && canBeStackingContainer()
             && !hasOutOfFlowPositionedDescendant();
 
 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
-        m_needsCompositedScrolling = forceUseCompositedScrolling || renderer()->style()->useTouchOverflowScrolling();
+        needsCompositedScrolling = forceUseCompositedScrolling || renderer()->style()->useTouchOverflowScrolling();
 #else
-        m_needsCompositedScrolling = forceUseCompositedScrolling;
+        needsCompositedScrolling = forceUseCompositedScrolling;
 #endif
-        // 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", m_needsCompositedScrolling, 2);
     }
 
-    if (oldNeedsCompositedScrolling != m_needsCompositedScrolling) {
-        updateSelfPaintingLayer();
-        if (isStackingContainer())
-            dirtyZOrderLists();
-        else
-            clearZOrderLists();
+    setNeedsCompositedScrolling(needsCompositedScrolling);
+}
 
-        dirtyStackingContainerZOrderLists();
+void RenderLayer::setNeedsCompositedScrolling(bool needsCompositedScrolling)
+{
+    // 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);
 
-        compositor()->setShouldReevaluateCompositingAfterLayout();
-        compositor()->setCompositingLayersNeedRebuild();
-    }
+    if (m_needsCompositedScrolling == needsCompositedScrolling)
+        return;
+
+    m_needsCompositedScrolling = needsCompositedScrolling;
+
+    updateSelfPaintingLayer();
+    updateIsNormalFlowOnly();

[Julien - ping for review, 2013/04/09 21:06:43]

Already mentioned somewhere else but isSelfPaintingLayer relies on isNormalFlow
so the order is wrong :-/

[Ian Vollick, 2013/04/12 03:53:14]

Done.

+
+    if (isStackingContainer())
+        dirtyZOrderLists();
+    else
+        clearZOrderLists();
+
+    dirtyStackingContainerZOrderLists();

[Julien - ping for review, 2013/04/09 21:06:43]

Wouldn't that dirty the z-order list of a stacking container twice? (see the
code above)

[Ian Vollick, 2013/04/12 03:53:14]

Should be ok, I think. This function starts looking for stacking a
container/context starting at our parent. Shouldn't dirty the same layer twice.

+
+    compositor()->setShouldReevaluateCompositingAfterLayout();
+    compositor()->setCompositingLayersNeedRebuild();
+}
+
+void RenderLayer::requestNeedsCompositedScrollingUpdate()
+{
+    if (acceleratedCompositingForOverflowScrollEnabled())
+        ScopedCompositedScrollingUpdater(this, UpdateNeedsCompositedScrolling);
+}
+
+void RenderLayer::requestDescendantsAreContiguousInStackingOrderUpdate()
+{
+    if (acceleratedCompositingForOverflowScrollEnabled())
+        ScopedCompositedScrollingUpdater(this, UpdateDescendantsAreContiguousInStackingOrder);
+}
+
+void RenderLayer::cancelScheduledCompositedScrollingUpdates() const
+{
+    if (!renderer() || !renderer()->view())
+        return;
+
+    renderer()->view()->cancelScheduledCompositedScrollingUpdatesForLayer(const_cast<RenderLayer*>(this));

[Julien - ping for review, 2013/04/09 21:06:43]

Couldn't cancelScheduledCompositedScrollingUpdatesForLayer take a const pointer
instead of having to do a const_cast?

[Ian Vollick, 2013/04/12 03:53:14]

No longer applicable (yay).

 }
 
 static inline int adjustedScrollDelta(int beginningDelta) {
     // This implemention matches Firefox's.
     // http://mxr.mozilla.org/firefox/source/toolkit/content/widgets/browser.xml#856.
     const int speedReducer = 12;
 
     int adjustedDelta = beginningDelta / speedReducer;
     if (adjustedDelta > 1)
         adjustedDelta = static_cast<int>(adjustedDelta * sqrt(static_cast<double>(adjustedDelta))) - 1;
@@ skipping 274 matching lines @@
         frameView->resumeScheduledEvents();
 }
 
 void RenderLayer::updateCompositingLayersAfterScroll()
 {
     if (compositor()->inCompositingMode()) {
         // Our stacking container is guaranteed to contain all of our descendants that may need
         // repositioning, so update compositing layers from there.
         if (RenderLayer* compositingAncestor = stackingContainer()->enclosingCompositingLayer()) {
             if (compositor()->compositingConsultsOverlap()) {
-                if (usesCompositedScrolling() && !hasOutOfFlowPositionedDescendant())
+                if (usesCompositedScrolling())
                     compositor()->updateCompositingLayers(CompositingUpdateOnCompositedScroll, compositingAncestor);
                 else
                     compositor()->updateCompositingLayers(CompositingUpdateOnScroll, compositingAncestor);
             } else
                 compositingAncestor->backing()->updateAfterLayout(RenderLayerBacking::IsUpdateRoot);
         }
     }
 }
 
 LayoutRect RenderLayer::getRectToExpose(const LayoutRect &visibleRect, const LayoutRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
@@ skipping 3215 matching lines @@
 {
     ASSERT(m_layerListMutationAllowed);
     ASSERT(isStackingContainer());
 
     if (m_posZOrderList)
         m_posZOrderList->clear();
     if (m_negZOrderList)
         m_negZOrderList->clear();
     m_zOrderListsDirty = true;
 
+    m_descendantsAreContiguousInStackingOrderDirty = true;
+    requestDescendantsAreContiguousInStackingOrderUpdate();
+
     if (!renderer()->documentBeingDestroyed()) {
         compositor()->setCompositingLayersNeedRebuild();
         if (acceleratedCompositingForOverflowScrollEnabled())
             compositor()->setShouldReevaluateCompositingAfterLayout();
     }
 }
 
 void RenderLayer::dirtyStackingContainerZOrderLists()
 {
-    RenderLayer* sc = stackingContainer();
-    if (sc)
-        sc->dirtyZOrderLists();
+    RenderLayer* stackingContainer = this->stackingContainer();
+    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
+    // happen.
+    RenderLayer* stackingContext = this->stackingContext();
+    if (stackingContext && stackingContext != stackingContainer)
+        stackingContext->dirtyZOrderLists();
 }
 
 void RenderLayer::dirtyNormalFlowList()
 {
     ASSERT(m_layerListMutationAllowed);
 
     if (m_normalFlowList)
         m_normalFlowList->clear();
     m_normalFlowListDirty = true;
 
+    requestDescendantsAreContiguousInStackingOrderUpdate();
     if (!renderer()->documentBeingDestroyed()) {
         compositor()->setCompositingLayersNeedRebuild();
         if (acceleratedCompositingForOverflowScrollEnabled())
             compositor()->setShouldReevaluateCompositingAfterLayout();
     }
 }
 
+void RenderLayer::updateZOrderLists()
+{
+    ScopedCompositedScrollingUpdater suspendCompositedScrollingUpdates(renderer()->view());
+
+    if (!m_zOrderListsDirty)
+        return;
+
+    if (!isStackingContainer()) {
+        clearZOrderLists();
+        m_zOrderListsDirty = false;
+        return;
+    }
+
+    rebuildZOrderLists();
+}
+
 void RenderLayer::rebuildZOrderLists()
 {
     ASSERT(m_layerListMutationAllowed);
     ASSERT(isDirtyStackingContainer());
     rebuildZOrderLists(StopAtStackingContainers, m_posZOrderList, m_negZOrderList);
     m_zOrderListsDirty = false;
 }
 
 void RenderLayer::rebuildZOrderLists(CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*> >& posZOrderList, OwnPtr<Vector<RenderLayer*> >& negZOrderList)
 {
@@ skipping 75 matching lines @@
         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
             // Ignore reflections.
             if (!m_reflection || reflectionLayer() != child)
                 child->collectLayers(includeHiddenLayers, behavior, posBuffer, negBuffer);
         }
     }
 }
 
 void RenderLayer::updateLayerListsIfNeeded()
 {
-    bool shouldUpdateDescendantsAreContiguousInStackingOrder = isStackingContext() && (m_zOrderListsDirty || m_normalFlowListDirty);
+    bool shouldUpdateDescendantsAreContiguousInStackingOrder = acceleratedCompositingForOverflowScrollEnabled() && isStackingContext() && (m_zOrderListsDirty || m_normalFlowListDirty) && m_descendantsAreContiguousInStackingOrderDirty;
     updateZOrderLists();
     updateNormalFlowList();
 
     if (RenderLayer* reflectionLayer = this->reflectionLayer()) {
         reflectionLayer->updateZOrderLists();
         reflectionLayer->updateNormalFlowList();
     }
 
     if (shouldUpdateDescendantsAreContiguousInStackingOrder) {
         updateDescendantsAreContiguousInStackingOrder();
@@ skipping 85 matching lines @@
             && !renderer()->hasBlendMode()
 #endif
             && !isTransparent()
             && !needsCompositedScrolling()
 #if ENABLE(CSS_EXCLUSIONS)
             && !renderer()->isFloatingWithShapeOutside()
 #endif
             ;
 }
 
+void RenderLayer::updateIsNormalFlowOnly()
+{
+    bool isNormalFlowOnly = shouldBeNormalFlowOnly();
+    if (isNormalFlowOnly != m_isNormalFlowOnly) {

[Julien - ping for review, 2013/04/09 21:06:43]

Better with an early return.

[Ian Vollick, 2013/04/12 03:53:14]

Done.

+        m_isNormalFlowOnly = isNormalFlowOnly;
+        RenderLayer* p = parent();
+        if (p)
+            p->dirtyNormalFlowList();
+        dirtyStackingContainerZOrderLists();
+    }
+}
+
 bool RenderLayer::shouldBeSelfPaintingLayer() const
 {
     return !isNormalFlowOnly()
         || hasOverlayScrollbars()
         || needsCompositedScrolling()
         || renderer()->hasReflection()
         || renderer()->hasMask()
         || renderer()->isTableRow()
         || renderer()->isCanvas()
         || renderer()->isVideo()
@@ skipping 62 matching lines @@
 
     if (renderer()->isReplaced() || renderer()->hasMask())
         return true;
 
     if (hasVisibleBoxDecorations())
         return true;
 
     return false;
 }
 
+void RenderLayer::updateVisibilityAfterStyleChange(const RenderStyle* oldStyle)
+{
+    EVisibility oldVisibility = VISIBLE;
+    if (oldStyle)
+        oldVisibility = oldStyle->visibility();

[Julien - ping for review, 2013/04/09 21:06:43]

On one line?

EVisibility oldVisibility = oldStyle ? oldStyle->visibility() : VISIBLE;

[Ian Vollick, 2013/04/12 03:53:14]

Done.

+
+    if (oldVisibility != renderer()->style()->visibility()) {

[Julien - ping for review, 2013/04/09 21:06:43]

Again, better with an early return.

[Ian Vollick, 2013/04/12 03:53:14]

Done.

+        for (RenderLayer* layer = this; layer; layer = layer->parent())
+            layer->requestNeedsCompositedScrollingUpdate();
+    }
+}
+
 void RenderLayer::updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle)
 {
-    if (!oldStyle)
-        return;
-
-    bool wasStackingContext = isStackingContext(oldStyle);
-    bool isStackingContext = this->isStackingContext();
-    if (isStackingContext != wasStackingContext) {
-        dirtyStackingContainerZOrderLists();
-        if (isStackingContext)
-            dirtyZOrderLists();
-        else
-            clearZOrderLists();
-        return;
+    bool wasStackingContext = false;
+    EVisibility oldVisibility = VISIBLE;
+    int oldZIndex = 0;

[Julien - ping for review, 2013/04/09 21:06:43]

Ditto, those should be one liners.

[Ian Vollick, 2013/04/12 03:53:14]

Done.

+    if (oldStyle) {
+        wasStackingContext = isStackingContext(oldStyle);
+        oldVisibility = oldStyle->visibility();
+        oldZIndex = oldStyle->zIndex();
     }
 
     // FIXME: RenderLayer already handles visibility changes through our visiblity dirty bits. This logic could
     // likely be folded along with the rest.
-    if (oldStyle->zIndex() != renderer()->style()->zIndex() || oldStyle->visibility() != renderer()->style()->visibility()) {
+    bool isStackingContext = this->isStackingContext();
+    if (isStackingContext != wasStackingContext
+        || oldVisibility != renderer()->style()->visibility()
+        || oldZIndex != renderer()->style()->zIndex()) {
         dirtyStackingContainerZOrderLists();
-        if (isStackingContext)
+        if (isStackingContainer())
             dirtyZOrderLists();
+
+        requestNeedsCompositedScrollingUpdate();
     }
 }
 
 static bool overflowRequiresScrollbar(EOverflow overflow)
 {
     return overflow == OSCROLL;
 }
 
 static bool overflowDefinesAutomaticScrollbar(EOverflow overflow)
 {
@@ skipping 37 matching lines @@
 }
 
 void RenderLayer::setAncestorChainHasOutOfFlowPositionedDescendant(RenderObject* containingBlock)
 {
     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
         if (!layer->m_hasOutOfFlowPositionedDescendantDirty && layer->hasOutOfFlowPositionedDescendant())
             break;
 
         layer->m_hasOutOfFlowPositionedDescendantDirty = false;
         layer->m_hasOutOfFlowPositionedDescendant = true;
-        layer->updateNeedsCompositedScrolling();
+        layer->requestNeedsCompositedScrollingUpdate();
 
         if (layer->renderer() && layer->renderer() == containingBlock)
             break;
     }
 }
 
 void RenderLayer::dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus()
 {
-    m_hasOutOfFlowPositionedDescendantDirty = true;
+    if (m_hasOutOfFlowPositionedDescendant) {
+        m_hasOutOfFlowPositionedDescendantDirty = true;
+        requestNeedsCompositedScrollingUpdate();
+    }
     if (parent())
         parent()->dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
 }
 
 void RenderLayer::updateOutOfFlowPositioned(const RenderStyle* oldStyle)
 {
     bool wasOutOfFlowPositioned = oldStyle && (oldStyle->position() == AbsolutePosition || oldStyle->position() == FixedPosition);
-    if (parent() && ((renderer() && renderer()->isOutOfFlowPositioned()) != wasOutOfFlowPositioned)) {
-        parent()->dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
-        if (!renderer()->documentBeingDestroyed() && acceleratedCompositingForOverflowScrollEnabled())
-            compositor()->setShouldReevaluateCompositingAfterLayout();
+    bool isOutOfFlowPositioned = renderer()->isOutOfFlowPositioned();
+    if (parent() && isOutOfFlowPositioned != wasOutOfFlowPositioned) {
+        if (isOutOfFlowPositioned)
+            parent()->setAncestorChainHasOutOfFlowPositionedDescendant(renderer()->containingBlock());
+        else
+            parent()->dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
     }
 }
 
 #if ENABLE(CSS_FILTERS)
 static bool hasOrHadFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle)
 {
     ASSERT(newStyle);
     return (oldStyle && oldStyle->hasFilter()) || newStyle->hasFilter();
 }
 #endif
@@ skipping 63 matching lines @@
     // FilterEffectRenderer is intended to render software filters and shouldn't be needed for accelerated filters.
     // We should extract the SVG graph building functionality out of FilterEffectRenderer, and it should happen in RenderLayer::computeFilterOperations.
     // https://bugs.webkit.org/show_bug.cgi?id=114051
     if (shouldUpdateFilters && newStyle->filter().hasReferenceFilter())
         backing()->updateFilters(renderer()->style());
 }
 #endif
 
 void RenderLayer::styleChanged(StyleDifference, const RenderStyle* oldStyle)
 {
-    bool isNormalFlowOnly = shouldBeNormalFlowOnly();
-    if (isNormalFlowOnly != m_isNormalFlowOnly) {
-        m_isNormalFlowOnly = isNormalFlowOnly;
-        RenderLayer* p = parent();
-        if (p)
-            p->dirtyNormalFlowList();
-        dirtyStackingContainerZOrderLists();
-    }
-
     if (renderer()->style()->overflowX() == OMARQUEE && renderer()->style()->marqueeBehavior() != MNONE && renderer()->isBox()) {
         if (!m_marquee)
             m_marquee = adoptPtr(new RenderMarquee(this));
         FeatureObserver::observe(renderer()->document(), renderer()->isHTMLMarquee() ? FeatureObserver::HTMLMarqueeElement : FeatureObserver::CSSOverflowMarquee);
         m_marquee->updateMarqueeStyle();
     }
     else if (m_marquee) {
         m_marquee.clear();
     }
 
     updateScrollbarsAfterStyleChange(oldStyle);
     updateStackingContextsAfterStyleChange(oldStyle);
+    updateVisibilityAfterStyleChange(oldStyle);
     // Overlay scrollbars can make this layer self-painting so we need
     // to recompute the bit once scrollbars have been updated.
     updateSelfPaintingLayer();
     updateOutOfFlowPositioned(oldStyle);
 
     if (!hasReflection() && m_reflection)
         removeReflection();
     else if (hasReflection()) {
         if (!m_reflection)
             createReflection();
@@ skipping 17 matching lines @@
 #endif
 
     bool didPaintWithFilters = false;
 
 #if ENABLE(CSS_FILTERS)
     if (paintsWithFilters())
         didPaintWithFilters = true;
     updateFilters(oldStyle, renderer()->style());
 #endif
 
-    updateNeedsCompositedScrolling();
-
     const RenderStyle* newStyle = renderer()->style();
     if (compositor()->updateLayerCompositingState(this)
         || needsCompositingLayersRebuiltForClip(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForOverflow(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForFilters(oldStyle, newStyle, didPaintWithFilters))
         compositor()->setCompositingLayersNeedRebuild();
     else if (isComposited())
         backing()->updateGraphicsLayerGeometry();
 }
 
 void RenderLayer::updateScrollableAreaSet(bool hasOverflow)
 {
     Frame* frame = renderer()->frame();
     if (!frame)
         return;
 
     FrameView* frameView = frame->view();
     if (!frameView)
         return;
 
     bool isVisibleToHitTest = renderer()->visibleToHitTesting();
     if (HTMLFrameOwnerElement* owner = frame->ownerElement())
         isVisibleToHitTest &= owner->renderer() && owner->renderer()->visibleToHitTesting();
 
-    if (hasOverflow && isVisibleToHitTest ? frameView->addScrollableArea(this) : frameView->removeScrollableArea(this))
-        updateNeedsCompositedScrolling();
+    bool updatedScrollableAreaSet = false;
+    if (hasOverflow && isVisibleToHitTest)
+        updatedScrollableAreaSet = frameView->addScrollableArea(this);
+    else
+        updatedScrollableAreaSet = frameView->removeScrollableArea(this);
+
+    if (updatedScrollableAreaSet)
+        requestNeedsCompositedScrollingUpdate();
 }
 
 void RenderLayer::updateScrollCornerStyle()
 {
     RenderObject* actualRenderer = rendererForScrollbar(renderer());
     RefPtr<RenderStyle> corner = renderer()->hasOverflowClip() ? actualRenderer->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), actualRenderer->style()) : PassRefPtr<RenderStyle>(0);
     if (corner) {
         if (!m_scrollCorner) {
             m_scrollCorner = RenderScrollbarPart::createAnonymous(renderer()->document());
             m_scrollCorner->setParent(renderer());
@@ skipping 240 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif