Rename isTreatedAsOrStackingContext to isStacked

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 1266 matching lines @@
     void setInsideLink(EInsideLink insideLink) { inherited_flags._insideLink = insideLink; }
     void setIsLink(bool b) { noninherited_flags.isLink = b; }
 
     PrintColorAdjust getPrintColorAdjust() const { return static_cast<PrintColorAdjust>(inherited_flags.m_printColorAdjust); }
     void setPrintColorAdjust(PrintColorAdjust value) { inherited_flags.m_printColorAdjust = value; }
 
     // A stacking context is painted atomically and defines a stacking order, whereas
     // a containing stacking context defines in which order the stacking contexts
     // below are painted. In Blink, a stacking context is defined by non-auto
     // z-index'. This invariant is enforced by the logic in StyleAdjuster
-    // See CSS 2.1, Appendix E for more details.
+    // See CSS 2.1, Appendix E (https://www.w3.org/TR/CSS21/zindex.html) for more details.
     bool isStackingContext() const { return !hasAutoZIndex(); }
 
-    // Some elements are "treated as if they create a new stacking context" for
-    // the purpose of painting and hit testing. This means that they are painted
-    // atomically (like a stacking context) but they don't determine the
-    // stacking of the elements underneath them (stacking contexts or elements
-    // "treated as stacking context"). See PaintLayerStackingNode for
-    // more about painting order.
-    bool isTreatedAsStackingContext() const
-    {
-        // FIXME: Floating objects are also considered stacking contexts.
-        return position() != StaticPosition;
-    }
-
-    // Returns true if  an element is a stacking context or "treated as a
-    // stacking context". Most callers care about this as it follows the
-    // painting order where we collect anything that returns true from this
-    // function under the enclosing stacking context.
-    bool isTreatedAsOrStackingContext() const
-    {
-        return isStackingContext() || isTreatedAsStackingContext();
-    }
+    // 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().)
+    bool isStacked() const { return isStackingContext() || position() != StaticPosition; }
 
     bool hasAutoZIndex() const { return m_box->hasAutoZIndex(); }
     void setHasAutoZIndex() { SET_VAR(m_box, m_hasAutoZIndex, true); SET_VAR(m_box, m_zIndex, 0); }
     int zIndex() const { return m_box->zIndex(); }
     void setZIndex(int v) { SET_VAR(m_box, m_hasAutoZIndex, false); SET_VAR(m_box, m_zIndex, v); }
 
     void setHasAutoWidows() { SET_VAR(rareInheritedData, widows, initialWidows()); }
     void setWidows(short w) { SET_VAR(rareInheritedData, widows, w); }
 
     void setHasAutoOrphans() { SET_VAR(rareInheritedData, m_hasAutoOrphans, true); SET_VAR(rareInheritedData, orphans, initialOrphans()); }
@@ skipping 731 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return noninherited_flags.pseudoBits & ElementPseudoIdMask;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h