Compute the normal flow list on the fly

Source/core/paint/DeprecatedPaintLayerStackingNodeIterator.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/paint/DeprecatedPaintLayerStackingNodeIterator.h"
 
+// FIXME: We should build our primitive on top of
+// DeprecatedLayerStackingNode and remove this include.
+#include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/DeprecatedPaintLayerStackingNode.h"
 
 namespace blink {
 
+DeprecatedPaintLayerStackingNodeIterator::DeprecatedPaintLayerStackingNodeIterator(const DeprecatedPaintLayerStackingNode& root, unsigned whichChildren)
+    : m_root(root)
+    , m_remainingChildren(whichChildren)
+    , m_index(0)
+{
+    m_currentNormalFlowChild = root.layer()->firstChild();
+}
+
 DeprecatedPaintLayerStackingNode* DeprecatedPaintLayerStackingNodeIterator::next()
 {
     if (m_remainingChildren & NegativeZOrderChildren) {
         Vector<DeprecatedPaintLayerStackingNode*>* negZOrderList = m_root.negZOrderList();
         if (negZOrderList && m_index < negZOrderList->size())
             return negZOrderList->at(m_index++);
 
         m_index = 0;
         m_remainingChildren &= ~NegativeZOrderChildren;
     }
 
     if (m_remainingChildren & NormalFlowChildren) {
-        Vector<DeprecatedPaintLayerStackingNode*>* normalFlowList = m_root.normalFlowList();
-        if (normalFlowList && m_index < normalFlowList->size())
-            return normalFlowList->at(m_index++);
+        for (; m_currentNormalFlowChild; m_currentNormalFlowChild = m_currentNormalFlowChild->nextSibling()) {
+            if (!m_currentNormalFlowChild->stackingNode()->isTreatedAsStackingContextForPainting() && !m_currentNormalFlowChild->isReflection()) {
+                DeprecatedPaintLayer* normalFlowChild = m_currentNormalFlowChild;
+                m_currentNormalFlowChild = m_currentNormalFlowChild->nextSibling();
+                return normalFlowChild->stackingNode();
+            }
+        }
 
-        m_index = 0;
+        // We reset the iterator in case we reuse it.
+        m_currentNormalFlowChild = m_root.layer()->firstChild();

[chrishtr, 2015/06/24 23:07:55]

Is this functionality actually used? I don't think stl iterators work this way.

[Julien - ping for review, 2015/06/24 23:13:57]

It's not used no. For consistency with the other cases that reset m_index to 0,
I reset this value.

If you prefer I can skip resetting it.

[chrishtr, 2015/06/24 23:36:30]

It seems weird as written. Because you can call next() one more time after
getting a null return value, it'll loop around. Maybe set it to nullptr and
ASSERT that next() is never called again?

[Julien - ping for review, 2015/06/25 17:16:24]

It won't loop around as we remove normal flow children from m_remainingChildren
the line below. Where did you see that next() would return nullptr then a value?
(that would be a definite bug!)

It's more like if you re-add normal the flow list to the iterator, it would just
work (tm). This is not possible right now though so it's a moot point.

[chrishtr, 2015/06/25 17:20:49]

If you call next() and it's already at the end, then won't line 83 execute and
return nullptr?

[chrishtr, 2015/06/25 20:38:19]

I see now. (Julien explained offline). LGTM

         m_remainingChildren &= ~NormalFlowChildren;
     }
 
     if (m_remainingChildren & PositiveZOrderChildren) {
         Vector<DeprecatedPaintLayerStackingNode*>* posZOrderList = m_root.posZOrderList();
         if (posZOrderList && m_index < posZOrderList->size())
             return posZOrderList->at(m_index++);
 
         m_index = 0;
         m_remainingChildren &= ~PositiveZOrderChildren;
     }
 
     return 0;
 }
 
 DeprecatedPaintLayerStackingNode* DeprecatedPaintLayerStackingNodeReverseIterator::next()
 {
     if (m_remainingChildren & NegativeZOrderChildren) {
         Vector<DeprecatedPaintLayerStackingNode*>* negZOrderList = m_root.negZOrderList();
         if (negZOrderList && m_index >= 0)
             return negZOrderList->at(m_index--);
 
         m_remainingChildren &= ~NegativeZOrderChildren;
         setIndexToLastItem();
     }
 
     if (m_remainingChildren & NormalFlowChildren) {
-        Vector<DeprecatedPaintLayerStackingNode*>* normalFlowList = m_root.normalFlowList();
-        if (normalFlowList && m_index >= 0)
-            return normalFlowList->at(m_index--);
+        for (; m_currentNormalFlowChild; m_currentNormalFlowChild = m_currentNormalFlowChild->previousSibling()) {
+            if (!m_currentNormalFlowChild->stackingNode()->isTreatedAsStackingContextForPainting() && !m_currentNormalFlowChild->isReflection()) {
+                DeprecatedPaintLayer* normalFlowChild = m_currentNormalFlowChild;
+                m_currentNormalFlowChild = m_currentNormalFlowChild->previousSibling();
+                return normalFlowChild->stackingNode();
+            }
+        }
 
         m_remainingChildren &= ~NormalFlowChildren;
         setIndexToLastItem();
     }
 
     if (m_remainingChildren & PositiveZOrderChildren) {
         Vector<DeprecatedPaintLayerStackingNode*>* posZOrderList = m_root.posZOrderList();
         if (posZOrderList && m_index >= 0)
             return posZOrderList->at(m_index--);
 
@@ skipping 10 matching lines @@
         Vector<DeprecatedPaintLayerStackingNode*>* negZOrderList = m_root.negZOrderList();
         if (negZOrderList) {
             m_index  = negZOrderList->size() - 1;
             return;
         }
 
         m_remainingChildren &= ~NegativeZOrderChildren;
     }
 
     if (m_remainingChildren & NormalFlowChildren) {
-        Vector<DeprecatedPaintLayerStackingNode*>* normalFlowList = m_root.normalFlowList();
-        if (normalFlowList) {
-            m_index = normalFlowList->size() - 1;
-            return;
-        }
-
-        m_remainingChildren &= ~NormalFlowChildren;
+        m_currentNormalFlowChild = m_root.layer()->lastChild();
+        return;
     }
 
     if (m_remainingChildren & PositiveZOrderChildren) {
         Vector<DeprecatedPaintLayerStackingNode*>* posZOrderList = m_root.posZOrderList();
         if (posZOrderList) {
             m_index = posZOrderList->size() - 1;
             return;
         }
 
         m_remainingChildren &= ~PositiveZOrderChildren;
     }
 
     // No more list to visit.
     ASSERT(!m_remainingChildren);
     m_index = -1;
 }
 
 } // namespace blink