Rename isTreatedAsOrStackingContext to isStacked

third_party/WebKit/Source/core/paint/PaintLayerStackingNode.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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>
@@ skipping 46 matching lines @@
 class PaintLayerCompositor;
 class ComputedStyle;
 class LayoutBoxModelObject;
 
 // PaintLayerStackingNode represents anything that is a stacking
 // context or treated as a stacking context.
 //
 // Stacking contexts are the basis for the CSS painting algorithm. The paint
 // order is determined by walking stacking contexts (or elements treated like a
 // stacking context like positioned objects or floats) in an order defined by
-// ‘z-index’. This walk is interleaved with content that is not a stacking.
+// ‘z-index’. This walk is interleaved with content that is not a stacking
 // context. See CSS 2.1 appendix E for the actual algorithm
 // http://www.w3.org/TR/CSS21/zindex.html
 // See also PaintLayerPainter (in particular paintLayerContents) for
 // our implementation of the walk.
 //
 // Stacking contexts form a subtree over the layout tree. Ideally we would want
 // objects of this class to be a node in this tree but there are potential
 // issues with stale pointers so we rely on PaintLayer's tree
 // structure.
 //
@@ skipping 20 matching lines @@
 
     bool zOrderListsDirty() const { return m_zOrderListsDirty; }
     void dirtyZOrderLists();
     void updateZOrderLists();
     void clearZOrderLists();
     void dirtyStackingContextZOrderLists();
 
     bool hasPositiveZOrderList() const { return posZOrderList() && posZOrderList()->size(); }
     bool hasNegativeZOrderList() const { return negZOrderList() && negZOrderList()->size(); }
 
-    bool isTreatedAsOrStackingContext() const { return m_isTreatedAsOrStackingContext; }
-    void updateIsTreatedAsStackingContext();
+    bool isStacked() const { return m_isStacked; }
+    void updateIsStacked();
 
     void updateStackingNodesAfterStyleChange(const ComputedStyle* oldStyle);
 
     PaintLayerStackingNode* ancestorStackingContextNode() const;
 
     PaintLayer* layer() const { return m_layer; }
 
 #if ENABLE(ASSERT)
     bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
     void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
 #endif
 
+    // Stacking contexts and positioned elements[1] are stacked (sorted in negZOrderList
+    // and posZOrderList) in their enclosing stacking contexts.
+    //
+    // [1] According to CSS2.1, Appendix E.2.8 (https://www.w3.org/TR/CSS21/zindex.html),
+    // positioned elements with 'z-index: auto' are "treated as if it created a new
+    // stacking context" and z-ordered together with other elements with 'z-index: 0'.
+    // The difference of them from normal stacking contexts is that they don't determine
+    // the stacking of the elements underneath them.
+    // (Note: There are also other elements treated as stacking context during painting,
+    // but not managed in stacks. See ObjectPainter::paintAllPhasesAtomically().)

[pdr., 2016/03/16 02:22:53]

Optional, may want to add a link to the markdown too:
https://chromium.googlesource.com/chromium/src.git/+/master/third_party/WebKi...

[Xianzhu, 2016/03/16 18:10:24]

Done.

+    static bool shouldStackObject(const LayoutObject& object) { return object.styleRef().isStackingContext() || object.isPositioned(); }
+
 private:
     friend class PaintLayerStackingNodeIterator;
     friend class PaintLayerStackingNodeReverseIterator;
     friend class LayoutTreeAsText;
 
     Vector<PaintLayerStackingNode*>* posZOrderList() const
     {
         ASSERT(!m_zOrderListsDirty);
         ASSERT(isStackingContext() || !m_posZOrderList);
         return m_posZOrderList.get();
     }
 
     Vector<PaintLayerStackingNode*>* negZOrderList() const
     {
         ASSERT(!m_zOrderListsDirty);
         ASSERT(isStackingContext() || !m_negZOrderList);
         return m_negZOrderList.get();
     }
 
     void rebuildZOrderLists();
     void collectLayers(OwnPtr<Vector<PaintLayerStackingNode*>>& posZOrderList, OwnPtr<Vector<PaintLayerStackingNode*>>& negZOrderList);
 
 #if ENABLE(ASSERT)
     bool isInStackingParentZOrderLists() const;
     void updateStackingParentForZOrderLists(PaintLayerStackingNode* stackingParent);
     void setStackingParent(PaintLayerStackingNode* stackingParent) { m_stackingParent = stackingParent; }
 #endif
 
-    bool shouldBeTreatedAsOrStackingContext() const { return layoutObject()->style()->isTreatedAsOrStackingContext(); }
-
     bool isDirtyStackingContext() const { return m_zOrderListsDirty && isStackingContext(); }
 
     PaintLayerCompositor* compositor() const;
     // We can't return a LayoutBox as LayoutInline can be a stacking context.
     LayoutBoxModelObject* layoutObject() const;
 
     PaintLayer* m_layer;
 
     // m_posZOrderList holds a sorted list of all the descendant nodes within
-    // that have z-indices of 0 or greater (auto will count as 0).
+    // that have z-indices of 0 (or is treated as 0 for positioned objects) or greater.
     // m_negZOrderList holds descendants within our stacking context with
     // negative z-indices.
     OwnPtr<Vector<PaintLayerStackingNode*>> m_posZOrderList;
     OwnPtr<Vector<PaintLayerStackingNode*>> m_negZOrderList;
 
     // This boolean caches whether the z-order lists above are dirty.
     // It is only ever set for stacking contexts, as no other element can
     // have z-order lists.
     unsigned m_zOrderListsDirty : 1;
 
-    // This attribute caches whether the element was a stacking context or
-    // was treated like a stacking context, so that we can do comparison against
+    // This attribute caches whether the element was stacked, so that we can do comparison against
     // it during style change (styleDidChange in particular), as we have lost
     // the previous style information.
-    unsigned m_isTreatedAsOrStackingContext: 1;
+    unsigned m_isStacked: 1;
 
 #if ENABLE(ASSERT)
     unsigned m_layerListMutationAllowed : 1;
     PaintLayerStackingNode* m_stackingParent;
 #endif
 };
 
 inline void PaintLayerStackingNode::clearZOrderLists()
 {
     ASSERT(!isStackingContext());
@@ skipping 37 matching lines @@
 
 private:
     PaintLayerStackingNode* m_stackingNode;
     bool m_previousMutationAllowedState;
 };
 #endif
 
 } // namespace blink
 
 #endif // PaintLayerStackingNode_h