Rename isNormalFlowOnly to something meaningful

Source/core/paint/DeprecatedPaintLayer.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 465 matching lines @@
     // Each paginated layer has to paint on its own. There is no recurring into child layers. Each
     // layer has to be checked individually and genuinely know if it is going to have to split
     // itself up when painting only its contents (and not any other descendant layers). We track an
     // enclosingPaginationLayer instead of using a simple bit, since we want to be able to get back
     // to that layer easily.
     if (layoutObject()->isLayoutFlowThread()) {
         m_enclosingPaginationLayer = this;
         return;
     }
 
-    if (m_stackingNode->isNormalFlowOnly()) {
+    if (!m_stackingNode->isTreatedAsStackingContextForPainting()) {
         // We cannot take the fast path for spanners, as they do not have their nearest ancestor
         // pagination layer (flow thread) in their containing block chain.
         if (!layoutObject()->isColumnSpanAll()) {
             // Content inside a transform is not considered to be paginated, since we simply
             // paint the transform multiple times in each column, so we don't have to use
             // fragments for the transformed content.
             m_enclosingPaginationLayer = parent()->enclosingPaginationLayer();
             if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransformRelatedProperty())
                 m_enclosingPaginationLayer = 0;
             return;
@@ skipping 389 matching lines @@
 
     TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
     // FIXME: add a test that checks flipped writing mode and ApplyContainerFlip are correct.
     layoutObject()->mapLocalToContainer(properties.transformAncestor ? properties.transformAncestor->layoutObject() : 0, transformState, ApplyContainerFlip);
     transformState.flatten();
     return LayoutPoint(transformState.lastPlanarPoint());
 }
 
 const DeprecatedPaintLayer* DeprecatedPaintLayer::compositingContainer() const
 {
-    if (stackingNode()->isNormalFlowOnly())
+    if (!stackingNode()->isTreatedAsStackingContextForPainting())
         return parent();
     if (DeprecatedPaintLayerStackingNode* ancestorStackingNode = stackingNode()->ancestorStackingContextNode())
         return ancestorStackingNode->layer();
     return 0;
 }
 
 bool DeprecatedPaintLayer::isPaintInvalidationContainer() const
 {
     return compositingState() == PaintsIntoOwnBacking || compositingState() == PaintsIntoGroupedBacking;
 }
@@ skipping 236 matching lines @@
         child->setNextSibling(beforeChild);
         ASSERT(beforeChild != child);
     } else {
         setLastChild(child);
     }
 
     child->m_parent = this;
 
     setNeedsCompositingInputsUpdate();
 
-    if (child->stackingNode()->isNormalFlowOnly())
+    if (!child->stackingNode()->isTreatedAsStackingContextForPainting())
         m_stackingNode->dirtyNormalFlowList();
 
-    if (!child->stackingNode()->isNormalFlowOnly() || child->firstChild()) {
+    if (child->stackingNode()->isTreatedAsStackingContextForPainting() || child->firstChild()) {
         // Dirty the z-order list in which we are contained. The ancestorStackingContextNode() 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->stackingNode()->dirtyStackingContextZOrderLists();
     }
 
     dirtyAncestorChainVisibleDescendantStatus();
     dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     child->updateDescendantDependentFlags();
 }
 
 DeprecatedPaintLayer* DeprecatedPaintLayer::removeChild(DeprecatedPaintLayer* oldChild)
 {
     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();
 
-    if (oldChild->stackingNode()->isNormalFlowOnly())
+    if (!oldChild->stackingNode()->isTreatedAsStackingContextForPainting())
         m_stackingNode->dirtyNormalFlowList();
-    if (!oldChild->stackingNode()->isNormalFlowOnly() || oldChild->firstChild()) {
+    if (oldChild->stackingNode()->isTreatedAsStackingContextForPainting() || 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
         // |stackingContext| value.
         oldChild->stackingNode()->dirtyStackingContextZOrderLists();
     }
 
     if (layoutObject()->style()->visibility() != VISIBLE)
         dirtyVisibleContentStatus();
 
@@ skipping 1349 matching lines @@
         m_scrollableArea->updateAfterStyleChange(oldStyle);
 
     return true;
 }
 
 void DeprecatedPaintLayer::styleChanged(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     if (attemptDirectCompositingUpdate(diff, oldStyle))
         return;
 
-    m_stackingNode->updateIsNormalFlowOnly();
+    m_stackingNode->updateIsTreatedAsStackingContextForPainting();
     m_stackingNode->updateStackingNodesAfterStyleChange(oldStyle);
 
     if (m_scrollableArea)
         m_scrollableArea->updateAfterStyleChange(oldStyle);
 
     // Overlay scrollbars can make this layer self-painting so we need
     // to recompute the bit once scrollbars have been updated.
     updateSelfPaintingLayer();
 
     if (!oldStyle || !layoutObject()->style()->reflectionDataEquivalent(oldStyle)) {
@@ skipping 148 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif