Implement will-change-based creation of layers, stacking contexts, and containing blocks

Source/core/css/resolver/StyleAdjuster.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 26 matching lines @@
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/rendering/RenderTheme.h"
 #include "core/rendering/style/GridPosition.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "core/rendering/style/RenderStyleConstants.h"
 #include "platform/Length.h"
+#include "platform/transforms/TransformOperations.h"
 #include "wtf/Assertions.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // FIXME: This is duplicated with StyleResolver.cpp
 // Perhaps this should move onto ElementResolveContext or even Element?
 static inline bool isAtShadowBoundary(const Element* element)
 {
@@ skipping 94 matching lines @@
 static bool isDisplayGridBox(EDisplay display)
 {
     return display == GRID || display == INLINE_GRID;
 }
 
 static bool parentStyleForcesZIndexToCreateStackingContext(const RenderStyle* parentStyle)
 {
     return isDisplayFlexibleBox(parentStyle->display()) || isDisplayGridBox(parentStyle->display());
 }
 
+static bool hasWillChangeThatCreatesStackingContext(const RenderStyle* style, Element* e)
+{
+    for (size_t i = 0; i < style->willChangeProperties().size(); ++i) {
+        switch (style->willChangeProperties()[i]) {
+        case CSSPropertyOpacity:
+        case CSSPropertyWebkitTransform:
+        case CSSPropertyWebkitTransformStyle:
+        case CSSPropertyWebkitPerspective:
+        case CSSPropertyWebkitMask:
+        case CSSPropertyWebkitMaskBoxImage:
+        case CSSPropertyWebkitClipPath:
+        case CSSPropertyWebkitBoxReflect:
+        case CSSPropertyWebkitFilter:
+        case CSSPropertyZIndex:

[Ian Vollick, 2014/02/26 16:21:12]

z-index only creates a sc if the element is also positioned.

I wonder if we need to change the logic so that
will-change: z-index ==> sc if positioned or will-change: position,
and
will-change: position ==> sc if z-index != auto or will-change: z-index.

Chatting offline with Ali about this seemed to suggest some ambiguity in the
spec. Will need to follow up with Tab.

[ajuma, 2014/02/26 17:00:30]

I took a look at what Mozilla's implementation does
(https://bugzilla.mozilla.org/attachment.cgi?id=8378525&action=diff), and it
turns out that they unconditionally create stacking contexts for will-change:
z-index and will-change: position. This seems reasonable to me (given that I
don't expect these particular values of will-change to be widely used, keeping
the implementation simple makes sense), so I've updated this CL so that we also
unconditionally create a stacking context for will-change: position. I'll follow
up with Tab about getting the spec updated to clarify this.

+            return true;
+        case CSSPropertyMixBlendMode:
+        case CSSPropertyIsolation:
+            if (RuntimeEnabledFeatures::cssCompositingEnabled())
+                return true;
+            break;
+        case CSSPropertyPosition:
+            if (RuntimeEnabledFeatures::cssStickyPositionEnabled()
+                || (e && e->document().settings() && e->document().settings()->fixedPositionCreatesStackingContext()))
+                return true;
+            break;
+        default:
+            break;
+        }
+    }
+    return false;
+}
+
 void StyleAdjuster::adjustRenderStyle(RenderStyle* style, RenderStyle* parentStyle, Element *e)
 {
     ASSERT(parentStyle);
 
     // Cache our original display.
     style->setOriginalDisplay(style->display());
 
     if (style->display() != NONE) {
         // If we have a <td> that specifies a float property, in quirks mode we just drop the float
         // property.
@@ skipping 97 matching lines @@
         || style->hasTransformRelatedProperty()
         || style->hasMask()
         || style->clipPath()
         || style->boxReflect()
         || style->hasFilter()
         || style->hasBlendMode()
         || style->hasIsolation()
         || style->position() == StickyPosition
         || (style->position() == FixedPosition && e && e->document().settings() && e->document().settings()->fixedPositionCreatesStackingContext())
         || isInTopLayer(e, style)
+        || hasWillChangeThatCreatesStackingContext(style, e)
         ))
         style->setZIndex(0);
 
+    // will-change:transform should result in the same rendering behavior as having a transform,
+    // including the creation of a containing block for fixed position descendants.
+    if (!style->hasTransform() && style->willChangeProperties().contains(CSSPropertyWebkitTransform))
+        style->setTransform(TransformOperations(true));
+
     // Textarea considers overflow visible as auto.
     if (e && e->hasTagName(textareaTag)) {
         style->setOverflowX(style->overflowX() == OVISIBLE ? OAUTO : style->overflowX());
         style->setOverflowY(style->overflowY() == OVISIBLE ? OAUTO : style->overflowY());
     }
 
     // For now, <marquee> requires an overflow clip to work properly.
     if (e && e->hasTagName(marqueeTag)) {
         style->setOverflowX(OHIDDEN);
         style->setOverflowY(OHIDDEN);
@@ skipping 111 matching lines @@
     if (prop.isNamedGridArea() && !map.contains(prop.namedGridLine())) \
         style->setGrid##Prop(GridPosition());
 
     CLEAR_UNKNOWN_NAMED_AREA(columnStartPosition, ColumnStart);
     CLEAR_UNKNOWN_NAMED_AREA(columnEndPosition, ColumnEnd);
     CLEAR_UNKNOWN_NAMED_AREA(rowStartPosition, RowStart);
     CLEAR_UNKNOWN_NAMED_AREA(rowEndPosition, RowEnd);
 }
 
 }