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_normalFlowCurrent = 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_normalFlowCurrent; m_normalFlowCurrent = m_normalFlowCurrent->nextSibling()) {
+            if (!m_normalFlowCurrent->stackingNode()->isTreatedAsStackingContextForPainting() && (!m_root.layer()->reflectionInfo() || m_root.layer()->reflectionInfo()->reflectionLayer() != m_normalFlowCurrent)) {

[dsinclair, 2015/06/24 15:22:42]

Can this condition be pulled out into a local isNormalFlowChild method since
it's repeated below?

[Julien - ping for review, 2015/06/24 16:51:57]

I did something even better:

(!m_root.layer()->reflectionInfo() ||
m_root.layer()->reflectionInfo()->reflectionLayer() != m_normalFlowCurrent) is
equivalent to !m_normalFlowCurrent->isReflection()

so no need for a new function

+                DeprecatedPaintLayer* normalFlowChild = m_normalFlowCurrent;
+                m_normalFlowCurrent = m_normalFlowCurrent->nextSibling();
+                return normalFlowChild->stackingNode();
+            }
+        }
 
-        m_index = 0;
+        // We reset the iterator in case we reuse it.
+        m_normalFlowCurrent = m_root.layer()->firstChild();
         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_normalFlowCurrent; m_normalFlowCurrent = m_normalFlowCurrent->previousSibling()) {
+            if (!m_normalFlowCurrent->stackingNode()->isTreatedAsStackingContextForPainting() && (!m_root.layer()->reflectionInfo() || m_root.layer()->reflectionInfo()->reflectionLayer() != m_normalFlowCurrent)) {
+                DeprecatedPaintLayer* normalFlowChild = m_normalFlowCurrent;
+                m_normalFlowCurrent = m_normalFlowCurrent->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_normalFlowCurrent = 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