Changeset 177200 in webkit


Ignore:
Timestamp:
Dec 11, 2014, 5:59:37 PM (10 years ago)
Author:
Simon Fraser
Message:

Transform-style should not kill position:fixed
​https://bugs.webkit.org/show_bug.cgi?id=138122

Reviewed by Dean Jackson.

Source/WebCore:

Various bits of rendering code checked RenderObject::hasTransform() for various
reasons. Confusingly, this meant "has transform, or preserve-3d, or perspective".

This patch teases those behaviors apart to produce the following behavior:

  1. "transform" acts as containing block for fixed position (no behavior change).
  2. "transform" acts as containing block for absolute/relative position (no behavior change).
  3. "perspective" does not act as containing block for fixed position (no behavior change).
  4. "perspective" acts as containing block for absolute/relative position (no behavior change).
  5. "preserve-3d" does not act as containing block for fixed position (behavior change).
  6. "preserve-3d" acts as containing block for absolute/relative position. This is not a

behavior change, but seems like incorrect behavior (​https://www.w3.org/Bugs/Public/show_bug.cgi?id=27566).
However, we may be forced to keep it for compatibility.

The gist of the change is to rename RenderObject::hasTransform() to RenderObject::hasTransformRelatedProperty(),
and add hasTransform() with the more restrictive meaning. All call sites of hasTransform() were examined
and fixed to produce the desired behaviors.

Tests: transforms/2d/perspective-not-fixed-container.html

transforms/2d/preserve3d-not-fixed-container.html
transforms/perspective-is-containing-block-for-absolute.html
transforms/preserve3d-is-containing-block-for-absolute.html
transforms/transform-is-containing-block-for-absolute.html

  • css/CSSComputedStyleDeclaration.cpp:

(WebCore::computedTransform): Now we can just test hasTransform().

  • rendering/LogicalSelectionOffsetCaches.h:

(WebCore::isContainingBlockCandidateForAbsolutelyPositionedObject): For now, this
can just use hasTransformRelatedProperty(), but if we change [6] above this will have
to change (as documented in the comment). Also FIXME comments about sharing code.

  • rendering/RenderBox.cpp:

(WebCore::RenderBox::updateFromStyle):
(WebCore::RenderBox::mapLocalToContainer): Can just use hasTransform() now.
(WebCore::RenderBox::pushMappingToContainer): Ditto.
(WebCore::RenderBox::mapAbsoluteToLocalPoint): Ditto.
(WebCore::RenderBox::layoutOverflowRectForPropagation): Ditto.

  • rendering/RenderBox.h: All transform-related properties create RenderLayers.
  • rendering/RenderBoxModelObject.h: Ditto.
  • rendering/RenderElement.cpp:

(WebCore::RenderElement::styleWillChange):

  • rendering/RenderGeometryMap.cpp:

(WebCore::canMapBetweenRenderersViaLayers): Rename to clarify. We need to not map via
layers if we have a perspective (since we need to generate a perspective matrix). It's
OK with preserve-3d though.
(WebCore::RenderGeometryMap::pushMappingsToAncestor):
(WebCore::canMapBetweenRenderers): Deleted.

  • rendering/RenderInline.cpp:

(WebCore::RenderInline::updateFromStyle):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::updateTransform): Can just check hasTransform().
(WebCore::RenderLayer::updateLayerPosition): Avoid calling parent() and enclosingPositionedAncestor() twice.
(WebCore::RenderLayer::perspectiveTransform): Do the fast bit check hasTransformRelatedProperty() first.
(WebCore::RenderLayer::perspectiveOrigin): Ditto.
(WebCore::isContainerForPositioned): This code has to now have different behavior for absolute and fixed
position. Changed it to call existing functions, rather than having a 3rd place that has to know about
containing block rules.
(WebCore::RenderLayer::enclosingAncestorForPosition): Call isContainerForPositioned() now.
(WebCore::accumulateOffsetTowardsAncestor): Call enclosingAncestorForPosition().
(WebCore::RenderLayer::createLocalTransformState):
(WebCore::RenderLayer::calculateClipRects):
(WebCore::isPositionedContainer): Deleted.
(WebCore::isFixedPositionedContainer): Deleted.
(WebCore::RenderLayer::enclosingPositionedAncestor): Deleted.

  • rendering/RenderLayer.h:
  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::updateGeometry):

  • rendering/RenderLayerModelObject.cpp:

(WebCore::RenderLayerModelObject::styleDidChange):

  • rendering/RenderObject.cpp:

(WebCore::RenderObject::shouldUseTransformFromContainer): Can just check hasTransform() now.
(WebCore::RenderObject::container):

  • rendering/RenderObject.h:

(WebCore::RenderObject::hasTransformRelatedProperty):
(WebCore::RenderObject::hasTransform):
(WebCore::RenderObject::setHasTransformRelatedProperty):
(WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
(WebCore::RenderObject::setHasTransform): Deleted.

  • rendering/RenderTableRow.h:
  • rendering/RenderView.cpp:

(WebCore::RenderView::mapLocalToContainer): nullptr goodness.
(WebCore::RenderView::pushMappingToContainer): Ditto.
(WebCore::RenderView::mapAbsoluteToLocalPoint): Ditto.

LayoutTests:

New tests and updated results:

  • platform/mac/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt: Progression, caused

by RenderLayerBacking::updateCompositedBounds() now allowing shouldClipCompositedBounds on
preserve-3d layers, since they are no longer considered to have a transform.

  • platform/mac/compositing/visible-rect/3d-transform-style-expected.txt: Ditto.
  • transforms/2d/perspective-not-fixed-container-expected.html: Added.
  • transforms/2d/perspective-not-fixed-container.html: Added. Tests that

perspective does not act as containing block for fixed position (not a behavior change).

  • transforms/2d/preserve3d-not-fixed-container-expected.html: Added.
  • transforms/2d/preserve3d-not-fixed-container.html: Added. Tests that

preserve3d does not act as containing block for fixed position. This is a behavior change.

  • transforms/perspective-is-containing-block-for-absolute-expected.html: Added.
  • transforms/perspective-is-containing-block-for-absolute.html: Added. Tests that

perspective is a as containing block for absolute/relative position. This is not a behavior change.

  • transforms/preserve3d-is-containing-block-for-absolute-expected.html: Added.
  • transforms/preserve3d-is-containing-block-for-absolute.html: Added. Tests that

preserve3d is a as containing block for absolute/relative position. This is not a behavior change,
but seems like incorrect behavior for now.

  • transforms/transform-is-containing-block-for-absolute-expected.html: Added.
  • transforms/transform-is-containing-block-for-absolute.html: Added. Tests that

transform is a as containing block for absolute/relative position. This is not a behavior change.

Location:
trunk
Files:
10 added
26 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/LayoutTests/ChangeLog

    r177194 r177200  
     12014-12-11  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Transform-style should not kill position:fixed
     4        https://bugs.webkit.org/show_bug.cgi?id=138122
     5
     6        Reviewed by Dean Jackson.
     7       
     8        New tests and updated results:
     9
     10        * platform/mac/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt: Progression, caused
     11        by RenderLayerBacking::updateCompositedBounds() now allowing shouldClipCompositedBounds on
     12        preserve-3d layers, since they are no longer considered to have a transform.
     13        * platform/mac/compositing/visible-rect/3d-transform-style-expected.txt: Ditto.
     14        * transforms/2d/perspective-not-fixed-container-expected.html: Added.
     15        * transforms/2d/perspective-not-fixed-container.html: Added. Tests that
     16        perspective does not act as containing block for fixed position (not a behavior change).
     17        * transforms/2d/preserve3d-not-fixed-container-expected.html: Added.
     18        * transforms/2d/preserve3d-not-fixed-container.html: Added. Tests that
     19        preserve3d does not act as containing block for fixed position. This is a behavior change.
     20        * transforms/perspective-is-containing-block-for-absolute-expected.html: Added.
     21        * transforms/perspective-is-containing-block-for-absolute.html: Added. Tests that
     22        perspective is a as containing block for absolute/relative position. This is not a behavior change.
     23        * transforms/preserve3d-is-containing-block-for-absolute-expected.html: Added.
     24        * transforms/preserve3d-is-containing-block-for-absolute.html: Added. Tests that
     25        preserve3d is a as containing block for absolute/relative position. This is not a behavior change,
     26        but seems like incorrect behavior for now.
     27        * transforms/transform-is-containing-block-for-absolute-expected.html: Added.
     28        * transforms/transform-is-containing-block-for-absolute.html: Added. Tests that
     29        transform is a as containing block for absolute/relative position. This is not a behavior change.
     30
    1312014-12-11  Roger Fong  <roger_fong@apple.com>
    232

  • TabularUnified trunk/LayoutTests/platform/ios-simulator-wk2/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt

    r177052 r177200  
    2828              (children 1
    2929                (GraphicsLayer
    30                   (bounds 500.00 0.00)
    3130                  (preserves3D 1)
    3231                  (visible rect 0.00, 0.00 0.00 x 0.00)

  • TabularUnified trunk/LayoutTests/platform/ios-simulator/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt

    r176113 r177200  
    2828              (children 1
    2929                (GraphicsLayer
    30                   (bounds 500.00 0.00)
    3130                  (preserves3D 1)
    3231                  (visible rect 0.00, 0.00 0.00 x 0.00)

  • TabularUnified trunk/LayoutTests/platform/mac-wk2/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt

    r169278 r177200  
    2828              (children 1
    2929                (GraphicsLayer
    30                   (bounds 500.00 0.00)
    3130                  (preserves3D 1)
    3231                  (visible rect 0.00, 0.00 0.00 x 0.00)

  • TabularUnified trunk/LayoutTests/platform/mac/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt

    r169229 r177200  
    2525              (children 1
    2626                (GraphicsLayer
    27                   (bounds 500.00 0.00)
    2827                  (preserves3D 1)
    2928                  (visible rect 0.00, 0.00 0.00 x 0.00)

  • TabularUnified trunk/LayoutTests/platform/mac/compositing/visible-rect/3d-transform-style-expected.txt

    r168244 r177200  
    2525              (children 1
    2626                (GraphicsLayer
    27                   (bounds 200.00 0.00)
    2827                  (preserves3D 1)
    2928                  (visible rect 0.00, 0.00 0.00 x 0.00)
    … …  
    5756              (children 1
    5857                (GraphicsLayer
    59                   (bounds 200.00 0.00)
    6058                  (preserves3D 1)
    6159                  (visible rect 0.00, 0.00 0.00 x 0.00)

  • TabularUnified trunk/LayoutTests/platform/win/compositing/tiling/rotated-tiled-preserve3d-clamped-expected.txt

    r149090 r177200  
    2020              (children 1
    2121                (GraphicsLayer
    22                   (bounds 500.00 0.00)
    2322                  (preserves3D 1)
    2423                  (visible rect 0.00, 0.00 0.00 x 0.00)

  • TabularUnified trunk/Source/WebCore/ChangeLog

    r177198 r177200  
     12014-12-11  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Transform-style should not kill position:fixed
     4        https://bugs.webkit.org/show_bug.cgi?id=138122
     5
     6        Reviewed by Dean Jackson.
     7       
     8        Various bits of rendering code checked RenderObject::hasTransform() for various
     9        reasons. Confusingly, this meant "has transform, or preserve-3d, or perspective".
     10       
     11        This patch teases those behaviors apart to produce the following behavior:
     12       
     13        1. "transform" acts as containing block for fixed position (no behavior change).
     14        2. "transform" acts as containing block for absolute/relative position (no behavior change).
     15        3. "perspective" does not act as containing block for fixed position (no behavior change).
     16        4. "perspective" acts as containing block for absolute/relative position (no behavior change).
     17        5. "preserve-3d" does not act as containing block for fixed position (behavior change).
     18        6. "preserve-3d" acts as containing block for absolute/relative position. This is not a
     19        behavior change, but seems like incorrect behavior (https://www.w3.org/Bugs/Public/show_bug.cgi?id=27566).
     20        However, we may be forced to keep it for compatibility.
     21       
     22        The gist of the change is to rename RenderObject::hasTransform() to RenderObject::hasTransformRelatedProperty(),
     23        and add hasTransform() with the more restrictive meaning. All call sites of hasTransform() were examined
     24        and fixed to produce the desired behaviors.
     25
     26        Tests: transforms/2d/perspective-not-fixed-container.html
     27               transforms/2d/preserve3d-not-fixed-container.html
     28               transforms/perspective-is-containing-block-for-absolute.html
     29               transforms/preserve3d-is-containing-block-for-absolute.html
     30               transforms/transform-is-containing-block-for-absolute.html
     31
     32        * css/CSSComputedStyleDeclaration.cpp:
     33        (WebCore::computedTransform): Now we can just test hasTransform().
     34        * rendering/LogicalSelectionOffsetCaches.h:
     35        (WebCore::isContainingBlockCandidateForAbsolutelyPositionedObject): For now, this
     36        can just use hasTransformRelatedProperty(), but if we change [6] above this will have
     37        to change (as documented in the comment). Also FIXME comments about sharing code.
     38        * rendering/RenderBox.cpp:
     39        (WebCore::RenderBox::updateFromStyle):
     40        (WebCore::RenderBox::mapLocalToContainer): Can just use hasTransform() now.
     41        (WebCore::RenderBox::pushMappingToContainer): Ditto.
     42        (WebCore::RenderBox::mapAbsoluteToLocalPoint): Ditto.
     43        (WebCore::RenderBox::layoutOverflowRectForPropagation): Ditto.
     44        * rendering/RenderBox.h: All transform-related properties create RenderLayers.
     45        * rendering/RenderBoxModelObject.h: Ditto.
     46        * rendering/RenderElement.cpp:
     47        (WebCore::RenderElement::styleWillChange):
     48        * rendering/RenderGeometryMap.cpp:
     49        (WebCore::canMapBetweenRenderersViaLayers): Rename to clarify. We need to not map via
     50        layers if we have a perspective (since we need to generate a perspective matrix). It's
     51        OK with preserve-3d though.
     52        (WebCore::RenderGeometryMap::pushMappingsToAncestor):
     53        (WebCore::canMapBetweenRenderers): Deleted.
     54        * rendering/RenderInline.cpp:
     55        (WebCore::RenderInline::updateFromStyle):
     56        * rendering/RenderLayer.cpp:
     57        (WebCore::RenderLayer::updateTransform): Can just check hasTransform().
     58        (WebCore::RenderLayer::updateLayerPosition): Avoid calling parent() and enclosingPositionedAncestor() twice.
     59        (WebCore::RenderLayer::perspectiveTransform): Do the fast bit check hasTransformRelatedProperty() first.
     60        (WebCore::RenderLayer::perspectiveOrigin): Ditto.
     61        (WebCore::isContainerForPositioned): This code has to now have different behavior for absolute and fixed
     62        position. Changed it to call existing functions, rather than having a 3rd place that has to know about
     63        containing block rules.
     64        (WebCore::RenderLayer::enclosingAncestorForPosition): Call isContainerForPositioned() now.
     65        (WebCore::accumulateOffsetTowardsAncestor): Call enclosingAncestorForPosition().
     66        (WebCore::RenderLayer::createLocalTransformState):
     67        (WebCore::RenderLayer::calculateClipRects):
     68        (WebCore::isPositionedContainer): Deleted.
     69        (WebCore::isFixedPositionedContainer): Deleted.
     70        (WebCore::RenderLayer::enclosingPositionedAncestor): Deleted.
     71        * rendering/RenderLayer.h:
     72        * rendering/RenderLayerBacking.cpp:
     73        (WebCore::RenderLayerBacking::updateGeometry):
     74        * rendering/RenderLayerModelObject.cpp:
     75        (WebCore::RenderLayerModelObject::styleDidChange):
     76        * rendering/RenderObject.cpp:
     77        (WebCore::RenderObject::shouldUseTransformFromContainer): Can just check hasTransform() now.
     78        (WebCore::RenderObject::container):
     79        * rendering/RenderObject.h:
     80        (WebCore::RenderObject::hasTransformRelatedProperty):
     81        (WebCore::RenderObject::hasTransform):
     82        (WebCore::RenderObject::setHasTransformRelatedProperty):
     83        (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
     84        (WebCore::RenderObject::setHasTransform): Deleted.
     85        * rendering/RenderTableRow.h:
     86        * rendering/RenderView.cpp:
     87        (WebCore::RenderView::mapLocalToContainer): nullptr goodness.
     88        (WebCore::RenderView::pushMappingToContainer): Ditto.
     89        (WebCore::RenderView::mapAbsoluteToLocalPoint): Ditto.
     90
    1912014-12-11  Rich Tibbett <rich.tibbett@gmail.com>
    292

  • TabularUnified trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp

    r177169 r177200  
    848848static PassRef<CSSValue> computedTransform(RenderObject* renderer, const RenderStyle* style)
    849849{
    850     if (!renderer || !renderer->hasTransform() || !style->hasTransform())
     850    if (!renderer || !renderer->hasTransform())
    851851        return cssValuePool().createIdentifierValue(CSSValueNone);
    852852

  • TabularUnified trunk/Source/WebCore/rendering/LogicalSelectionOffsetCaches.h

    r174480 r177200  
    2626namespace WebCore {
    2727
     28// FIXME: share code with RenderObject::container().
    2829static inline bool isContainingBlockCandidateForAbsolutelyPositionedObject(RenderElement& object)
    2930{
     31    // FIXME: hasTransformRelatedProperty() includes preserves3D() check, but this may need to change: https://www.w3.org/Bugs/Public/show_bug.cgi?id=27566
    3032    return object.style().position() != StaticPosition
    31         || (object.hasTransform() && object.isRenderBlock())
     33        || (object.isRenderBlock() && object.hasTransformRelatedProperty())
    3234        || object.isSVGForeignObject()
    3335        || object.isRenderView();
    … …  
    3941}
    4042
     43// FIXME: share code with RenderObject::container().
    4144static inline RenderBlock* containingBlockForFixedPosition(RenderElement* parent)
    4245{

  • TabularUnified trunk/Source/WebCore/rendering/RenderBox.cpp

    r177169 r177200  
    485485    }
    486486
    487     setHasTransform(styleToUse.hasTransformRelatedProperty());
     487    setHasTransformRelatedProperty(styleToUse.hasTransformRelatedProperty());
    488488    setHasReflection(styleToUse.boxReflect());
    489489}
    … …  
    19191919
    19201920    bool isFixedPos = style().position() == FixedPosition;
    1921     bool hasTransform = hasLayer() && layer()->transform();
    19221921    // If this box has a transform, it acts as a fixed position container for fixed descendants,
    19231922    // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
    1924     if (hasTransform && !isFixedPos)
     1923    if (hasTransform() && !isFixedPos)
    19251924        mode &= ~IsFixed;
    19261925    else if (isFixedPos)
    … …  
    19681967
    19691968    bool isFixedPos = style().position() == FixedPosition;
    1970     bool hasTransform = hasLayer() && layer()->transform();
    1971 
    19721969    LayoutSize adjustmentForSkippedAncestor;
    19731970    if (ancestorSkipped) {
    … …  
    19861983        t.translateRight(adjustmentForSkippedAncestor.width(), adjustmentForSkippedAncestor.height());
    19871984       
    1988         geometryMap.push(this, t, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
     1985        geometryMap.push(this, t, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform());
    19891986    } else {
    19901987        containerOffset += adjustmentForSkippedAncestor;
    1991         geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
     1988        geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform());
    19921989    }
    19931990   
    … …  
    19981995{
    19991996    bool isFixedPos = style().position() == FixedPosition;
    2000     bool hasTransform = hasLayer() && layer()->transform();
    2001     if (hasTransform && !isFixedPos) {
     1997    if (hasTransform() && !isFixedPos) {
    20021998        // If this box has a transform, it acts as a fixed position container for fixed descendants,
    20031999        // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
    … …  
    45674563        rect.unite(layoutOverflowRect());
    45684564
    4569     bool hasTransform = hasLayer() && layer()->transform();
     4565    bool hasTransform = this->hasTransform();
    45704566#if PLATFORM(IOS)
    45714567    if (isInFlowPositioned() || (hasTransform && document().settings()->shouldTransformsAffectOverflow())) {

  • TabularUnified trunk/Source/WebCore/rendering/RenderBox.h

    r177169 r177200  
    5454    {
    5555        return isRoot() || isPositioned() || createsGroup() || hasClipPath() || hasOverflowClip()
    56             || hasTransform() || hasHiddenBackface() || hasReflection() || style().specifiesColumns()
     56            || hasTransformRelatedProperty() || hasHiddenBackface() || hasReflection() || style().specifiesColumns()
    5757            || !style().hasAutoZIndex();
    5858    }

  • TabularUnified trunk/Source/WebCore/rendering/RenderBoxModelObject.h

    r176798 r177200  
    143143    virtual void updateFromStyle() override;
    144144
    145     virtual bool requiresLayer() const override { return isRoot() || isPositioned() || createsGroup() || hasClipPath() || hasTransform() || hasHiddenBackface() || hasReflection(); }
     145    virtual bool requiresLayer() const override { return isRoot() || isPositioned() || createsGroup() || hasClipPath() || hasTransformRelatedProperty() || hasHiddenBackface() || hasReflection(); }
    146146
    147147    // This will work on inlines to return the bounding box of all of the lines' border boxes.

  • TabularUnified trunk/Source/WebCore/rendering/RenderElement.cpp

    r177193 r177200  
    859859        setHasBoxDecorations(false);
    860860        setHasOverflowClip(false);
    861         setHasTransform(false);
     861        setHasTransformRelatedProperty(false);
    862862        setHasReflection(false);
    863863    } else {

  • TabularUnified trunk/Source/WebCore/rendering/RenderGeometryMap.cpp

    r173945 r177200  
    156156}
    157157
    158 static bool canMapBetweenRenderers(const RenderLayerModelObject& renderer, const RenderLayerModelObject& ancestor)
     158static bool canMapBetweenRenderersViaLayers(const RenderLayerModelObject& renderer, const RenderLayerModelObject& ancestor)
    159159{
    160160    for (const RenderElement* current = &renderer; ; current = current->parent()) {
    … …  
    163163            return false;
    164164
    165         if (current->hasTransform() || current->isRenderFlowThread())
     165        if (current->hasTransformRelatedProperty() && (current->style().hasTransform() || current->style().hasPerspective()))
     166            return false;
     167       
     168        if (current->isRenderFlowThread())
    166169            return false;
    167170
    … …  
    182185    // We have to visit all the renderers to detect flipped blocks. This might defeat the gains
    183186    // from mapping via layers.
    184     bool canConvertInLayerTree = ancestorLayer ? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer()) : false;
     187    bool canConvertInLayerTree = ancestorLayer ? canMapBetweenRenderersViaLayers(layer->renderer(), ancestorLayer->renderer()) : false;
    185188
    186189    if (canConvertInLayerTree) {

  • TabularUnified trunk/Source/WebCore/rendering/RenderInline.cpp

    r176974 r177200  
    125125
    126126    // FIXME: Support transforms and reflections on inline flows someday.
    127     setHasTransform(false);
     127    setHasTransformRelatedProperty(false);
    128128    setHasReflection(false);   
    129129}

  • TabularUnified trunk/Source/WebCore/rendering/RenderLayer.cpp

    r177169 r177200  
    7878#include "HitTestResult.h"
    7979#include "InspectorInstrumentation.h"
     80#include "LogicalSelectionOffsetCaches.h"
    8081#include "OverflowEvent.h"
    8182#include "OverlapTestRequestClient.h"
    … …  
    831832void RenderLayer::updateTransform()
    832833{
    833     // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
    834     // so check style too.
    835     bool hasTransform = renderer().hasTransform() && renderer().style().hasTransform();
     834    bool hasTransform = renderer().hasTransform();
    836835    bool had3DTransform = has3DTransform();
    837836
    … …  
    12111210    }
    12121211
    1213     if (!renderer().isOutOfFlowPositioned() && renderer().parent()) {
     1212    RenderElement* ancestor;
     1213    if (!renderer().isOutOfFlowPositioned() && (ancestor = renderer().parent())) {
    12141214        // We must adjust our position by walking up the render tree looking for the
    12151215        // nearest enclosing object with a layer.
    1216         RenderElement* ancestor = renderer().parent();
    12171216        while (ancestor && !ancestor->hasLayer()) {
    12181217            if (is<RenderBox>(*ancestor) && !is<RenderTableRow>(*ancestor)) {
    … …  
    12301229   
    12311230    // Subtract our parent's scroll offset.
    1232     if (renderer().isOutOfFlowPositioned() && enclosingPositionedAncestor()) {
    1233         RenderLayer* positionedParent = enclosingPositionedAncestor();
    1234 
     1231    RenderLayer* positionedParent;
     1232    if (renderer().isOutOfFlowPositioned() && (positionedParent = enclosingAncestorForPosition(renderer().style().position()))) {
    12351233        // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
    12361234        if (positionedParent->renderer().hasOverflowClip()) {
    … …  
    12701268TransformationMatrix RenderLayer::perspectiveTransform() const
    12711269{
    1272     if (!renderer().hasTransform())
     1270    if (!renderer().hasTransformRelatedProperty())
    12731271        return TransformationMatrix();
    12741272
    … …  
    13001298FloatPoint RenderLayer::perspectiveOrigin() const
    13011299{
    1302     if (!renderer().hasTransform())
     1300    if (!renderer().hasTransformRelatedProperty())
    13031301        return FloatPoint();
    13041302
    … …  
    13201318}
    13211319
    1322 static inline bool isPositionedContainer(RenderLayer* layer)
    1323 {
    1324     return layer->isRootLayer() || layer->renderer().isPositioned() || layer->hasTransform();
    1325 }
    1326 
    1327 static inline bool isFixedPositionedContainer(RenderLayer* layer)
    1328 {
    1329     return layer->isRootLayer() || layer->hasTransform();
    1330 }
    1331 
    1332 RenderLayer* RenderLayer::enclosingPositionedAncestor() const
     1320static inline bool isContainerForPositioned(RenderLayer& layer, EPosition position)
     1321{
     1322    switch (position) {
     1323    case FixedPosition:
     1324        return layer.renderer().canContainFixedPositionObjects();
     1325
     1326    case AbsolutePosition:
     1327        return isContainingBlockCandidateForAbsolutelyPositionedObject(layer.renderer());
     1328   
     1329    default:
     1330        ASSERT_NOT_REACHED();
     1331        return false;
     1332    }
     1333}
     1334
     1335RenderLayer* RenderLayer::enclosingAncestorForPosition(EPosition position) const
    13331336{
    13341337    RenderLayer* curr = parent();
    1335     while (curr && !isPositionedContainer(curr))
     1338    while (curr && !isContainerForPositioned(*curr, position))
    13361339        curr = curr->parent();
    13371340
    … …  
    19121915                foundAncestor = true;
    19131916
    1914             if (isFixedPositionedContainer(currLayer)) {
     1917            if (isContainerForPositioned(*currLayer, FixedPosition)) {
    19151918                fixedPositionContainerLayer = currLayer;
    19161919                ASSERT_UNUSED(foundAncestor, foundAncestor);
    … …  
    19491952    RenderLayer* parentLayer;
    19501953    if (position == AbsolutePosition || position == FixedPosition) {
    1951         // Do what enclosingPositionedAncestor() does, but check for ancestorLayer along the way.
     1954        // Do what enclosingAncestorForPosition() does, but check for ancestorLayer along the way.
    19521955        parentLayer = layer->parent();
    19531956        bool foundAncestorFirst = false;
    … …  
    19561959            // This implies that, for out-of-flow positioned elements inside a RenderFlowThread,
    19571960            // we are bailing out before reaching root layer.
    1958             if (isPositionedContainer(parentLayer))
     1961            if (isContainerForPositioned(*parentLayer, position))
    19591962                break;
    19601963
    … …  
    19741977        if (foundAncestorFirst) {
    19751978            // Found ancestorLayer before the abs. positioned container, so compute offset of both relative
    1976             // to enclosingPositionedAncestor and subtract.
    1977             RenderLayer* positionedAncestor = parentLayer->enclosingPositionedAncestor();
     1979            // to enclosingAncestorForPosition and subtract.
     1980            RenderLayer* positionedAncestor = parentLayer->enclosingAncestorForPosition(position);
    19781981            LayoutSize thisCoords = layer->offsetFromAncestor(positionedAncestor);
    19791982            LayoutSize ancestorCoords = ancestorLayer->offsetFromAncestor(positionedAncestor);
    … …  
    47194722    offset += translationOffset;
    47204723
    4721     RenderObject* containerRenderer = containerLayer ? &containerLayer->renderer() : 0;
     4724    RenderObject* containerRenderer = containerLayer ? &containerLayer->renderer() : nullptr;
    47224725    if (renderer().shouldUseTransformFromContainer(containerRenderer)) {
    47234726        TransformationMatrix containerTransform;
    … …  
    62166219        || renderer().isInFlowRenderFlowThread())
    62176220        && !renderer().isPositioned()
    6218         && !renderer().hasTransform()
     6221        && !renderer().hasTransformRelatedProperty()
    62196222        && !renderer().hasClipPath()
    62206223        && !renderer().hasFilter()

  • TabularUnified trunk/Source/WebCore/rendering/RenderLayer.h

    r177169 r177200  
    620620    // Gets the nearest enclosing positioned ancestor layer (also includes
    621621    // the <html> layer and the root layer).
    622     RenderLayer* enclosingPositionedAncestor() const;
     622    RenderLayer* enclosingAncestorForPosition(EPosition) const;
    623623
    624624    // Returns the nearest enclosing layer that is scrollable.

  • TabularUnified trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r175818 r177200  
    823823    }
    824824   
    825     if (m_owningLayer.hasTransform()) {
     825    if (m_owningLayer.renderer().hasTransformRelatedProperty()) {
    826826        // Update properties that depend on layer dimensions.
    827827        FloatPoint3D transformOrigin = computeTransformOriginForPainting(downcast<RenderBox>(renderer()).borderBoxRect());

  • TabularUnified trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r176459 r177200  
    22622262        break;
    22632263    case RenderLayer::IndirectCompositingReason::GraphicalEffect:
    2264         if (renderer->layer()->transform())
     2264        if (renderer->hasTransform())
    22652265            reasons |= CompositingReasonTransformWithCompositedDescendants;
    22662266

  • TabularUnified trunk/Source/WebCore/rendering/RenderLayerModelObject.cpp

    r175716 r177200  
    148148            layer()->parent()->dirtyAncestorChainHasBlendingDescendants();
    149149#endif
    150         setHasTransform(false); // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
     150        setHasTransformRelatedProperty(false); // All transform-related propeties force layers, so we know we don't have one or the object doesn't support them.
    151151        setHasReflection(false);
    152152        layer()->removeOnlyThisLayer(); // calls destroyLayer() which clears m_layer

  • TabularUnified trunk/Source/WebCore/rendering/RenderObject.cpp

    r176816 r177200  
    16491649{
    16501650#if ENABLE(3D_RENDERING)
    1651     // hasTransform() indicates whether the object has transform, transform-style or perspective. We just care about transform,
    1652     // so check the layer's transform directly.
    1653     return (hasLayer() && downcast<RenderLayerModelObject>(*this).layer()->transform()) || (containerObject && containerObject->style().hasPerspective());
     1651    return hasTransform() || (containerObject && containerObject->style().hasPerspective());
    16541652#else
    16551653    UNUSED_PARAM(containerObject);
    … …  
    18121810        // FIXME: The definition of view() has changed to not crawl up the render tree.  It might
    18131811        // be safe now to use it.
     1812        // FIXME: share code with containingBlockForFixedPosition().
    18141813        while (o && o->parent() && !(o->hasTransform() && o->isRenderBlock())) {
    18151814            // foreignObject is the containing block for its contents.
    … …  
    18311830        // we may not have one if we're part of an uninstalled subtree.  We'll
    18321831        // climb as high as we can though.
    1833         while (o && o->style().position() == StaticPosition && !o->isRenderView() && !(o->hasTransform() && o->isRenderBlock())) {
     1832        // FIXME: share code with isContainingBlockCandidateForAbsolutelyPositionedObject().
     1833        // FIXME: hasTransformRelatedProperty() includes preserves3D() check, but this may need to change: https://www.w3.org/Bugs/Public/show_bug.cgi?id=27566
     1834        while (o && o->style().position() == StaticPosition && !o->isRenderView() && !(o->hasTransformRelatedProperty() && o->isRenderBlock())) {
    18341835            if (o->isSVGForeignObject()) // foreignObject is the containing block for contents inside it
    18351836                break;

  • TabularUnified trunk/Source/WebCore/rendering/RenderObject.h

    r176816 r177200  
    551551    bool hasOverflowClip() const { return m_bitfields.hasOverflowClip(); }
    552552
    553     bool hasTransform() const { return m_bitfields.hasTransform(); }
     553    bool hasTransformRelatedProperty() const { return m_bitfields.hasTransformRelatedProperty(); } // Transform, perspective or transform-style: preserve-3d.
     554    bool hasTransform() const { return hasTransformRelatedProperty() && style().hasTransform(); }
    554555
    555556    inline bool preservesNewline() const;
    … …  
    617618    void setHasOverflowClip(bool b = true) { m_bitfields.setHasOverflowClip(b); }
    618619    void setHasLayer(bool b = true) { m_bitfields.setHasLayer(b); }
    619     void setHasTransform(bool b = true) { m_bitfields.setHasTransform(b); }
     620    void setHasTransformRelatedProperty(bool b = true) { m_bitfields.setHasTransformRelatedProperty(b); }
    620621    void setHasReflection(bool b = true) { m_bitfields.setHasReflection(b); }
    621622
    … …  
    928929            , m_hasLayer(false)
    929930            , m_hasOverflowClip(false)
    930             , m_hasTransform(false)
     931            , m_hasTransformRelatedProperty(false)
    931932            , m_hasReflection(false)
    932933            , m_everHadLayout(false)
    … …  
    959960        ADD_BOOLEAN_BITFIELD(hasLayer, HasLayer);
    960961        ADD_BOOLEAN_BITFIELD(hasOverflowClip, HasOverflowClip); // Set in the case of overflow:auto/scroll/hidden
    961         ADD_BOOLEAN_BITFIELD(hasTransform, HasTransform);
     962        ADD_BOOLEAN_BITFIELD(hasTransformRelatedProperty, HasTransformRelatedProperty);
    962963        ADD_BOOLEAN_BITFIELD(hasReflection, HasReflection);
    963964

  • TabularUnified trunk/Source/WebCore/rendering/RenderRegion.cpp

    r174761 r177200  
    545545        rect.unite(layoutOverflowRectForBox(box));
    546546
    547     bool hasTransform = box->hasLayer() && box->layer()->transform();
     547    bool hasTransform = box->hasTransform();
    548548    if (box->isInFlowPositioned() || hasTransform) {
    549549        if (hasTransform)

  • TabularUnified trunk/Source/WebCore/rendering/RenderTableRow.h

    r174653 r177200  
    104104    virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const override;
    105105
    106     virtual bool requiresLayer() const override { return hasOverflowClip() || hasTransform() || hasHiddenBackface() || hasClipPath() || createsGroup() || isStickyPositioned(); }
     106    virtual bool requiresLayer() const override { return hasOverflowClip() || hasTransformRelatedProperty() || hasHiddenBackface() || hasClipPath() || createsGroup() || isStickyPositioned(); }
    107107
    108108    virtual void paint(PaintInfo&, const LayoutPoint&) override;

  • TabularUnified trunk/Source/WebCore/rendering/RenderView.cpp

    r176459 r177200  
    421421    ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == (mode & IsFixed));
    422422
    423     if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) {
     423    if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(nullptr)) {
    424424        TransformationMatrix t;
    425         getTransformFromContainer(0, LayoutSize(), t);
     425        getTransformFromContainer(nullptr, LayoutSize(), t);
    426426        transformState.applyTransform(t);
    427427    }
    … …  
    447447#endif
    448448
    449     if (!ancestorToStopAt && shouldUseTransformFromContainer(0)) {
     449    if (!ancestorToStopAt && shouldUseTransformFromContainer(nullptr)) {
    450450        TransformationMatrix t;
    451         getTransformFromContainer(0, LayoutSize(), t);
     451        getTransformFromContainer(nullptr, LayoutSize(), t);
    452452        geometryMap.pushView(this, scrollOffset, &t);
    453453    } else
    … …  
    466466#endif
    467467
    468     if (mode & UseTransforms && shouldUseTransformFromContainer(0)) {
     468    if (mode & UseTransforms && shouldUseTransformFromContainer(nullptr)) {
    469469        TransformationMatrix t;
    470         getTransformFromContainer(0, LayoutSize(), t);
     470        getTransformFromContainer(nullptr, LayoutSize(), t);
    471471        transformState.applyTransform(t);
    472472    }
Note: See TracChangeset for help on using the changeset viewer.