⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 118567 in webkit


Ignore:
Timestamp:
May 25, 2012, 2:42:32 PM (14 years ago)
Author:
Simon Fraser
Message:

Terrible performance on ​http://alliances.commandandconquer.com/ and ​http://www.lordofultima.com/
​https://bugs.webkit.org/show_bug.cgi?id=84410

Source/WebCore:

Reviewed by Dave Hyatt.

First part of fixing O(N2) issues when walking the RenderLayer tree
for computeCompositingRequirements().

For each layer that goes into the OverlapMap, we were computing an absolute
layer bounds, which requires walking back to the root of the tree.
Optimize this when possible by storing a stack of offsets as we walk
the tree, and using this stack to do the mapping.

The stack of offsets and transforms is managed by RenderGeometryMap.
When visiting a RenderLayer, RenderLayerCompositor pushes onto
the geometry map stack data about offsets and transforms between
the current layer and its stacking-parent. RenderGeometryMap handles
the case where the previous renderer pushed is between the current
renderer and its container. RenderGeometryMap can also handle callers
pushing renderers with multiple containers between them.

RenderGeometryMap stores some flags about whether the set of mapping
steps in the stack involve transforms, fixed position, or special non-uniform
mappings like CSS columns. In some cases, it falls back to mapping via
renderers.

Once constructed, the RenderGeometryMap stack can be used to map multiple
rects or points efficiently. Stacks consisting of simple offsets are
collapsed to a single offset.

Mappings between renderers and their containers are pushed by pushMappingToContainer()
methods, which are similar to mapLocalToContainer() methods. Having this code
in RenderObjects was deemed preferable to handling columns, transforms etc. all in
RenderLayer code.

Tested by assertions in RenderGeometryMap code that its mapping matches
mapping via localToAbsolute() calls.

RenderLayerCompositor::updateCompositingLayers() creates a RenderGeometryMap,
and pushes and pops layer renderers as it visits them. The geometry map is used
by RenderLayerCompositor::addToOverlapMap() when computing absolute layer bounds.

Futher optimizations in RenderGeometryMap are possible, especially with stacks that
have many offsets and a few transforms.

Tests: compositing/geometry/composited-in-columns.html

compositing/geometry/flipped-writing-mode.html

  • CMakeLists.txt: Add RenderGeometryMap
  • GNUmakefile.list.am: Ditt
  • Target.pri: Ditto
  • WebCore.gypi: Ditto
  • WebCore.vcproj/WebCore.vcproj: Ditto
  • WebCore.xcodeproj/project.pbxproj: Ditto
  • rendering/RenderBox.cpp:

(WebCore::RenderBox::absoluteContentBox):
(WebCore::RenderBox::pushMappingToContainer):
(WebCore::RenderBox::offsetFromContainer):

  • rendering/RenderBox.h:
  • rendering/RenderGeometryMap.cpp: Added.

(RenderGeometryMapStep):
(WebCore::RenderGeometryMapStep::RenderGeometryMapStep):
(WebCore::RenderGeometryMapStep::mapPoint):
(WebCore::RenderGeometryMapStep::mapQuad):
(WebCore::RenderGeometryMap::RenderGeometryMap):
(WebCore::RenderGeometryMap::~RenderGeometryMap):
(WebCore::RenderGeometryMap::absolutePoint):
(WebCore::RenderGeometryMap::absoluteRect):
(WebCore::RenderGeometryMap::mapToAbsolute):
(WebCore::RenderGeometryMap::pushMappingsToAncestor):
(WebCore::RenderGeometryMap::push):
(WebCore::RenderGeometryMap::pushView):
(WebCore::RenderGeometryMap::popMappingsToAncestor):
(WebCore::RenderGeometryMap::stepInserted):
(WebCore::RenderGeometryMap::stepRemoved):

  • rendering/RenderGeometryMap.h: Added.

(RenderGeometryMap):
(WebCore::RenderGeometryMap::hasNonUniformStep):
(WebCore::RenderGeometryMap::hasTransformStep):
(WebCore::RenderGeometryMap::hasFixedPositionStep):

  • rendering/RenderInline.cpp:

(WebCore::RenderInline::offsetFromContainer):
(WebCore::RenderInline::pushMappingToContainer):

  • rendering/RenderInline.h:

(RenderInline):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::updateCompositingLayers):
(WebCore::RenderLayerCompositor::addToOverlapMap):
(WebCore::RenderLayerCompositor::addToOverlapMapRecursive):
(WebCore::RenderLayerCompositor::computeCompositingRequirements):

  • rendering/RenderLayerCompositor.h:

(RenderLayerCompositor):

  • rendering/RenderObject.cpp:

(WebCore::RenderObject::mapLocalToContainer):
(WebCore::RenderObject::pushMappingToContainer):
(WebCore::RenderObject::offsetFromContainer):
(WebCore::RenderObject::container):

  • rendering/RenderObject.h:
  • rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::offsetFromContainer):

  • rendering/RenderTableCell.h:

(RenderTableCell):

  • rendering/RenderView.cpp:

(WebCore::RenderView::pushMappingToContainer):

  • rendering/RenderView.h:
  • rendering/svg/RenderSVGForeignObject.cpp:

(WebCore::RenderSVGForeignObject::pushMappingToContainer):

  • rendering/svg/RenderSVGForeignObject.h:

(RenderSVGForeignObject):

  • rendering/svg/RenderSVGInline.cpp:

(WebCore::RenderSVGInline::pushMappingToContainer):

  • rendering/svg/RenderSVGInline.h:

(RenderSVGInline):

  • rendering/svg/RenderSVGModelObject.cpp:

(WebCore::RenderSVGModelObject::pushMappingToContainer):

  • rendering/svg/RenderSVGModelObject.h:

(RenderSVGModelObject):

  • rendering/svg/RenderSVGRoot.cpp:

(WebCore::RenderSVGRoot::pushMappingToContainer):

  • rendering/svg/RenderSVGRoot.h:

(RenderSVGRoot):

  • rendering/svg/RenderSVGText.cpp:

