Avoid touching z-index in StyleAdjuster by using an isStackingContext flag instead

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

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 536 matching lines @@
             return true;
 
         // If the counter directives change, trigger a relayout to re-calculate counter values and rebuild the counter node tree.
         const CounterDirectiveMap* mapA = rareNonInheritedData->m_counterDirectives.get();
         const CounterDirectiveMap* mapB = other.rareNonInheritedData->m_counterDirectives.get();
         if (!(mapA == mapB || (mapA && mapB && *mapA == *mapB)))
             return true;
 
         // We only need do layout for opacity changes if adding or losing opacity could trigger a change
         // in us being a stacking context.
-        if (hasAutoZIndex() != other.hasAutoZIndex() && rareNonInheritedData->hasOpacity() != other.rareNonInheritedData->hasOpacity()) {
+        if (isStackingContext() != other.isStackingContext() && rareNonInheritedData->hasOpacity() != other.rareNonInheritedData->hasOpacity()) {
             // FIXME: We would like to use SimplifiedLayout here, but we can't quite do that yet.
             // We need to make sure SimplifiedLayout can operate correctly on LayoutInlines (we will need
             // to add a selfNeedsSimplifiedLayout bit in order to not get confused and taint every line).
             // In addition we need to solve the floating object issue when layers come and go. Right now
             // a full layout is necessary to keep floating object lists sane.
             return true;
         }
     }
 
     if (rareInheritedData.get() != other.rareInheritedData.get()) {
@@ skipping 238 matching lines @@
             if (!dataEquivalent(thisVar, otherVar))
                 return true;
         }
     }
 
     return false;
 }
 
 void ComputedStyle::updatePropertySpecificDifferences(const ComputedStyle& other, StyleDifference& diff) const
 {
-    // StyleAdjuster has ensured that zIndex is non-auto only if it's applicable.
-    if (m_box->zIndex() != other.m_box->zIndex() || m_box->hasAutoZIndex() != other.m_box->hasAutoZIndex())
+    if (m_box->zIndex() != other.m_box->zIndex() || isStackingContext() != other.isStackingContext())
         diff.setZIndexChanged();
 
     if (rareNonInheritedData.get() != other.rareNonInheritedData.get()) {
         if (!transformDataEquivalent(other))
             diff.setTransformChanged();
 
         if (rareNonInheritedData->opacity != other.rareNonInheritedData->opacity)
             diff.setOpacityChanged();
 
         if (rareNonInheritedData->m_filter != other.rareNonInheritedData->m_filter)
@@ skipping 60 matching lines @@
 {
     rareInheritedData.access()->quotes = q;
 }
 
 void ComputedStyle::clearCursorList()
 {
     if (rareInheritedData->cursorData)
         rareInheritedData.access()->cursorData = nullptr;
 }
 
+static bool hasPropertyThatCreatesStackingContext(const Vector<CSSPropertyID>& properties)
+{
+    for (CSSPropertyID property : properties) {
+        switch (property) {
+        case CSSPropertyOpacity:
+        case CSSPropertyTransform:
+        case CSSPropertyAliasWebkitTransform:
+        case CSSPropertyTransformStyle:
+        case CSSPropertyAliasWebkitTransformStyle:
+        case CSSPropertyPerspective:
+        case CSSPropertyAliasWebkitPerspective:
+        case CSSPropertyWebkitMask:
+        case CSSPropertyWebkitMaskBoxImage:
+        case CSSPropertyWebkitClipPath:
+        case CSSPropertyWebkitBoxReflect:
+        case CSSPropertyFilter:
+        case CSSPropertyAliasWebkitFilter:
+        case CSSPropertyBackdropFilter:
+        case CSSPropertyZIndex:
+        case CSSPropertyPosition:
+        case CSSPropertyMixBlendMode:
+        case CSSPropertyIsolation:
+            return true;
+        default:
+            break;
+        }
+    }
+    return false;
+}
+
+void ComputedStyle::updateIsStackingContext(bool isDocumentElement, bool isInTopLayer)
+{
+    if (isStackingContext())
+        return;
+
+    if (isDocumentElement
+        || isInTopLayer
+        || styleType() == PseudoIdBackdrop
+        || hasOpacity()
+        || hasTransformRelatedProperty()
+        || hasMask()
+        || clipPath()
+        || boxReflect()
+        || hasFilterInducingProperty()
+        || hasBlendMode()
+        || hasIsolation()
+        || hasViewportConstrainedPosition()
+        || hasPropertyThatCreatesStackingContext(willChangeProperties())
+        || containsPaint()) {
+        setIsStackingContext(true);
+    }
+}
+
 void ComputedStyle::addCallbackSelector(const String& selector)
 {
     if (!rareNonInheritedData->m_callbackSelectors.contains(selector))
         rareNonInheritedData.access()->m_callbackSelectors.append(selector);
 }
 
 void ComputedStyle::setContent(ContentData* contentData)
 {
     SET_VAR(rareNonInheritedData, m_content, contentData);
 }
@@ skipping 966 matching lines @@
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 } // namespace blink