Add an intermediate function to generate 2 paint-order lists.

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 60 matching lines @@
 #include "HTMLFrameElement.h"
 #include "HTMLFrameOwnerElement.h"
 #include "HTMLNames.h"
 #include "HistogramSupport.h"
 #include "HitTestingTransformState.h"
 #include "HitTestRequest.h"
 #include "HitTestResult.h"
 #include "OverflowEvent.h"
 #include "OverlapTestRequestClient.h"
 #include "Page.h"
+#include "PaintOrderLists.h"
 #include "PlatformMouseEvent.h"
 #include "RenderArena.h"
 #include "RenderFlowThread.h"
 #include "RenderGeometryMap.h"
 #include "RenderInline.h"
 #include "RenderLayerBacking.h"
 #include "RenderLayerCompositor.h"
 #include "RenderMarquee.h"
 #include "RenderReplica.h"
 #include "RenderSVGResourceClipper.h"
 #include "RenderScrollbar.h"
 #include "RenderScrollbarPart.h"
 #include "RenderTheme.h"
 #include "RenderTreeAsText.h"
 #include "RenderView.h"
 #include "ScaleTransformOperation.h"
 #include "ScrollAnimator.h"
 #include "Scrollbar.h"
 #include "ScrollbarTheme.h"
 #include "ScrollingCoordinator.h"
 #include "Settings.h"
 #include "ShadowRoot.h"
 #include "SourceGraphic.h"
+#include "StaticHashSetNodeList.h"
 #include "StylePropertySet.h"
 #include "StyleResolver.h"
 #include "TextStream.h"
 #include "TransformationMatrix.h"
 #include "TranslateTransformOperation.h"
 #include "WebCoreMemoryInstrumentation.h"
 #include <wtf/MemoryInstrumentationVector.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/UnusedParam.h>
 #include <wtf/text/CString.h>
@@ skipping 552 matching lines @@
 
     if (!isStackingContext()) {
         bool newValue = maxIndex - minIndex == count;
         bool didUpdate = newValue != m_descendantsAreContiguousInStackingOrder;
         m_descendantsAreContiguousInStackingOrder = newValue;
         if (didUpdate)
             updateNeedsCompositedScrolling();
     }
 }
 