(WebCore::RenderSVGText::pushMappingToContainer):

  • rendering/svg/RenderSVGText.h:

(RenderSVGText):

  • rendering/svg/SVGRenderSupport.cpp:

(WebCore::SVGRenderSupport::pushMappingToContainer):

  • rendering/svg/SVGRenderSupport.h:

(SVGRenderSupport):

LayoutTests:

Reviewed by Dave Hyatt.

Basic tests for compositing inside columns, and in a flipped-writing-mode
document.

  • compositing/geometry/composited-in-columns-expected.png: Added.
  • compositing/geometry/composited-in-columns-expected.txt: Added.
  • compositing/geometry/composited-in-columns.html: Added.
  • compositing/geometry/flipped-writing-mode-expected.png: Added.
  • compositing/geometry/flipped-writing-mode-expected.txt: Added.
  • compositing/geometry/flipped-writing-mode.html: Added.
Location:
trunk
Files:
8 added
32 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r118566 r118567  
     12012-05-25  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Terrible performance on http://alliances.commandandconquer.com/ and http://www.lordofultima.com/
     4        https://bugs.webkit.org/show_bug.cgi?id=84410
     5
     6        Reviewed by Dave Hyatt.
     7       
     8        Basic tests for compositing inside columns, and in a flipped-writing-mode
     9        document.
     10
     11        * compositing/geometry/composited-in-columns-expected.png: Added.
     12        * compositing/geometry/composited-in-columns-expected.txt: Added.
     13        * compositing/geometry/composited-in-columns.html: Added.
     14        * compositing/geometry/flipped-writing-mode-expected.png: Added.
     15        * compositing/geometry/flipped-writing-mode-expected.txt: Added.
     16        * compositing/geometry/flipped-writing-mode.html: Added.
     17
    1182012-05-25  Andras Becsi  <andras.becsi@nokia.com>
    219

  • trunk/Source/WebCore/CMakeLists.txt

    r118376 r118567  
    13421342    rendering/RenderFrameSet.cpp
    13431343    rendering/RenderFullScreen.cpp
     1344    rendering/RenderGeometryMap.cpp
    13441345    rendering/RenderHTMLCanvas.cpp
    13451346    rendering/RenderIFrame.cpp

  • trunk/Source/WebCore/ChangeLog

    r118562 r118567  
     12012-05-25  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Terrible performance on http://alliances.commandandconquer.com/ and http://www.lordofultima.com/
     4        https://bugs.webkit.org/show_bug.cgi?id=84410
     5
     6        Reviewed by Dave Hyatt.
     7       
     8        First part of fixing O(N^2) issues when walking the RenderLayer tree
     9        for computeCompositingRequirements().
     10       
     11        For each layer that goes into the OverlapMap, we were computing an absolute
     12        layer bounds, which requires walking back to the root of the tree.
     13        Optimize this when possible by storing a stack of offsets as we walk
     14        the tree, and using this stack to do the mapping.
     15       
     16        The stack of offsets and transforms is managed by RenderGeometryMap.
     17        When visiting a RenderLayer, RenderLayerCompositor pushes onto
     18        the geometry map stack data about offsets and transforms between
     19        the current layer and its stacking-parent. RenderGeometryMap handles
     20        the case where the previous renderer pushed is between the current
     21        renderer and its container. RenderGeometryMap can also handle callers
     22        pushing renderers with multiple containers between them.
     23       
     24        RenderGeometryMap stores some flags about whether the set of mapping
     25        steps in the stack involve transforms, fixed position, or special non-uniform
     26        mappings like CSS columns. In some cases, it falls back to mapping via
     27        renderers.
     28
     29        Once constructed, the RenderGeometryMap stack can be used to map multiple
     30        rects or points efficiently. Stacks consisting of simple offsets are
     31        collapsed to a single offset.
     32       
     33        Mappings between renderers and their containers are pushed by pushMappingToContainer()
     34        methods, which are similar to mapLocalToContainer() methods. Having this code
     35        in RenderObjects was deemed preferable to handling columns, transforms etc. all in
     36        RenderLayer code.
     37
     38        Tested by assertions in RenderGeometryMap code that its mapping matches
     39        mapping via localToAbsolute() calls.
     40       
     41        RenderLayerCompositor::updateCompositingLayers() creates a RenderGeometryMap,
     42        and pushes and pops layer renderers as it visits them. The geometry map is used
     43        by RenderLayerCompositor::addToOverlapMap() when computing absolute layer bounds.
     44       
     45        Futher optimizations in RenderGeometryMap are possible, especially with stacks that
     46        have many offsets and a few transforms.
     47
     48        Tests: compositing/geometry/composited-in-columns.html
     49               compositing/geometry/flipped-writing-mode.html
     50
     51        * CMakeLists.txt: Add RenderGeometryMap
     52        * GNUmakefile.list.am: Ditt
     53        * Target.pri: Ditto
     54        * WebCore.gypi: Ditto
     55        * WebCore.vcproj/WebCore.vcproj: Ditto
     56        * WebCore.xcodeproj/project.pbxproj: Ditto
     57        * rendering/RenderBox.cpp:
     58        (WebCore::RenderBox::absoluteContentBox):
     59        (WebCore::RenderBox::pushMappingToContainer):
     60        (WebCore::RenderBox::offsetFromContainer):
     61        * rendering/RenderBox.h:
     62        * rendering/RenderGeometryMap.cpp: Added.
     63        (RenderGeometryMapStep):
     64        (WebCore::RenderGeometryMapStep::RenderGeometryMapStep):
     65        (WebCore::RenderGeometryMapStep::mapPoint):
     66        (WebCore::RenderGeometryMapStep::mapQuad):
     67        (WebCore::RenderGeometryMap::RenderGeometryMap):
     68        (WebCore::RenderGeometryMap::~RenderGeometryMap):
     69        (WebCore::RenderGeometryMap::absolutePoint):
     70        (WebCore::RenderGeometryMap::absoluteRect):
     71        (WebCore::RenderGeometryMap::mapToAbsolute):
     72        (WebCore::RenderGeometryMap::pushMappingsToAncestor):
     73        (WebCore::RenderGeometryMap::push):
     74        (WebCore::RenderGeometryMap::pushView):
     75        (WebCore::RenderGeometryMap::popMappingsToAncestor):
     76        (WebCore::RenderGeometryMap::stepInserted):
     77        (WebCore::RenderGeometryMap::stepRemoved):
     78        * rendering/RenderGeometryMap.h: Added.
     79        (RenderGeometryMap):
     80        (WebCore::RenderGeometryMap::hasNonUniformStep):
     81        (WebCore::RenderGeometryMap::hasTransformStep):
     82        (WebCore::RenderGeometryMap::hasFixedPositionStep):
     83        * rendering/RenderInline.cpp:
     84        (WebCore::RenderInline::offsetFromContainer):
     85        (WebCore::RenderInline::pushMappingToContainer):
     86        * rendering/RenderInline.h:
     87        (RenderInline):
     88        * rendering/RenderLayerCompositor.cpp:
     89        (WebCore::RenderLayerCompositor::updateCompositingLayers):
     90        (WebCore::RenderLayerCompositor::addToOverlapMap):
     91        (WebCore::RenderLayerCompositor::addToOverlapMapRecursive):
     92        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
     93        * rendering/RenderLayerCompositor.h:
     94        (RenderLayerCompositor):
     95        * rendering/RenderObject.cpp:
     96        (WebCore::RenderObject::mapLocalToContainer):
     97        (WebCore::RenderObject::pushMappingToContainer):
     98        (WebCore::RenderObject::offsetFromContainer):
     99        (WebCore::RenderObject::container):
     100        * rendering/RenderObject.h:
     101        * rendering/RenderTableCell.cpp:
     102        (WebCore::RenderTableCell::offsetFromContainer):
     103        * rendering/RenderTableCell.h:
     104        (RenderTableCell):
     105        * rendering/RenderView.cpp:
     106        (WebCore::RenderView::pushMappingToContainer):
     107        * rendering/RenderView.h:
     108        * rendering/svg/RenderSVGForeignObject.cpp:
     109        (WebCore::RenderSVGForeignObject::pushMappingToContainer):
     110        * rendering/svg/RenderSVGForeignObject.h:
     111        (RenderSVGForeignObject):
     112        * rendering/svg/RenderSVGInline.cpp:
     113        (WebCore::RenderSVGInline::pushMappingToContainer):
     114        * rendering/svg/RenderSVGInline.h:
     115        (RenderSVGInline):
     116        * rendering/svg/RenderSVGModelObject.cpp:
     117        (WebCore::RenderSVGModelObject::pushMappingToContainer):
     118        * rendering/svg/RenderSVGModelObject.h:
     119        (RenderSVGModelObject):
     120        * rendering/svg/RenderSVGRoot.cpp:
     121        (WebCore::RenderSVGRoot::pushMappingToContainer):
     122        * rendering/svg/RenderSVGRoot.h:
     123        (RenderSVGRoot):
     124        * rendering/svg/RenderSVGText.cpp:
     125        (WebCore::RenderSVGText::pushMappingToContainer):
     126        * rendering/svg/RenderSVGText.h:
     127        (RenderSVGText):
     128        * rendering/svg/SVGRenderSupport.cpp:
     129        (WebCore::SVGRenderSupport::pushMappingToContainer):
     130        * rendering/svg/SVGRenderSupport.h:
     131        (SVGRenderSupport):
     132
    11332012-05-25  Simon Fraser  <simon.fraser@apple.com>
    2134

  • trunk/Source/WebCore/GNUmakefile.list.am

    r118510 r118567  
    38153815        Source/WebCore/rendering/RenderFullScreen.cpp \
    38163816        Source/WebCore/rendering/RenderFullScreen.h \
     3817        Source/WebCore/rendering/RenderGeometryMap.cpp \
     3818        Source/WebCore/rendering/RenderGeometryMap.h \
    38173819        Source/WebCore/rendering/RenderHTMLCanvas.cpp \
    38183820        Source/WebCore/rendering/RenderHTMLCanvas.h \

  • trunk/Source/WebCore/Target.pri

    r118407 r118567  
    12671267    rendering/RenderFrameBase.cpp \
    12681268    rendering/RenderFrameSet.cpp \
     1269    rendering/RenderGeometryMap.cpp \
    12691270    rendering/RenderHTMLCanvas.cpp \
    12701271    rendering/RenderIFrame.cpp \
    … …  
    24642465    rendering/RenderFrameBase.h \
    24652466    rendering/RenderFrameSet.h \
     2467    rendering/RenderGeometryMap.h \
    24662468    rendering/RenderHTMLCanvas.h \
    24672469    rendering/RenderIFrame.h \

  • trunk/Source/WebCore/WebCore.gypi

    r118527 r118567  
    48114811            'rendering/RenderFullScreen.cpp',
    48124812            'rendering/RenderFullScreen.h',
     4813            'rendering/RenderGeometryMap.cpp',
     4814            'rendering/RenderGeometryMap.h',
    48134815            'rendering/RenderHTMLCanvas.cpp',
    48144816            'rendering/RenderHTMLCanvas.h',

  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r118510 r118567  
    3937239372                        </File>
    3937339373                        <File
     39374                                RelativePath="..\rendering\RenderGeometryMap.cpp"
     39375                                >
     39376                        </File>
     39377                        <File
     39378                                RelativePath="..\rendering\RenderGeometryMap.h"
     39379                                >
     39380                        </File>
     39381                        <File
    3937439382                                RelativePath="..\rendering\RenderHTMLCanvas.cpp"
    3937539383                                >

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r118510 r118567  
    242242                0F3DD44F12F5EA1B000D9190 /* ShadowBlur.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F3DD44D12F5EA1B000D9190 /* ShadowBlur.cpp */; };
    243243                0F3DD45012F5EA1B000D9190 /* ShadowBlur.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F3DD44E12F5EA1B000D9190 /* ShadowBlur.h */; };
     244                0F3F0E59157030C3006DA57F /* RenderGeometryMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F3F0E57157030C3006DA57F /* RenderGeometryMap.cpp */; };
     245                0F3F0E5A157030C3006DA57F /* RenderGeometryMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F3F0E58157030C3006DA57F /* RenderGeometryMap.h */; };
    244246                0F4E57171313276200CF85AF /* RenderSVGAllInOne.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F4E57161313276200CF85AF /* RenderSVGAllInOne.cpp */; };
    245247                0F56028F0E4B76580065B038 /* RenderMarquee.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F56028D0E4B76580065B038 /* RenderMarquee.h */; };
    … …  
    71307132                0F3DD44D12F5EA1B000D9190 /* ShadowBlur.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ShadowBlur.cpp; sourceTree = "<group>"; };
    71317133                0F3DD44E12F5EA1B000D9190 /* ShadowBlur.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ShadowBlur.h; sourceTree = "<group>"; };
     7134                0F3F0E57157030C3006DA57F /* RenderGeometryMap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderGeometryMap.cpp; sourceTree = "<group>"; };
     7135                0F3F0E58157030C3006DA57F /* RenderGeometryMap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderGeometryMap.h; sourceTree = "<group>"; };
    71327136                0F4E57161313276200CF85AF /* RenderSVGAllInOne.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderSVGAllInOne.cpp; sourceTree = "<group>"; };
    71337137                0F56028D0E4B76580065B038 /* RenderMarquee.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderMarquee.h; sourceTree = "<group>"; };
    … …  
    2092520929                                CDEA7C831276230400B846DD /* RenderFullScreen.cpp */,
    2092620930                                CDEA7C821276230400B846DD /* RenderFullScreen.h */,
     20931                                0F3F0E57157030C3006DA57F /* RenderGeometryMap.cpp */,
     20932                                0F3F0E58157030C3006DA57F /* RenderGeometryMap.h */,
    2092720933                                BCEA482A097D93020094C9E4 /* RenderHTMLCanvas.cpp */,
    2092820934                                BCEA482B097D93020094C9E4 /* RenderHTMLCanvas.h */,
    … …  
    2495124957                                E4946EAF156E64DD00D3297F /* StyleRuleImport.h in Headers */,
    2495224958                                71DCB7021568197600862271 /* JSSVGZoomAndPan.h in Headers */,
     24959                                0F3F0E5A157030C3006DA57F /* RenderGeometryMap.h in Headers */,
    2495324960                        );
    2495424961                        runOnlyForDeploymentPostprocessing = 0;
    … …  
    2798227989                                E4946EAE156E64DD00D3297F /* StyleRuleImport.cpp in Sources */,
    2798327990                                71DCB7011568197600862271 /* JSSVGZoomAndPan.cpp in Sources */,
     27991                                0F3F0E59157030C3006DA57F /* RenderGeometryMap.cpp in Sources */,
    2798427992                        );
    2798527993                        runOnlyForDeploymentPostprocessing = 0;

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

    r118551 r118567  
    4545#include "RenderFlexibleBox.h"
    4646#include "RenderFlowThread.h"
     47#include "RenderGeometryMap.h"
    4748#include "RenderInline.h"
    4849#include "RenderLayer.h"
    … …  
    438439IntRect RenderBox::absoluteContentBox() const
    439440{
     441    // This is wrong with transforms and flipped writing modes.
    440442    IntRect rect = pixelSnappedIntRect(contentBoxRect());
    441443    FloatPoint absPos = localToAbsolute(FloatPoint());
    … …  
    13161318}
    13171319
     1320const RenderObject* RenderBox::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     1321{
     1322    ASSERT(ancestorToStopAt != this);
     1323
     1324    bool ancestorSkipped;
     1325    RenderObject* container = this->container(ancestorToStopAt, &ancestorSkipped);
     1326    if (!container)
     1327        return 0;
     1328
     1329    bool isFixedPos = style()->position() == FixedPosition;
     1330    bool hasTransform = hasLayer() && layer()->transform();
     1331
     1332    LayoutSize adjustmentForSkippedAncestor;
     1333    if (ancestorSkipped) {
     1334        // There can't be a transform between repaintContainer and o, because transforms create containers, so it should be safe
     1335        // to just subtract the delta between the ancestor and o.
     1336        adjustmentForSkippedAncestor = -ancestorToStopAt->offsetFromAncestorContainer(container);
     1337    }
     1338
     1339    bool offsetDependsOnPoint = false;
     1340    LayoutSize containerOffset = offsetFromContainer(container, LayoutPoint(), &offsetDependsOnPoint);
     1341
     1342    if (container->isRenderFlowThread())
     1343        offsetDependsOnPoint = true;
     1344   
     1345    bool preserve3D = container->style()->preserves3D() || style()->preserves3D();
     1346    if (shouldUseTransformFromContainer(container)) {
     1347        TransformationMatrix t;
     1348        getTransformFromContainer(container, containerOffset, t);
     1349        t.translateRight(adjustmentForSkippedAncestor.width(), adjustmentForSkippedAncestor.height());
     1350       
     1351        geometryMap.push(this, t, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
     1352    } else {
     1353        containerOffset += adjustmentForSkippedAncestor;
     1354        geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint, isFixedPos, hasTransform);
     1355    }
     1356   
     1357    return ancestorSkipped ? ancestorToStopAt : container;
     1358}
     1359
    13181360void RenderBox::mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState& transformState) const
    13191361{
    … …  
    13331375}
    13341376
    1335 LayoutSize RenderBox::offsetFromContainer(RenderObject* o, const LayoutPoint& point) const
     1377LayoutSize RenderBox::offsetFromContainer(RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
    13361378{
    13371379    ASSERT(o == container());
    … …  
    13511393            o->adjustForColumns(offset, columnPoint);
    13521394            offset = block->flipForWritingMode(offset);
     1395
     1396            if (offsetDependsOnPoint)
     1397                *offsetDependsOnPoint = true;
    13531398        } else
    13541399            offset += topLeftLocationOffset();

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

    r118291 r118567  
    277277    void clearOverrideSize();
    278278
    279     virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&) const;
     279    virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
    280280   
    281281    LayoutUnit computeBorderBoxLogicalWidth(LayoutUnit width) const;
    … …  
    520520
    521521    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     522    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject*, RenderGeometryMap&) const;
    522523    virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;
    523524

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

    r118094 r118567  
    3333#include "RenderBlock.h"
    3434#include "RenderFlowThread.h"
     35#include "RenderGeometryMap.h"
    3536#include "RenderLayer.h"
    3637#include "RenderTheme.h"
    … …  
    10661067}
    10671068
    1068 LayoutSize RenderInline::offsetFromContainer(RenderObject* container, const LayoutPoint& point) const
     1069LayoutSize RenderInline::offsetFromContainer(RenderObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
    10691070{
    10701071    ASSERT(container == this->container());
    … …  
    10781079    if (container->hasOverflowClip())
    10791080        offset -= toRenderBox(container)->scrolledContentOffset();
     1081
     1082    if (offsetDependsOnPoint)
     1083        *offsetDependsOnPoint = container->hasColumns();
    10801084
    10811085    return offset;
    … …  
    11281132
    11291133    o->mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, applyContainerFlip, wasFixed);
     1134}
     1135
     1136const RenderObject* RenderInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     1137{
     1138    ASSERT(ancestorToStopAt != this);
     1139
     1140    bool ancestorSkipped;
     1141    RenderObject* container = this->container(ancestorToStopAt, &ancestorSkipped);
     1142    if (!container)
     1143        return 0;
     1144
     1145    bool offsetDependsOnPoint = false;
     1146
     1147    if (container->isBox() && container->style()->isFlippedBlocksWritingMode())
     1148        offsetDependsOnPoint = true;
     1149
     1150    LayoutSize adjustmentForSkippedAncestor;
     1151    if (ancestorSkipped) {
     1152        // There can't be a transform between repaintContainer and o, because transforms create containers, so it should be safe
     1153        // to just subtract the delta between the ancestor and o.
     1154        adjustmentForSkippedAncestor = -ancestorToStopAt->offsetFromAncestorContainer(container);
     1155    }
     1156
     1157    LayoutSize containerOffset = offsetFromContainer(container, LayoutPoint(), &offsetDependsOnPoint);
     1158
     1159    bool preserve3D = container->style()->preserves3D() || style()->preserves3D();
     1160    if (shouldUseTransformFromContainer(container)) {
     1161        TransformationMatrix t;
     1162        getTransformFromContainer(container, containerOffset, t);
     1163        t.translateRight(adjustmentForSkippedAncestor.width(), adjustmentForSkippedAncestor.height()); // FIXME: right?
     1164        geometryMap.push(this, t, preserve3D, offsetDependsOnPoint);
     1165    } else {
     1166        containerOffset += adjustmentForSkippedAncestor;
     1167        geometryMap.push(this, containerOffset, preserve3D, offsetDependsOnPoint);
     1168    }
     1169   
     1170    return ancestorSkipped ? ancestorToStopAt : container;
    11301171}
    11311172

  • trunk/Source/WebCore/rendering/RenderInline.h

    r117946 r118567  
    5050    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
    5151
    52     virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&) const;
     52    virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
    5353
    5454    IntRect linesBoundingBox() const;
    … …  
    135135
    136136    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     137    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
    137138
    138139    virtual VisiblePosition positionForPoint(const LayoutPoint&);

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

    r118562 r118567  
    4646#include "RenderEmbeddedObject.h"
    4747#include "RenderFullScreen.h"
     48#include "RenderGeometryMap.h"
    4849#include "RenderIFrame.h"
    4950#include "RenderLayerBacking.h"
    … …  
    5556#include "Settings.h"
    5657#include "TiledBacking.h"
     58#include "TransformState.h"
    5759
    5860#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
    … …  
    399401        if (m_compositingConsultsOverlap) {
    400402            OverlapMap overlapTestRequestMap;
    401             computeCompositingRequirements(updateRoot, &overlapTestRequestMap, compState, layersChanged);
     403            RenderGeometryMap geometryMap;
     404            computeCompositingRequirements(0, updateRoot, &geometryMap, &overlapTestRequestMap, compState, layersChanged);
    402405        } else
    403             computeCompositingRequirements(updateRoot, 0, compState, layersChanged);
     406            computeCompositingRequirements(0, updateRoot, 0, 0, compState, layersChanged);
    404407       
    405408        needHierarchyUpdate |= layersChanged;
    … …  
    628631}
    629632
    630 void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)
     633void RenderLayerCompositor::addToOverlapMap(RenderGeometryMap& geometryMap, OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)
    631634{
    632635    if (layer->isRootLayer())
    … …  
    634637
    635638    if (!boundsComputed) {
    636         layerBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();
     639        layerBounds = enclosingIntRect(geometryMap.absoluteRect(layer->localBoundingBox()));
    637640        // Empty rects never intersect, but we need them to for the purposes of overlap testing.
    638641        if (layerBounds.isEmpty())
    … …  
    647650}
    648651
    649 void RenderLayerCompositor::addToOverlapMapRecursive(OverlapMap& overlapMap, RenderLayer* layer)
     652void RenderLayerCompositor::addToOverlapMapRecursive(RenderGeometryMap& geometryMap, OverlapMap& overlapMap, RenderLayer* layer, RenderLayer* ancestorLayer)
    650653{
    651654    if (!canBeComposited(layer) || overlapMap.contains(layer))
    652655        return;
    653656
     657    // A null ancestorLayer is an indication that 'layer' has already been pushed.
     658    if (ancestorLayer)
     659        geometryMap.pushMappingsToAncestor(layer->renderer(), ancestorLayer->renderer());
     660   
    654661    IntRect bounds;
    655662    bool haveComputedBounds = false;
    656     addToOverlapMap(overlapMap, layer, bounds, haveComputedBounds);
     663    addToOverlapMap(geometryMap, overlapMap, layer, bounds, haveComputedBounds);
    657664
    658665#if !ASSERT_DISABLED
    … …  
    665672            for (size_t i = 0; i < listSize; ++i) {
    666673                RenderLayer* curLayer = negZOrderList->at(i);
    667                 addToOverlapMapRecursive(overlapMap, curLayer);
     674                addToOverlapMapRecursive(geometryMap, overlapMap, curLayer, layer);
    668675            }
    669676        }
    … …  
    674681        for (size_t i = 0; i < listSize; ++i) {
    675682            RenderLayer* curLayer = normalFlowList->at(i);
    676             addToOverlapMapRecursive(overlapMap, curLayer);
     683            addToOverlapMapRecursive(geometryMap, overlapMap, curLayer, layer);
    677684        }
    678685    }
    … …  
    683690            for (size_t i = 0; i < listSize; ++i) {
    684691                RenderLayer* curLayer = posZOrderList->at(i);
    685                 addToOverlapMapRecursive(overlapMap, curLayer);
     692                addToOverlapMapRecursive(geometryMap, overlapMap, curLayer, layer);
    686693            }
    687694        }
    688695    }
     696   
     697    if (ancestorLayer)
     698        geometryMap.popMappingsToAncestor(ancestorLayer->renderer());
    689699}
    690700
    … …  
    698708//      This implies that its positive z-index children must also be compositing.
    699709//
    700 void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, OverlapMap* overlapMap, CompositingState& compositingState, bool& layersChanged)
     710void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, RenderGeometryMap* geometryMap, OverlapMap* overlapMap, CompositingState& compositingState, bool& layersChanged)
    701711{
    702712    layer->updateLayerListsIfNeeded();
    703 
     713   
     714    // Should geometryMap be part of the overlap map?
     715    if (geometryMap)
     716        geometryMap->pushMappingsToAncestor(layer->renderer(), ancestorLayer ? ancestorLayer->renderer() : 0);
     717   
    704718    // Clear the flag
    705719    layer->setHasCompositingDescendant(false);
    … …  
    711725    if (overlapMap && !overlapMap->isEmpty() && compositingState.m_testingOverlap) {
    712726        // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
    713         absBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();
     727        absBounds = enclosingIntRect(geometryMap->absoluteRect(layer->localBoundingBox()));
     728
    714729        // Empty rects never intersect, but we need them to for the purposes of overlap testing.
    715730        if (absBounds.isEmpty())
    … …  
    760775            for (size_t i = 0; i < listSize; ++i) {
    761776                RenderLayer* curLayer = negZOrderList->at(i);
    762                 computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged);
     777                computeCompositingRequirements(layer, curLayer, geometryMap, overlapMap, childState, layersChanged);
    763778
    764779                // If we have to make a layer for this child, make one now so we can have a contents layer
    … …  
    780795        for (size_t i = 0; i < listSize; ++i) {
    781796            RenderLayer* curLayer = normalFlowList->at(i);
    782             computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged);
     797            computeCompositingRequirements(layer, curLayer, geometryMap, overlapMap, childState, layersChanged);
    783798        }
    784799    }
    … …  
    789804            for (size_t i = 0; i < listSize; ++i) {
    790805                RenderLayer* curLayer = posZOrderList->at(i);
    791                 computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged);
     806                computeCompositingRequirements(layer, curLayer, geometryMap, overlapMap, childState, layersChanged);
    792807            }
    793808        }
    … …  
    806821    // compositing ancestor's backing, and so are still considered for overlap.
    807822    if (overlapMap && childState.m_compositingAncestor && !childState.m_compositingAncestor->isRootLayer())
    808         addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
     823        addToOverlapMap(*geometryMap, *overlapMap, layer, absBounds, haveComputedBounds);
    809824
    810825    // If we have a software transform, and we have layers under us, we need to also
    … …  
    816831        if (overlapMap) {
    817832            overlapMap->pushCompositingContainer();
    818             addToOverlapMapRecursive(*overlapMap, layer);
     833            addToOverlapMapRecursive(*geometryMap, *overlapMap, layer);
    819834        }
    820835        willBeComposited = true;
    … …  
    845860            if (overlapMap) {
    846861                overlapMap->pushCompositingContainer();
    847                 addToOverlapMapRecursive(*overlapMap, layer);
     862                addToOverlapMapRecursive(*geometryMap, *overlapMap, layer);
    848863            }
    849864            willBeComposited = true;
    … …  
    876891    if (layer->reflectionLayer() && updateLayerCompositingState(layer->reflectionLayer(), CompositingChangeRepaintNow))
    877892        layersChanged = true;
     893
     894    if (geometryMap)
     895        geometryMap->popMappingsToAncestor(ancestorLayer ? ancestorLayer->renderer() : 0);
    878896}
    879897

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.h

    r115992 r118567  
    3535class GraphicsLayer;
    3636class RenderEmbeddedObject;
     37class RenderGeometryMap;
    3738class RenderPart;
    3839class ScrollingCoordinator;
    … …  
    239240    void recursiveRepaintLayerRect(RenderLayer*, const IntRect&);
    240241
    241     void addToOverlapMap(OverlapMap&, RenderLayer*, IntRect& layerBounds, bool& boundsComputed);
    242     void addToOverlapMapRecursive(OverlapMap&, RenderLayer*);
     242    void addToOverlapMap(RenderGeometryMap&, OverlapMap&, RenderLayer*, IntRect& layerBounds, bool& boundsComputed);
     243    void addToOverlapMapRecursive(RenderGeometryMap&, OverlapMap&, RenderLayer*, RenderLayer* ancestorLayer = 0);
    243244
    244245    void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*);
    245246
    246247    // Returns true if any layer's compositing changed
    247     void computeCompositingRequirements(RenderLayer*, OverlapMap*, struct CompositingState&, bool& layersChanged);
     248    void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer*, RenderGeometryMap*, OverlapMap*, struct CompositingState&, bool& layersChanged);
    248249   
    249250    // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.

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

    r118542 r118567  
    4747#include "RenderDeprecatedFlexibleBox.h"
    4848#include "RenderFlexibleBox.h"
     49#include "RenderGeometryMap.h"
    4950#include "RenderImage.h"
    5051#include "RenderImageResourceStyleImage.h"
    … …  
    20312032        return;
    20322033
     2034    // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
    20332035    LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
    20342036    if (o->isBox() && o->style()->isFlippedBlocksWritingMode())
    … …  
    20442046
    20452047    o->mapLocalToContainer(repaintContainer, fixed, useTransforms, transformState, DoNotApplyContainerFlip, wasFixed);
     2048}
     2049
     2050const RenderObject* RenderObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     2051{
     2052    ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != this);
     2053
     2054    RenderObject* container = parent();
     2055    if (!container)
     2056        return 0;
     2057
     2058    // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
     2059    LayoutSize offset;
     2060    if (container->hasOverflowClip())
     2061        offset = -toRenderBox(container)->scrolledContentOffset();
     2062
     2063    geometryMap.push(this, offset, hasColumns());
     2064   
     2065    return container;
    20462066}
    20472067
    … …  
    21142134}
    21152135
    2116 LayoutSize RenderObject::offsetFromContainer(RenderObject* o, const LayoutPoint& point) const
     2136LayoutSize RenderObject::offsetFromContainer(RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
    21172137{
    21182138    ASSERT(o == container());
    … …  
    21242144    if (o->hasOverflowClip())
    21252145        offset -= toRenderBox(o)->scrolledContentOffset();
     2146
     2147    if (offsetDependsOnPoint)
     2148        *offsetDependsOnPoint = hasColumns();
    21262149
    21272150    return offset;
    … …  
    22002223}
    22012224
    2202 RenderObject* RenderObject::container(RenderBoxModelObject* repaintContainer, bool* repaintContainerSkipped) const
     2225RenderObject* RenderObject::container(const RenderBoxModelObject* repaintContainer, bool* repaintContainerSkipped) const
    22032226{
    22042227    if (repaintContainerSkipped)

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

    r118552 r118567  
    6161class RenderBlock;
    6262class RenderFlowThread;
     63class RenderGeometryMap;
    6364class RenderLayer;
    6465class RenderTable;
    … …  
    587588    // If repaintContainer and repaintContainerSkipped are not null, on return *repaintContainerSkipped
    588589    // is true if the renderer returned is an ancestor of repaintContainer.
    589     RenderObject* container(RenderBoxModelObject* repaintContainer = 0, bool* repaintContainerSkipped = 0) const;
     590    RenderObject* container(const RenderBoxModelObject* repaintContainer = 0, bool* repaintContainerSkipped = 0) const;
    590591
    591592    virtual RenderObject* hoverAncestor() const { return parent(); }
    … …  
    688689    // Return the offset from the container() renderer (excluding transforms). In multi-column layout,
    689690    // different offsets apply at different points, so return the offset that applies to the given point.
    690     virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&) const;
     691    virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
    691692    // Return the offset from an object up the container() chain. Asserts that none of the intermediate objects have transforms.
    692693    LayoutSize offsetFromAncestorContainer(RenderObject*) const;
    … …  
    885886    virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;
    886887
     888    // Pushes state onto RenderGeometryMap about how to map coordinates from this renderer to its container, or ancestorToStopAt (whichever is encountered first).
     889    // Returns the renderer which was mapped to (container or ancestorToStopAt).
     890    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
     891   
    887892    bool shouldUseTransformFromContainer(const RenderObject* container) const;
    888893    void getTransformFromContainer(const RenderObject* container, const LayoutSize& offsetInContainer, TransformationMatrix&) const;

  • trunk/Source/WebCore/rendering/RenderTableCell.cpp

    r117988 r118567  
    241241}
    242242
    243 LayoutSize RenderTableCell::offsetFromContainer(RenderObject* o, const LayoutPoint& point) const
     243LayoutSize RenderTableCell::offsetFromContainer(RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
    244244{
    245245    ASSERT(o == container());
    246246
    247     LayoutSize offset = RenderBlock::offsetFromContainer(o, point);
     247    LayoutSize offset = RenderBlock::offsetFromContainer(o, point, offsetDependsOnPoint);
    248248    if (parent())
    249249        offset.expand(-parentBox()->x(), -parentBox()->y());

  • trunk/Source/WebCore/rendering/RenderTableCell.h

    r115755 r118567  
    153153    virtual bool boxShadowShouldBeAppliedToBackground(BackgroundBleedAvoidance, InlineFlowBox*) const OVERRIDE;
    154154
    155     virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&) const;
     155    virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = 0) const;
    156156    virtual LayoutRect clippedOverflowRectForRepaint(RenderBoxModelObject* repaintContainer) const;
    157157    virtual void computeRectForRepaint(RenderBoxModelObject* repaintContainer, LayoutRect&, bool fixed = false) const;

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

    r118039 r118567  
    3333#include "HitTestResult.h"
    3434#include "Page.h"
     35#include "RenderGeometryMap.h"
    3536#include "RenderLayer.h"
    3637#include "RenderNamedFlowThread.h"
    … …  
    166167    if (fixed && m_frameView)
    167168        transformState.move(m_frameView->scrollOffsetForFixedPosition());
     169}
     170
     171const RenderObject* RenderView::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     172{
     173    // If a container was specified, and was not 0 or the RenderView,
     174    // then we should have found it by now.
     175    ASSERT_ARG(ancestorToStopAt, !ancestorToStopAt || ancestorToStopAt == this);
     176
     177    LayoutSize scrollOffset;
     178
     179    if (m_frameView)
     180        scrollOffset = m_frameView->scrollOffsetForFixedPosition();
     181
     182    if (!ancestorToStopAt && shouldUseTransformFromContainer(0)) {
     183        TransformationMatrix t;
     184        getTransformFromContainer(0, LayoutSize(), t);
     185        geometryMap.pushView(this, scrollOffset, &t);
     186    } else
     187        geometryMap.pushView(this, scrollOffset);
     188
     189    return 0;
    168190}
    169191

  • trunk/Source/WebCore/rendering/RenderView.h

    r118039 r118567  
    189189protected:
    190190    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     191    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
    191192    virtual void mapAbsoluteToLocalPoint(bool fixed, bool useTransforms, TransformState&) const;
    192193    virtual bool requiresColumns(int desiredColumnCount) const OVERRIDE;

  • trunk/Source/WebCore/rendering/svg/RenderSVGForeignObject.cpp

    r115981 r118567  
    194194}
    195195
     196const RenderObject* RenderSVGForeignObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     197{
     198    return SVGRenderSupport::pushMappingToContainer(this, ancestorToStopAt, geometryMap);
     199}
     200
    196201}
    197202

  • trunk/Source/WebCore/rendering/svg/RenderSVGForeignObject.h

    r115981 r118567  
    5656
    5757    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     58    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
    5859    virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }
    5960

  • trunk/Source/WebCore/rendering/svg/RenderSVGInline.cpp

    r117975 r118567  
    8585}
    8686
     87const RenderObject* RenderSVGInline::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     88{
     89    return SVGRenderSupport::pushMappingToContainer(this, ancestorToStopAt, geometryMap);
     90}
     91
    8792void RenderSVGInline::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
    8893{

  • trunk/Source/WebCore/rendering/svg/RenderSVGInline.h

    r117225 r118567  
    4949    virtual void computeFloatRectForRepaint(RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed = false) const;
    5050    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     51    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
    5152    virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
    5253

  • trunk/Source/WebCore/rendering/svg/RenderSVGModelObject.cpp

    r115981 r118567  
    5959{
    6060    SVGRenderSupport::mapLocalToContainer(this, repaintContainer, transformState, wasFixed);
     61}
     62
     63const RenderObject* RenderSVGModelObject::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     64{
     65    return SVGRenderSupport::pushMappingToContainer(this, ancestorToStopAt, geometryMap);
    6166}
    6267

  • trunk/Source/WebCore/rendering/svg/RenderSVGModelObject.h

    r115981 r118567  
    6060
    6161    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     62    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
    6263    virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
    6364    virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);

  • trunk/Source/WebCore/rendering/svg/RenderSVGRoot.cpp

    r118074 r118567  
    392392}
    393393
     394const RenderObject* RenderSVGRoot::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     395{
     396    return RenderReplaced::pushMappingToContainer(ancestorToStopAt, geometryMap);
     397}
     398
    394399void RenderSVGRoot::updateCachedBoundaries()
    395400{

  • trunk/Source/WebCore/rendering/svg/RenderSVGRoot.h

    r115981 r118567  
    9696
    9797    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     98    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
     99
    98100    virtual bool canBeSelectionLeaf() const { return false; }
    99101    virtual bool canHaveChildren() const { return true; }

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp

    r117977 r118567  
    116116}
    117117
     118const RenderObject* RenderSVGText::pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
     119{
     120    return SVGRenderSupport::pushMappingToContainer(this, ancestorToStopAt, geometryMap);
     121}
     122
    118123static inline void collectLayoutAttributes(RenderObject* text, Vector<SVGTextLayoutAttributes*>& attributes)
    119124{

  • trunk/Source/WebCore/rendering/svg/RenderSVGText.h

    r117975 r118567  
    7777
    7878    virtual void mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool useTransforms, bool fixed, TransformState&, ApplyContainerFlipOrNot = ApplyContainerFlip, bool* wasFixed = 0) const;
     79    virtual const RenderObject* pushMappingToContainer(const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&) const;
    7980    virtual void addChild(RenderObject* child, RenderObject* beforeChild = 0);
    8081    virtual void removeChild(RenderObject*) OVERRIDE;

  • trunk/Source/WebCore/rendering/svg/SVGRenderSupport.cpp

    r117225 r118567  
    2929
    3030#include "NodeRenderStyle.h"
     31#include "RenderGeometryMap.h"
    3132#include "RenderLayer.h"
    3233#include "RenderSVGResource.h"
    … …  
    8687}
    8788
     89const RenderObject* SVGRenderSupport::pushMappingToContainer(const RenderObject* object, const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap)
     90{
     91    ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != object);
     92
     93    RenderObject* parent = object->parent();
     94
     95    // At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform
     96    // to map an element from SVG viewport coordinates to CSS box coordinates.
     97    // RenderSVGRoot's mapLocalToContainer method expects CSS box coordinates.
     98    if (parent->isSVGRoot())
     99        geometryMap.push(object, TransformationMatrix(toRenderSVGRoot(parent)->localToBorderBoxTransform()));
     100    else
     101        geometryMap.push(object, LayoutSize());
     102
     103    return parent;
     104}
     105
    88106// Update a bounding box taking into account the validity of the other bounding box.
    89107static inline void updateObjectBoundingBox(FloatRect& objectBoundingBox, bool& objectBoundingBoxValid, RenderObject* other, FloatRect otherBoundingBox)

  • trunk/Source/WebCore/rendering/svg/SVGRenderSupport.h

    r112091 r118567  
    3535class ImageBuffer;
    3636class RenderBoxModelObject;
     37class RenderGeometryMap;
    3738class RenderObject;
    3839class RenderStyle;
    … …  
    6566    static void computeFloatRectForRepaint(const RenderObject*, RenderBoxModelObject* repaintContainer, FloatRect&, bool fixed);
    6667    static void mapLocalToContainer(const RenderObject*, RenderBoxModelObject* repaintContainer, TransformState&, bool* wasFixed = 0);
     68    static const RenderObject* pushMappingToContainer(const RenderObject*, const RenderBoxModelObject* ancestorToStopAt, RenderGeometryMap&);
    6769
    6870    // Shared between SVG renderers and resources.
Note: See TracChangeset for help on using the changeset viewer.