Changeset 91760 in webkit


Ignore:
Timestamp:
Jul 26, 2011 10:11:08 AM (13 years ago)
Author:
commit-queue@webkit.org
Message:

[CSSRegions] Collect flowed elements in different render element
https://bugs.webkit.org/show_bug.cgi?id=64516

Source/WebCore:

All the RenderObjects that have a specified "flow" name are moved out of the
normal flow. A RenderFlowThread will collect all such RenderObjects. There is
a RenderFlowThread for each flow name. The new RenderFlowThread is an anonymous
RenderBlock that is positioned absolute and will not render directly. In a
different bug/patch we will add RenderRegion that will take care of rendering the
RenderFlowThread on screen.

Patch by Alexandru Chiculita <Alexandru Chiculita> on 2011-07-26
Reviewed by Simon Fraser.

Tests: fast/regions/webkit-flow-renderer-layer.html

fast/regions/webkit-flow-renderer-nested.html
fast/regions/webkit-flow-renderer.html

  • WebCore.vcproj/WebCore.vcproj:
  • WebCore.xcodeproj/project.pbxproj:
  • dom/Node.cpp:

(WebCore::Node::diff):

  • dom/NodeRenderingContext.cpp:

(WebCore::NodeRenderingContext::NodeRenderingContext):
(WebCore::NodeRenderingContext::setStyle):
(WebCore::NodeRenderingContext::nextRenderer):
(WebCore::NodeRenderingContext::previousRenderer):
(WebCore::NodeRenderingContext::parentRenderer):
(WebCore::NodeRenderingContext::moveToFlowThreadIfNeeded):
(WebCore::NodeRendererFactory::createRendererIfNeeded):

  • dom/NodeRenderingContext.h:

(WebCore::NodeRenderingContext::hasFlowThreadParent):
(WebCore::NodeRenderingContext::parentFlowRenderer):

  • rendering/RenderFlowThread.cpp: Added.

(WebCore::RenderFlowThread::RenderFlowThread):
(WebCore::RenderFlowThread::createFlowThreadStyle):
(WebCore::RenderFlowThread::nextRendererForNode):
(WebCore::RenderFlowThread::previousRendererForNode):
(WebCore::RenderFlowThread::addChild):
(WebCore::RenderFlowThread::removeChild):

  • rendering/RenderFlowThread.h: Added.

(WebCore::toRenderFlowThread):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::collectLayers):

  • rendering/RenderObject.h:

(WebCore::RenderObject::isRenderFlowThread):

  • rendering/RenderTreeAsText.cpp:

(WebCore::RenderTreeAsText::writeRenderObject):
(WebCore::writeLayers):

  • rendering/RenderView.cpp:

(WebCore::RenderView::renderFlowThreadWithName):

  • rendering/RenderView.h:
  • rendering/style/RenderStyle.cpp:

(WebCore::RenderStyle::diff):

LayoutTests:

Patch by Alexandru Chiculita <Alexandru Chiculita> on 2011-07-26
Reviewed by Simon Fraser.

  • fast/regions/webkit-flow-renderer-expected.txt: Added.
  • fast/regions/webkit-flow-renderer-layer-expected.txt: Added.
  • fast/regions/webkit-flow-renderer-layer.html: Added.
  • fast/regions/webkit-flow-renderer-nested-expected.txt: Added.
  • fast/regions/webkit-flow-renderer-nested.html: Added.
  • fast/regions/webkit-flow-renderer.html: Added.
Location:
trunk
Files:
8 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r91759 r91760  
     12011-07-26  Alexandru Chiculita  <achicu@adobe.com>
     2
     3        [CSSRegions] Collect flowed elements in different render element
     4        https://bugs.webkit.org/show_bug.cgi?id=64516
     5
     6        Reviewed by Simon Fraser.
     7
     8        * fast/regions/webkit-flow-renderer-expected.txt: Added.
     9        * fast/regions/webkit-flow-renderer-layer-expected.txt: Added.
     10        * fast/regions/webkit-flow-renderer-layer.html: Added.
     11        * fast/regions/webkit-flow-renderer-nested-expected.txt: Added.
     12        * fast/regions/webkit-flow-renderer-nested.html: Added.
     13        * fast/regions/webkit-flow-renderer.html: Added.
     14
    1152011-07-26  Patrick Dubroy  <dubroy@chromium.org>
    216
  • trunk/Source/WebCore/ChangeLog

    r91759 r91760  
     12011-07-26  Alexandru Chiculita  <achicu@adobe.com>
     2
     3        [CSSRegions] Collect flowed elements in different render element
     4        https://bugs.webkit.org/show_bug.cgi?id=64516
     5
     6        All the RenderObjects that have a specified "flow" name are moved out of the
     7        normal flow. A RenderFlowThread will collect all such RenderObjects. There is
     8        a RenderFlowThread for each flow name. The new RenderFlowThread is an anonymous
     9        RenderBlock that is positioned absolute and will not render directly. In a
     10        different bug/patch we will add RenderRegion that will take care of rendering the
     11        RenderFlowThread on screen.
     12
     13        Reviewed by Simon Fraser.
     14
     15        Tests: fast/regions/webkit-flow-renderer-layer.html
     16               fast/regions/webkit-flow-renderer-nested.html
     17               fast/regions/webkit-flow-renderer.html
     18
     19        * WebCore.vcproj/WebCore.vcproj:
     20        * WebCore.xcodeproj/project.pbxproj:
     21        * dom/Node.cpp:
     22        (WebCore::Node::diff):
     23        * dom/NodeRenderingContext.cpp:
     24        (WebCore::NodeRenderingContext::NodeRenderingContext):
     25        (WebCore::NodeRenderingContext::setStyle):
     26        (WebCore::NodeRenderingContext::nextRenderer):
     27        (WebCore::NodeRenderingContext::previousRenderer):
     28        (WebCore::NodeRenderingContext::parentRenderer):
     29        (WebCore::NodeRenderingContext::moveToFlowThreadIfNeeded):
     30        (WebCore::NodeRendererFactory::createRendererIfNeeded):
     31        * dom/NodeRenderingContext.h:
     32        (WebCore::NodeRenderingContext::hasFlowThreadParent):
     33        (WebCore::NodeRenderingContext::parentFlowRenderer):
     34        * rendering/RenderFlowThread.cpp: Added.
     35        (WebCore::RenderFlowThread::RenderFlowThread):
     36        (WebCore::RenderFlowThread::createFlowThreadStyle):
     37        (WebCore::RenderFlowThread::nextRendererForNode):
     38        (WebCore::RenderFlowThread::previousRendererForNode):
     39        (WebCore::RenderFlowThread::addChild):
     40        (WebCore::RenderFlowThread::removeChild):
     41        * rendering/RenderFlowThread.h: Added.
     42        (WebCore::toRenderFlowThread):
     43        * rendering/RenderLayer.cpp:
     44        (WebCore::RenderLayer::collectLayers):
     45        * rendering/RenderObject.h:
     46        (WebCore::RenderObject::isRenderFlowThread):
     47        * rendering/RenderTreeAsText.cpp:
     48        (WebCore::RenderTreeAsText::writeRenderObject):
     49        (WebCore::writeLayers):
     50        * rendering/RenderView.cpp:
     51        (WebCore::RenderView::renderFlowThreadWithName):
     52        * rendering/RenderView.h:
     53        * rendering/style/RenderStyle.cpp:
     54        (WebCore::RenderStyle::diff):
     55
    1562011-07-26  Patrick Dubroy  <dubroy@chromium.org>
    257
  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r91643 r91760  
    3487534875                        </File>
    3487634876                        <File
     34877                                RelativePath="..\rendering\RenderFlowThread.cpp"
     34878                                >
     34879                        </File>
     34880                        <File
     34881                                RelativePath="..\rendering\RenderFlowThread.h"
     34882                                >
     34883                        </File>
     34884                        <File
    3487734885                                RelativePath="..\rendering\svg\RenderForeignObject.cpp"
    3487834886                                >
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r91643 r91760  
    13201320                501BA9E21393CEA000F7ACEB /* CSSWrapShapes.h in Headers */ = {isa = PBXBuildFile; fileRef = 501BA9E11393CEA000F7ACEB /* CSSWrapShapes.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13211321                501BAAA913950E2C00F7ACEB /* WindRule.h in Headers */ = {isa = PBXBuildFile; fileRef = 501BAAA813950E2C00F7ACEB /* WindRule.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1322                508CCA4F13CF106B003151F3 /* RenderFlowThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 508CCA4D13CF106B003151F3 /* RenderFlowThread.h */; };
     1323                508CCA5013CF106B003151F3 /* RenderFlowThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */; };
    13221324                50E566D6139E38C500214433 /* CSSWrapShapes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 501BAAB11395114B00F7ACEB /* CSSWrapShapes.cpp */; };
    13231325                510184690B08602A004A825F /* CachedPage.h in Headers */ = {isa = PBXBuildFile; fileRef = 510184670B08602A004A825F /* CachedPage.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    78957897                501BAAA813950E2C00F7ACEB /* WindRule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WindRule.h; sourceTree = "<group>"; };
    78967898                501BAAB11395114B00F7ACEB /* CSSWrapShapes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSWrapShapes.cpp; sourceTree = "<group>"; };
     7899                508CCA4D13CF106B003151F3 /* RenderFlowThread.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderFlowThread.h; sourceTree = "<group>"; };
     7900                508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderFlowThread.cpp; sourceTree = "<group>"; };
    78977901                510184670B08602A004A825F /* CachedPage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedPage.h; sourceTree = "<group>"; };
    78987902                510184680B08602A004A825F /* CachedPage.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CachedPage.cpp; sourceTree = "<group>"; };
     
    1961119615                                37FC96DA1104ED71003E1FAD /* TrailingFloatsRootInlineBox.h */,
    1961219616                                BCA257141293C010007A263D /* VerticalPositionCache.h */,
     19617                                508CCA4D13CF106B003151F3 /* RenderFlowThread.h */,
     19618                                508CCA4E13CF106B003151F3 /* RenderFlowThread.cpp */,
    1961319619                        );
    1961419620                        path = rendering;
     
    2325223258                                977E2E0F12F0FC9C00C13379 /* XSSAuditor.h in Headers */,
    2325323259                                FD537353137B651800008DCE /* ZeroPole.h in Headers */,
     23260                                508CCA4F13CF106B003151F3 /* RenderFlowThread.h in Headers */,
    2325423261                        );
    2325523262                        runOnlyForDeploymentPostprocessing = 0;
     
    2603826045                                977E2E0E12F0FC9C00C13379 /* XSSAuditor.cpp in Sources */,
    2603926046                                FD537352137B651800008DCE /* ZeroPole.cpp in Sources */,
     26047                                508CCA5013CF106B003151F3 /* RenderFlowThread.cpp in Sources */,
    2604026048                        );
    2604126049                        runOnlyForDeploymentPostprocessing = 0;
  • trunk/Source/WebCore/dom/Node.cpp

    r91404 r91760  
    358358        ch = Detach;
    359359
     360#if ENABLE(CSS_REGIONS)
     361    // We need to reattach the node, so that it is moved to the correct RenderFlowThread.
     362    if ((s1 && s2) && (s1->flowThread() != s2->flowThread()))
     363        ch = Detach;
     364#endif
     365
    360366    return ch;
    361367}
  • trunk/Source/WebCore/dom/NodeRenderingContext.cpp

    r91548 r91760  
    2929#include "ContainerNode.h"
    3030#include "Node.h"
     31#include "RenderFlowThread.h"
    3132#include "RenderFullScreen.h"
    3233#include "RenderObject.h"
     34#include "RenderView.h"
    3335#include "ShadowContentElement.h"
    3436#include "ShadowInclusionSelector.h"
     
    4547    , m_includer(0)
    4648    , m_style(0)
     49#if ENABLE(CSS_REGIONS)
     50    , m_parentFlowRenderer(0)
     51#endif
    4752{
    4853    ContainerNode* parent = m_node->parentOrHostNode();
     
    8590    , m_includer(0)
    8691    , m_style(style)
     92#if ENABLE(CSS_REGIONS)
     93    , m_parentFlowRenderer(0)
     94#endif
    8795{
    8896}
     
    95103{
    96104    m_style = style;
     105#if ENABLE(CSS_REGIONS)
     106    moveToFlowThreadIfNeeded();
     107#endif
    97108}
    98109
     
    156167        return renderer->nextSibling();
    157168
     169#if ENABLE(CSS_REGIONS)
     170    if (m_parentFlowRenderer)
     171        return m_parentFlowRenderer->nextRendererForNode(m_node);
     172#endif
     173
    158174    if (m_phase == AttachContentForwarded) {
    159175        if (RenderObject* found = nextRendererOf(m_includer, m_node))
     
    168184
    169185    for (Node* node = m_node->nextSibling(); node; node = node->nextSibling()) {
    170         if (node->renderer())
     186        if (node->renderer()) {
     187#if ENABLE(CSS_REGIONS)
     188            // Do not return elements that are attached to a different flow-thread.
     189            if (node->renderer()->style() && !node->renderer()->style()->flowThread().isEmpty())
     190                continue;
     191#endif
    171192            return node->renderer();
     193        }
    172194        if (node->isContentElement()) {
    173195            if (RenderObject* first = firstRendererOf(toShadowContentElement(node)))
     
    184206    if (RenderObject* renderer = m_node->renderer())
    185207        return renderer->previousSibling();
     208
     209#if ENABLE(CSS_REGIONS)
     210    if (m_parentFlowRenderer)
     211        return m_parentFlowRenderer->previousRendererForNode(m_node);
     212#endif
    186213
    187214    if (m_phase == AttachContentForwarded) {
     
    194221    // however, when I tried adding it, several tests failed.
    195222    for (Node* node = m_node->previousSibling(); node; node = node->previousSibling()) {
    196         if (node->renderer())
     223        if (node->renderer()) {
     224#if ENABLE(CSS_REGIONS)
     225            // Do not return elements that are attached to a different flow-thread.
     226            if (node->renderer()->style() && !node->renderer()->style()->flowThread().isEmpty())
     227                continue;
     228#endif
    197229            return node->renderer();
     230        }
    198231        if (node->isContentElement()) {
    199232            if (RenderObject* last = lastRendererOf(toShadowContentElement(node)))
     
    211244        return renderer->parent();
    212245    }
     246
     247#if ENABLE(CSS_REGIONS)
     248    if (m_parentFlowRenderer)
     249        return m_parentFlowRenderer;
     250#endif
    213251
    214252    ASSERT(m_location != LocationUndetermined);
     
    250288}
    251289
     290#if ENABLE(CSS_REGIONS)
     291void NodeRenderingContext::moveToFlowThreadIfNeeded()
     292{
     293    if (!m_node->isElementNode() || !m_style || m_style->flowThread().isEmpty())
     294        return;
     295
     296    m_flowThread = m_style->flowThread();
     297    ASSERT(m_node->document()->renderView());
     298    m_parentFlowRenderer = m_node->document()->renderView()->renderFlowThreadWithName(m_flowThread);
     299}
     300#endif
    252301
    253302NodeRendererFactory::NodeRendererFactory(Node* node)
     
    317366    RenderObject* newRenderer = createRendererAndStyle();
    318367
     368#if ENABLE(CSS_REGIONS)
     369    if (m_context.hasFlowThreadParent()) {
     370        parentRenderer = m_context.parentFlowRenderer();
     371        // Do not call m_context.nextRenderer() here, because it expects to have
     372        // the renderer added to its parent already.
     373        nextRenderer = m_context.parentFlowRenderer()->nextRendererForNode(node);
     374    }
     375#endif
     376
    319377#if ENABLE(FULLSCREEN_API)
    320378    if (document->webkitIsFullScreen() && document->webkitCurrentFullScreenElement() == node)
  • trunk/Source/WebCore/dom/NodeRenderingContext.h

    r91235 r91760  
    2929#include <wtf/Noncopyable.h>
    3030#include <wtf/RefPtr.h>
     31#include <wtf/text/AtomicString.h>
    3132
    3233namespace WebCore {
     
    3940class ShadowContentElement;
    4041class ShadowRoot;
     42
     43#if ENABLE(CSS_REGIONS)
     44class RenderFlowThread;
     45#endif
    4146
    4247class NodeRenderingContext {
     
    6166    void hostChildrenChanged();
    6267
     68#if ENABLE(CSS_REGIONS)
     69    bool hasFlowThreadParent() const { return m_parentFlowRenderer; }
     70    RenderFlowThread* parentFlowRenderer() const { return m_parentFlowRenderer; }
     71    void moveToFlowThreadIfNeeded();
     72#endif
    6373private:
    6474
     
    8393    ShadowContentElement* m_includer;
    8494    RefPtr<RenderStyle> m_style;
     95#if ENABLE(CSS_REGIONS)
     96    RenderFlowThread* m_parentFlowRenderer;
     97    AtomicString m_flowThread;
     98#endif
    8599};
    86100
  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r91436 r91760  
    38793879    updateVisibilityStatus();
    38803880
     3881#if ENABLE(CSS_REGIONS)
     3882    // Do not let the RenderFlowThread to render directly to screen. It will only render
     3883    // inside the RenderRegion objects, so avoid collecting it.
     3884    if (renderer()->isRenderFlowThread())
     3885        return;
     3886#endif
     3887
    38813888    // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
    38823889    if ((m_hasVisibleContent || (m_hasVisibleDescendant && isStackingContext())) && !isNormalFlowOnly()) {
  • trunk/Source/WebCore/rendering/RenderObject.h

    r91689 r91760  
    315315    virtual bool isRenderFullScreen() const { return false; }
    316316    virtual bool isRenderFullScreenPlaceholder() const { return false; }
     317#endif
     318
     319#if ENABLE(CSS_REGIONS)
     320    virtual bool isRenderFlowThread() const { return false; }
    317321#endif
    318322
  • trunk/Source/WebCore/rendering/RenderTreeAsText.cpp

    r89649 r91760  
    3939#include "RenderDetailsMarker.h"
    4040#include "RenderFileUploadControl.h"
     41#include "RenderFlowThread.h"
    4142#include "RenderInline.h"
    4243#include "RenderLayer.h"
     
    244245        }
    245246    }
    246 
     247   
    247248    bool adjustForTableCells = o.containingBlock()->isTableCell();
    248249
     
    706707            writeLayers(ts, rootLayer, posList->at(i), paintDirtyRect, currIndent, behavior);
    707708    }
     709   
     710#if ENABLE(CSS_REGIONS)
     711    // Altough the RenderFlowThread requires a layer, it is not collected by its parent,
     712    // so we have to treat it as a special case.
     713    bool firstRenderFlowThread = true;
     714    for (RenderObject* child = l->renderer()->firstChild(); child; child = child->nextSibling()) {
     715        if (child->isRenderFlowThread()) {
     716            if (firstRenderFlowThread) {
     717                firstRenderFlowThread = false;
     718                writeIndent(ts, indent);
     719                ts << "Flow Threads\n";
     720            }
     721            const RenderFlowThread* renderFlowThread = toRenderFlowThread(child);
     722            writeIndent(ts, indent + 1);
     723            ts << "Thread with flow-name '" << renderFlowThread->flowThread() << "'\n";
     724            RenderLayer* layer = renderFlowThread->layer();
     725            writeLayers(ts, rootLayer, layer, paintDirtyRect, indent + 2, behavior);
     726        }
     727    }
     728#endif
    708729}
    709730
  • trunk/Source/WebCore/rendering/RenderView.cpp

    r91436 r91760  
    3030#include "HTMLFrameOwnerElement.h"
    3131#include "HitTestResult.h"
     32#include "RenderFlowThread.h"
    3233#include "RenderLayer.h"
    3334#include "RenderSelectionInfo.h"
     
    783784}
    784785
     786#if ENABLE(CSS_REGIONS)
     787RenderFlowThread* RenderView::renderFlowThreadWithName(const AtomicString& flowThread)
     788{
     789    for (RenderObject* renderer = firstChild(); renderer; renderer = renderer->nextSibling()) {
     790        if (renderer->isRenderFlowThread()) {
     791            RenderFlowThread* flowRenderer = toRenderFlowThread(renderer);
     792            if (flowRenderer->flowThread() == flowThread)
     793                return flowRenderer;
     794        }
     795    }
     796
     797    RenderFlowThread* flowRenderer = new (renderArena()) RenderFlowThread(document(), flowThread);
     798    addChild(flowRenderer);
     799   
     800    return flowRenderer;
     801}
     802#endif
     803
    785804} // namespace WebCore
  • trunk/Source/WebCore/rendering/RenderView.h

    r91417 r91760  
    3232class RenderWidget;
    3333
     34#if ENABLE(CSS_REGIONS)
     35class RenderFlowThread;
     36#endif
     37
    3438#if USE(ACCELERATED_COMPOSITING)
    3539class RenderLayerCompositor;
     
    163167
    164168    IntRect documentRect() const;
     169
     170#if ENABLE(CSS_REGIONS)
     171    RenderFlowThread* renderFlowThreadWithName(const AtomicString& flowThread);
     172#endif
    165173
    166174protected:
  • trunk/Source/WebCore/rendering/style/RenderStyle.cpp

    r91392 r91760  
    350350
    351351#if ENABLE(CSS_REGIONS)
    352         if (rareNonInheritedData->m_flowThread != other->rareNonInheritedData->m_flowThread
    353             || rareNonInheritedData->m_regionThread != other->rareNonInheritedData->m_regionThread
     352        if (rareNonInheritedData->m_regionThread != other->rareNonInheritedData->m_regionThread
    354353            || rareNonInheritedData->m_regionIndex != other->rareNonInheritedData->m_regionIndex
    355354            || rareNonInheritedData->m_regionOverflow != other->rareNonInheritedData->m_regionOverflow)
Note: See TracChangeset for help on using the changeset viewer.