+static inline bool isPositionedContainer(const RenderLayer* layer)
+{
+    // FIXME: This is not in sync with containingBlock.
+    // RenderObject::canContainFixedPositionedObject() should probably be used
+    // instead.

[Ian Vollick, 2013/04/16 19:17:41]

Let's just fix this rather than putting in a FIXME. It's definitely the right
thing to do.

[hartmanng, 2013/04/17 18:00:20]

I tried to fix this, but ran into the following assert in debug mode:

STDERR: ASSERTION FAILED: enclosingIntRect(rendererMappedResult) ==
enclosingIntRect(FloatQuad(result).boundingBox())
STDERR:
../../third_party/WebKit/Source/core/rendering/RenderGeometryMap.cpp(142) :
WebCore::FloatQuad WebCore::RenderGeometryMap::mapToContainer(const
WebCore::FloatRect &, const WebCore::RenderLayerModelObject *) const

when running LayoutTests/compositing/overflow/build-paint-order-lists.html.

Julien: any idea why this might be?

+    RenderLayerModelObject* layerRenderer = layer->renderer();
+    return layer->isRootLayer() || layerRenderer->isPositioned() || layer->hasTransform();
+}
+
+enum StackingOrderDirection { FromBackground, FromForeground };
+
+// We'd like to be able to iterate through a single paint order list, but for
+// efficiency's sake, we hang onto two lists instead (namely, the pos and neg
+// z-order lists produced by CollectLayers). This function allows us to index
+// into these two lists as if they were one. It also allows us to index into
+// this virtual list either from the start or from the end (i.e., in either
+// stacking order direction).
+static const RenderLayer* getStackingOrderElementAt(const Vector<RenderLayer*>* posZOrderList, const Vector<RenderLayer*>* negZOrderList, const StackingOrderDirection direction, const size_t index)
+{
+    size_t negZOrderListSize = negZOrderList ? negZOrderList->size() : 0;
+
+    if (direction == FromBackground) {
+        if (index < negZOrderListSize)
+            return negZOrderList->at(index);
+
+        return posZOrderList->at(index - negZOrderListSize);
+    }
+
+    size_t posZOrderListSize = posZOrderList ? posZOrderList->size() : 0;
+
+    if (index < posZOrderListSize)
+        return posZOrderList->at(posZOrderListSize - index - 1);
+
+    return negZOrderList->at(negZOrderListSize - (index - posZOrderListSize) - 1);
+}
+
+void RenderLayer::collectBeforeAfterPromotionZOrderLists(RenderLayer* ancestorStackingContext,
+    OwnPtr<Vector<RenderLayer*> >& posZOrderListBeforePromote,
+    OwnPtr<Vector<RenderLayer*> >& negZOrderListBeforePromote,
+    OwnPtr<Vector<RenderLayer*> >& posZOrderListAfterPromote,
+    OwnPtr<Vector<RenderLayer*> >& negZOrderListAfterPromote)
+{
+    // We can't use TemporaryChange<> here since m_needsCompositedScrolling and
+    // m_isNormalFlowOnly are both bitfields, so we have to do it the
+    // old-fashioned way.
+    bool oldNeedsCompositedScrolling = m_needsCompositedScrolling;
+    bool oldIsNormalFlowOnly = m_isNormalFlowOnly;
+
+    // Set the flag on the current layer, then rebuild ancestor stacking
+    // context's lists. This way, we can see the exact effects that promoting
+    // this layer would cause.
+    m_needsCompositedScrolling = false;
+    m_isNormalFlowOnly = shouldBeNormalFlowOnly();
+    ancestorStackingContext->rebuildZOrderLists(StopAtStackingContexts, posZOrderListBeforePromote, negZOrderListBeforePromote, 0);
+
+    m_isNormalFlowOnly = false;
+    m_needsCompositedScrolling = true;
+    ancestorStackingContext->rebuildZOrderLists(StopAtStackingContexts, posZOrderListAfterPromote, negZOrderListAfterPromote, this);
+
+    m_needsCompositedScrolling = oldNeedsCompositedScrolling;
+    m_isNormalFlowOnly = oldIsNormalFlowOnly;
+}
+
+// Compute what positive and negative z-order lists would look like before and
+// after promotion, so we can later ensure that proper stacking order is
+// preserved between the two sets of lists.
+//
+// A few examples:
+// c = currentLayer
+// - = negative z-order child of currentLayer
+// + = positive z-order child of currentLayer
+// a = positioned ancestor of currentLayer
+// x = any other RenderLayer in the list
+//
+// (a) xxxxx-----++a+++x
+// (b) xxx-----c++++++xx
+//
+//
+// Normally the current layer would be painted in the normal flow list if it
+// doesn't already appear in the positive z-order list. However, in the case
+// that the layer has a positioned ancestor, it will paint directly after the
+// positioned ancestor. In example (a), the current layer would be painted in
+// the middle of its own positive z-order children, so promoting would cause a
+// change in paint order (since a promoted layer will paint all of its positive
+// z-order children strictly after it paints itself).
+//
+// In example (b), it is ok to promote the current layer only if it does not
+// have a background. If it has a background, the background gets painted before
+// the layer's negative z-order children, so again, a promotion would cause a
+// change in paint order (causing the background to get painted after the
+// negative z-order children instead of before).
+void RenderLayer::getPaintOrderLists(RenderLayer* ancestorStackingContext,
+    OwnPtr<Vector<RenderLayer*> >& posZOrderListBeforePromote,
+    OwnPtr<Vector<RenderLayer*> >& negZOrderListBeforePromote,
+    OwnPtr<Vector<RenderLayer*> >& posZOrderListAfterPromote,
+    OwnPtr<Vector<RenderLayer*> >& negZOrderListAfterPromote)
+{
+    collectBeforeAfterPromotionZOrderLists(ancestorStackingContext,
+        posZOrderListBeforePromote, negZOrderListBeforePromote,
+        posZOrderListAfterPromote, negZOrderListAfterPromote);
+
+    size_t posZOrderListSizeBeforePromote = posZOrderListBeforePromote ? posZOrderListBeforePromote->size() : 0;
+
+    const RenderLayer* positionedAncestor = parent();
+    while (positionedAncestor && !isPositionedContainer(positionedAncestor) && !positionedAncestor->isStackingContext())
+        positionedAncestor = positionedAncestor->parent();
+    if (positionedAncestor && (!isPositionedContainer(positionedAncestor) || positionedAncestor->isStackingContext()))
+        positionedAncestor = 0;
+
+    bool currentLayerIsInPosZOrderListBeforePromote = false;
+
+    for (size_t index = 0; index < posZOrderListSizeBeforePromote; index++) {
+        if (posZOrderListBeforePromote->at(index) == this) {
+            currentLayerIsInPosZOrderListBeforePromote = true;
+            break;
+        }
+    }
+
+    // Insert this into the posZOrderistBeforePromote directly after the
+    // positioned ancestor, if there is one. Otherwise, add it to the very
+    // beginning.
+    //
+    // The current layer will appear in the z-order lists after promotion, so
+    // for a meaningful comparison, we must insert it in the z-order lists
+    // before promotion if it does not appear there already.
+    if (!currentLayerIsInPosZOrderListBeforePromote) {
+        if (!positionedAncestor) {
+            if (!posZOrderListBeforePromote)
+                posZOrderListBeforePromote = adoptPtr(new Vector<RenderLayer*>());
+
+            posZOrderListBeforePromote->prepend(this);
+            posZOrderListSizeBeforePromote++;
+        } else {
+            for (size_t index = 0; index < posZOrderListSizeBeforePromote; index++) {
+                if (posZOrderListBeforePromote->at(index) == positionedAncestor) {
+                    posZOrderListBeforePromote->insert(index + 1, this);
+                    posZOrderListSizeBeforePromote++;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+String RenderLayer::paintOrderListsAsText()
+{
+    OwnPtr<Vector<RenderLayer*> > posZOrderListBeforePromote;
+    OwnPtr<Vector<RenderLayer*> > negZOrderListBeforePromote;
+    OwnPtr<Vector<RenderLayer*> > posZOrderListAfterPromote;
+    OwnPtr<Vector<RenderLayer*> > negZOrderListAfterPromote;
+
+    RenderLayer* ancestorStackingContext = this;
+
+    while (ancestorStackingContext) {
+        if (ancestorStackingContext != this && ancestorStackingContext->isStackingContext())
+            break;
+        ancestorStackingContext = ancestorStackingContext->parent();
+    }
+
+    if (!ancestorStackingContext)
+        return String();
+
+    getPaintOrderLists(ancestorStackingContext,
+        posZOrderListBeforePromote, negZOrderListBeforePromote,
+        posZOrderListAfterPromote, negZOrderListAfterPromote);
+
+    size_t posZOrderListSizeBeforePromote = posZOrderListBeforePromote ? posZOrderListBeforePromote->size() : 0;
+    size_t negZOrderListSizeBeforePromote = negZOrderListBeforePromote ? negZOrderListBeforePromote->size() : 0;
+    size_t posZOrderListSizeAfterPromote = posZOrderListAfterPromote ? posZOrderListAfterPromote->size() : 0;
+    size_t negZOrderListSizeAfterPromote = negZOrderListAfterPromote ? negZOrderListAfterPromote->size() : 0;
+
+    size_t sizeBeforePromote = posZOrderListSizeBeforePromote + negZOrderListSizeBeforePromote;
+    size_t sizeAfterPromote = posZOrderListSizeAfterPromote + negZOrderListSizeAfterPromote;
+
+    TextStream ts;
+
+    ts << "Layer: " << this << " \"" << name() << "\", z-index: " << renderer()->style()->zIndex() << "\n";
+
+    ts << "  stacking context's paint order list BEFORE promote:\n";
+    for (size_t index = 0; index < sizeBeforePromote; index++) {
+        const RenderLayer* layerBeforePromote = getStackingOrderElementAt(posZOrderListBeforePromote.get(), negZOrderListBeforePromote.get(), FromBackground, index);
+        ts << "    " << layerBeforePromote << " \"" << layerBeforePromote->name() << "\", z-index: " << layerBeforePromote->renderer()->style()->zIndex() << "\n";
+    }
+
+    ts << "  stacking context's paint order list AFTER promote:\n";
+    for (size_t index = 0; index < sizeAfterPromote; index++) {
+        const RenderLayer* layerAfterPromote = getStackingOrderElementAt(posZOrderListAfterPromote.get(), negZOrderListAfterPromote.get(), FromBackground, index);
+        ts << "    " << layerAfterPromote << " \"" << layerAfterPromote->name() << "\", z-index: " << layerAfterPromote->renderer()->style()->zIndex() << "\n";
+    }
+
+    return ts.release();
+}
+
+PassRefPtr<PaintOrderLists> RenderLayer::paintOrderLists()
+{
+    OwnPtr<Vector<RenderLayer*> > posZOrderListBeforePromote;
+    OwnPtr<Vector<RenderLayer*> > negZOrderListBeforePromote;
+    OwnPtr<Vector<RenderLayer*> > posZOrderListAfterPromote;
+    OwnPtr<Vector<RenderLayer*> > negZOrderListAfterPromote;
+
+    RenderLayer* ancestorStackingContext = this;
+
+    while (ancestorStackingContext) {
+        if (ancestorStackingContext != this && ancestorStackingContext->isStackingContext())
+            break;
+        ancestorStackingContext = ancestorStackingContext->parent();
+    }
+
+    if (!ancestorStackingContext)
+        return 0;
+
+    getPaintOrderLists(ancestorStackingContext,
+        posZOrderListBeforePromote, negZOrderListBeforePromote,
+        posZOrderListAfterPromote, negZOrderListAfterPromote);
+
+    size_t posZOrderListSizeBeforePromote = posZOrderListBeforePromote ? posZOrderListBeforePromote->size() : 0;
+    size_t negZOrderListSizeBeforePromote = negZOrderListBeforePromote ? negZOrderListBeforePromote->size() : 0;
+    size_t posZOrderListSizeAfterPromote = posZOrderListAfterPromote ? posZOrderListAfterPromote->size() : 0;
+    size_t negZOrderListSizeAfterPromote = negZOrderListAfterPromote ? negZOrderListAfterPromote->size() : 0;
+
+    size_t sizeBeforePromote = posZOrderListSizeBeforePromote + negZOrderListSizeBeforePromote;
+    size_t sizeAfterPromote = posZOrderListSizeAfterPromote + negZOrderListSizeAfterPromote;
+
+    ListHashSet<RefPtr<Node> > listBeforePromote;
+    for (size_t index = 0; index < sizeBeforePromote; index++) {
+        const RenderLayer* layerBeforePromote = getStackingOrderElementAt(posZOrderListBeforePromote.get(), negZOrderListBeforePromote.get(), FromBackground, index);
+        listBeforePromote.add(layerBeforePromote->renderer()->node());
+    }
+
+    ListHashSet<RefPtr<Node> > listAfterPromote;
+    for (size_t index = 0; index < sizeAfterPromote; index++) {
+        const RenderLayer* layerAfterPromote = getStackingOrderElementAt(posZOrderListAfterPromote.get(), negZOrderListAfterPromote.get(), FromBackground, index);
+        listAfterPromote.add(layerAfterPromote->renderer()->node());
+    }
+
+    PassRefPtr<PaintOrderLists> paintOrderLists = adoptRef(new PaintOrderLists(StaticHashSetNodeList::adopt(listBeforePromote), StaticHashSetNodeList::adopt(listAfterPromote)));
+    return paintOrderLists;
+}
+
+
 void RenderLayer::computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* geometryMap)
 {
     ASSERT(!m_visibleContentStatusDirty);
 
     m_repaintRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
     m_outlineBox = renderer()->outlineBoundsForRepaint(repaintContainer, geometryMap);
 }
 
 
 void RenderLayer::computeRepaintRectsIncludingDescendants()
@@ skipping 598 matching lines @@
 RenderLayer* RenderLayer::stackingContainer() const
 {
     RenderLayer* layer = parent();
     while (layer && !layer->isStackingContainer())
         layer = layer->parent();
 
     ASSERT(!layer || layer->isStackingContainer());
     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();
 }
 
 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
 {
     RenderLayer* curr = parent();
     while (curr && !isPositionedContainer(curr))
         curr = curr->parent();
@@ skipping 4242 matching lines @@
 }
 
 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)
+void RenderLayer::rebuildZOrderLists(CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*> >& posZOrderList, OwnPtr<Vector<RenderLayer*> >& negZOrderList, const RenderLayer* layerToForceAsStackingContext)
 {
     bool includeHiddenLayers = compositor()->inCompositingMode();
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         if (!m_reflection || reflectionLayer() != child)
-            child->collectLayers(includeHiddenLayers, behavior, posZOrderList, negZOrderList);
+            child->collectLayers(includeHiddenLayers, behavior, posZOrderList, negZOrderList, layerToForceAsStackingContext);
 
     // Sort the two lists.
     if (posZOrderList)
         std::stable_sort(posZOrderList->begin(), posZOrderList->end(), compareZIndex);
 
     if (negZOrderList)
         std::stable_sort(negZOrderList->begin(), negZOrderList->end(), compareZIndex);
 
 #if ENABLE(DIALOG_ELEMENT)
     // Append layers for top layer elements after normal layer collection, to ensure they are on top regardless of z-indexes.
@@ skipping 24 matching lines @@
         if (child->isNormalFlowOnly() && (!m_reflection || reflectionLayer() != child)) {
             if (!m_normalFlowList)
                 m_normalFlowList = adoptPtr(new Vector<RenderLayer*>);
             m_normalFlowList->append(child);
         }
     }
     
     m_normalFlowListDirty = false;
 }
 
-void RenderLayer::collectLayers(bool includeHiddenLayers, CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*> >& posBuffer, OwnPtr<Vector<RenderLayer*> >& negBuffer)
+void RenderLayer::collectLayers(bool includeHiddenLayers, CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*> >& posBuffer, OwnPtr<Vector<RenderLayer*> >& negBuffer, const RenderLayer* layerToForceAsStackingContext)
 {
 #if ENABLE(DIALOG_ELEMENT)
     if (isInTopLayer())
         return;
 #endif
 
     updateDescendantDependentFlags();
 
-    bool isStacking = behavior == StopAtStackingContexts ? isStackingContext() : isStackingContainer();
+    bool isStacking = (this == layerToForceAsStackingContext) || (behavior == StopAtStackingContexts ? isStackingContext() : isStackingContainer());
     // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
     bool includeHiddenLayer = includeHiddenLayers || (m_hasVisibleContent || (m_hasVisibleDescendant && isStacking));
     if (includeHiddenLayer && !isNormalFlowOnly() && !isOutOfFlowRenderFlowThread()) {
         // Determine which buffer the child should be in.
         OwnPtr<Vector<RenderLayer*> >& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
 
         // Create the buffer if it doesn't exist yet.
         if (!buffer)
             buffer = adoptPtr(new Vector<RenderLayer*>);
         
         // Append ourselves at the end of the appropriate buffer.
         buffer->append(this);
     }
 
     // Recur into our children to collect more layers, but only if we don't establish
     // a stacking context/container.
     if ((includeHiddenLayers || m_hasVisibleDescendant) && !isStacking) {
         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
             // Ignore reflections.
             if (!m_reflection || reflectionLayer() != child)
-                child->collectLayers(includeHiddenLayers, behavior, posBuffer, negBuffer);
+                child->collectLayers(includeHiddenLayers, behavior, posBuffer, negBuffer, layerToForceAsStackingContext);
         }
     }
 }
 
 void RenderLayer::updateLayerListsIfNeeded()
 {
     bool shouldUpdateDescendantsAreContiguousInStackingOrder = isStackingContext() && (m_zOrderListsDirty || m_normalFlowListDirty);
     updateZOrderLists();
     updateNormalFlowList();
 
@@ skipping 703 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif