Changeset 172409 in webkit


Ignore:
Timestamp:
Aug 11, 2014 1:42:16 PM (10 years ago)
Author:
Antti Koivisto
Message:

Pass inherited style only when resolving tree style
https://bugs.webkit.org/show_bug.cgi?id=135799

Reviewed by Andreas Kling.

No need to pass around the style parent element.

  • dom/ContainerNode.h:

(WebCore::ContainerNode::childShouldCreateRenderer): Deleted.

  • dom/Element.cpp:

(WebCore::Element::childShouldCreateRenderer):

  • dom/Element.h:
  • style/StyleResolveTree.cpp:

(WebCore::Style::RenderTreePosition::parent):
(WebCore::Style::nextSiblingRenderer):
(WebCore::Style::RenderTreePosition::RenderTreePosition):
(WebCore::Style::RenderTreePosition::computeNextSibling):
(WebCore::Style::shouldCreateRenderer):
(WebCore::Style::styleForElement):
(WebCore::Style::createRendererIfNeeded):
(WebCore::Style::textRendererIsNeeded):
(WebCore::Style::createTextRendererIfNeeded):
(WebCore::Style::attachTextRenderer):
(WebCore::Style::updateTextRendererAfterContentChange):
(WebCore::Style::attachChildren):
(WebCore::Style::attachDistributedChildren):
(WebCore::Style::attachShadowRoot):
(WebCore::Style::attachBeforeOrAfterPseudoElementIfNeeded):
(WebCore::Style::attachRenderTree):
(WebCore::Style::resolveLocal):
(WebCore::Style::resolveTextNode):
(WebCore::Style::resolveShadowTree):
(WebCore::Style::updateBeforeOrAfterPseudoElement):
(WebCore::Style::resolveTree):

  • svg/SVGDocument.cpp:

(WebCore::SVGDocument::childShouldCreateRenderer): Deleted.

Implement this in SVGSVGElement::rendererIsNeeded instead.

  • svg/SVGDocument.h:
  • svg/SVGSVGElement.cpp:

(WebCore::SVGSVGElement::rendererIsNeeded):

Location:
trunk/Source/WebCore
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r172408 r172409  
     12014-08-11  Antti Koivisto  <antti@apple.com>
     2
     3        Pass inherited style only when resolving tree style
     4        https://bugs.webkit.org/show_bug.cgi?id=135799
     5
     6        Reviewed by Andreas Kling.
     7
     8        No need to pass around the style parent element.
     9
     10        * dom/ContainerNode.h:
     11        (WebCore::ContainerNode::childShouldCreateRenderer): Deleted.
     12        * dom/Element.cpp:
     13        (WebCore::Element::childShouldCreateRenderer):
     14        * dom/Element.h:
     15        * style/StyleResolveTree.cpp:
     16        (WebCore::Style::RenderTreePosition::parent):
     17        (WebCore::Style::nextSiblingRenderer):
     18        (WebCore::Style::RenderTreePosition::RenderTreePosition):
     19        (WebCore::Style::RenderTreePosition::computeNextSibling):
     20        (WebCore::Style::shouldCreateRenderer):
     21        (WebCore::Style::styleForElement):
     22        (WebCore::Style::createRendererIfNeeded):
     23        (WebCore::Style::textRendererIsNeeded):
     24        (WebCore::Style::createTextRendererIfNeeded):
     25        (WebCore::Style::attachTextRenderer):
     26        (WebCore::Style::updateTextRendererAfterContentChange):
     27        (WebCore::Style::attachChildren):
     28        (WebCore::Style::attachDistributedChildren):
     29        (WebCore::Style::attachShadowRoot):
     30        (WebCore::Style::attachBeforeOrAfterPseudoElementIfNeeded):
     31        (WebCore::Style::attachRenderTree):
     32        (WebCore::Style::resolveLocal):
     33        (WebCore::Style::resolveTextNode):
     34        (WebCore::Style::resolveShadowTree):
     35        (WebCore::Style::updateBeforeOrAfterPseudoElement):
     36        (WebCore::Style::resolveTree):
     37        * svg/SVGDocument.cpp:
     38        (WebCore::SVGDocument::childShouldCreateRenderer): Deleted.
     39       
     40            Implement this in SVGSVGElement::rendererIsNeeded instead.
     41
     42        * svg/SVGDocument.h:
     43        * svg/SVGSVGElement.cpp:
     44        (WebCore::SVGSVGElement::rendererIsNeeded):
     45
    1462014-08-11  Yusuke Suzuki  <utatane.tea@gmail.com>
    247
  • trunk/Source/WebCore/dom/ContainerNode.h

    r168386 r172409  
    122122    void disconnectDescendantFrames();
    123123
    124     virtual bool childShouldCreateRenderer(const Node&) const { return true; }
    125 
    126124    using Node::setAttributeEventListener;
    127125    void setAttributeEventListener(const AtomicString& eventType, const QualifiedName& attributeName, const AtomicString& value);
  • trunk/Source/WebCore/dom/Element.cpp

    r171941 r172409  
    24592459        return child.hasTagName(SVGNames::svgTag) && toSVGElement(child).isValid();
    24602460    }
    2461     return ContainerNode::childShouldCreateRenderer(child);
     2461    return true;
    24622462}
    24632463
  • trunk/Source/WebCore/dom/Element.h

    r172259 r172409  
    489489    virtual bool isDisabledFormControl() const { return false; }
    490490
    491     virtual bool childShouldCreateRenderer(const Node&) const override;
     491    virtual bool childShouldCreateRenderer(const Node&) const;
    492492
    493493    bool hasPendingResources() const;
  • trunk/Source/WebCore/style/StyleResolveTree.cpp

    r170774 r172409  
    6565class RenderTreePosition {
    6666public:
    67     RenderTreePosition(RenderElement* parent);
     67    explicit RenderTreePosition(RenderView&);
     68    explicit RenderTreePosition(RenderElement* parent);
    6869    RenderTreePosition(RenderElement* parent, RenderObject* nextSibling);
    6970
    7071    RenderElement* parent() { return m_parent; }
     72    const RenderElement* parent() const { return m_parent; }
    7173
    7274    void insert(RenderObject&);
     
    7476    bool canInsert(RenderText&) const;
    7577
    76     void computeNextSibling(const Node&, ContainerNode& renderingParentNode);
     78    void computeNextSibling(const Node&);
    7779    void invalidateNextSibling(const RenderObject&);
    7880
     
    8688};
    8789
    88 static void attachRenderTree(Element&, ContainerNode& renderingParentNode, RenderTreePosition&, PassRefPtr<RenderStyle>);
    89 static void attachTextRenderer(Text&, ContainerNode& renderingParentNode, RenderTreePosition&);
     90static void attachRenderTree(Element&, RenderStyle* inheritedStyle, RenderTreePosition&, PassRefPtr<RenderStyle>);
     91static void attachTextRenderer(Text&, RenderTreePosition&);
    9092static void detachRenderTree(Element&, DetachType);
    91 static void resolveTextNode(Text&, ContainerNode& renderingParentNode, RenderTreePosition&);
    92 static void resolveTree(Element&, ContainerNode& renderingParentNode, RenderTreePosition&, Change);
     93static void resolveTextNode(Text&, RenderTreePosition&);
     94static void resolveTree(Element&, RenderStyle* inheritedStyle, RenderTreePosition&, Change);
    9395
    9496Change determineChange(const RenderStyle* s1, const RenderStyle* s2)
     
    153155}
    154156
    155 static RenderObject* nextSiblingRenderer(const Node& node, const ContainerNode& renderingParentNode)
    156 {
    157     if (!renderingParentNode.isElementNode())
    158         return nullptr;
    159     const Element& renderingParentElement = toElement(renderingParentNode);
    160     // Avoid an O(N^2) problem with this function by not checking for
    161     // nextRenderer() when the parent element hasn't attached yet.
    162     // FIXME: Why would we get here anyway if parent is not attached?
    163     if (!renderingParentElement.renderer())
     157static RenderObject* nextSiblingRenderer(const Node& node, const RenderElement& parentRenderer)
     158{
     159    if (!parentRenderer.element())
    164160        return nullptr;
    165161    if (node.isAfterPseudoElement())
    166162        return nullptr;
    167     Node* sibling = node.isBeforePseudoElement() ? NodeRenderingTraversal::firstChild(&renderingParentNode) : NodeRenderingTraversal::nextSibling(&node);
     163    Node* sibling = node.isBeforePseudoElement() ? NodeRenderingTraversal::firstChild(parentRenderer.element()) : NodeRenderingTraversal::nextSibling(&node);
    168164    for (; sibling; sibling = NodeRenderingTraversal::nextSibling(sibling)) {
    169165        RenderObject* renderer = sibling->renderer();
     
    171167            return renderer;
    172168    }
    173     if (PseudoElement* after = renderingParentElement.afterPseudoElement())
     169    if (PseudoElement* after = parentRenderer.element()->afterPseudoElement())
    174170        return after->renderer();
    175171    return nullptr;
     172}
     173
     174RenderTreePosition::RenderTreePosition(RenderView& root)
     175    : m_parent(&root)
     176    , m_nextSibling(nullptr)
     177    , m_hasValidNextSibling(true)
     178#if !ASSERT_DISABLED
     179    , m_assertionLimitCounter(0)
     180#endif
     181{
    176182}
    177183
     
    217223}
    218224
    219 void RenderTreePosition::computeNextSibling(const Node& node, ContainerNode& renderingParentNode)
    220 {
     225void RenderTreePosition::computeNextSibling(const Node& node)
     226{
     227    ASSERT(m_parent);
    221228    ASSERT(!node.renderer());
    222229    if (m_hasValidNextSibling) {
    223230        // Stop validating at some point so the assert doesn't make us O(N^2) on debug builds.
    224         ASSERT(++m_assertionLimitCounter > 20 || nextSiblingRenderer(node, renderingParentNode) == m_nextSibling);
    225         return;
    226     }
    227     m_nextSibling = nextSiblingRenderer(node, renderingParentNode);
     231        ASSERT(m_parent->isRenderView() || ++m_assertionLimitCounter > 20 || nextSiblingRenderer(node, *m_parent) == m_nextSibling);
     232        return;
     233    }
     234    m_nextSibling = nextSiblingRenderer(node, *m_parent);
    228235    m_hasValidNextSibling = true;
    229236}
     
    237244}
    238245
    239 static bool shouldCreateRenderer(const Element& element, const ContainerNode& renderingParent)
     246static bool shouldCreateRenderer(const Element& element, const RenderElement* parentRenderer)
    240247{
    241248    if (!element.document().shouldCreateRenderers())
    242249        return false;
    243     RenderObject* parentRenderer = renderingParent.renderer();
    244250    if (!parentRenderer)
    245251        return false;
    246252    if (!parentRenderer->canHaveChildren() && !(element.isPseudoElement() && parentRenderer->canHaveGeneratedChildren()))
    247253        return false;
    248     if (!renderingParent.childShouldCreateRenderer(element))
     254    if (parentRenderer->element() && !parentRenderer->element()->childShouldCreateRenderer(element))
    249255        return false;
    250256    return true;
    251257}
    252258
    253 static PassRef<RenderStyle> styleForElement(Element& element, ContainerNode& renderingParentNode)
    254 {
    255     RenderStyle* parentStyle = renderingParentNode.renderStyle();
    256     if (element.hasCustomStyleResolveCallbacks() && parentStyle) {
    257         if (RefPtr<RenderStyle> style = element.customStyleForRenderer(*parentStyle))
     259static PassRef<RenderStyle> styleForElement(Element& element, RenderStyle* inheritedStyle)
     260{
     261    if (element.hasCustomStyleResolveCallbacks() && inheritedStyle) {
     262        if (RefPtr<RenderStyle> style = element.customStyleForRenderer(*inheritedStyle))
    258263            return style.releaseNonNull();
    259264    }
    260     return element.document().ensureStyleResolver().styleForElement(&element, parentStyle);
     265    return element.document().ensureStyleResolver().styleForElement(&element, inheritedStyle);
    261266}
    262267
     
    274279#endif
    275280
    276 static void createRendererIfNeeded(Element& element, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition, PassRefPtr<RenderStyle> resolvedStyle)
     281static void createRendererIfNeeded(Element& element, RenderStyle* inheritedStyle, RenderTreePosition& renderTreePosition, PassRefPtr<RenderStyle> resolvedStyle)
    277282{
    278283    ASSERT(!element.renderer());
     
    280285    RefPtr<RenderStyle> style = resolvedStyle;
    281286
    282     if (!shouldCreateRenderer(element, renderingParentNode))
     287    if (!shouldCreateRenderer(element, renderTreePosition.parent()))
    283288        return;
    284289
    285290    if (!style)
    286         style = styleForElement(element, renderingParentNode);
     291        style = styleForElement(element, inheritedStyle);
    287292
    288293    RenderNamedFlowThread* parentFlowRenderer = 0;
     
    294299        return;
    295300
    296     renderTreePosition.computeNextSibling(element, renderingParentNode);
     301    renderTreePosition.computeNextSibling(element);
    297302
    298303    RenderTreePosition insertionPosition = parentFlowRenderer
     
    371376}
    372377
    373 static bool textRendererIsNeeded(const Text& textNode, ContainerNode& renderingParentNode)
    374 {
    375     if (!renderingParentNode.renderer())
    376         return false;
    377     RenderElement& parentRenderer = *renderingParentNode.renderer();
     378static bool textRendererIsNeeded(const Text& textNode, const RenderTreePosition& renderTreePosition)
     379{
     380    if (!renderTreePosition.parent())
     381        return false;
     382    const RenderElement& parentRenderer = *renderTreePosition.parent();
    378383    if (!parentRenderer.canHaveChildren())
    379384        return false;
    380     if (!renderingParentNode.childShouldCreateRenderer(textNode))
    381         return false;
    382 
     385    if (parentRenderer.element() && !parentRenderer.element()->childShouldCreateRenderer(textNode))
     386        return false;
    383387    if (textNode.isEditingText())
    384388        return true;
    385389    if (!textNode.length())
    386         return false;
    387     if (parentRenderer.style().display() == NONE)
    388390        return false;
    389391    if (!textNode.containsOnlyWhitespace())
     
    410412        while (first && first->isFloatingOrOutOfFlowPositioned())
    411413            first = first->nextSibling();
    412         RenderObject* nextRenderer = nextSiblingRenderer(textNode, *textNode.parentNode());
     414        RenderObject* nextRenderer = nextSiblingRenderer(textNode, parentRenderer);
    413415        if (!first || nextRenderer == first) {
    414416            // Whitespace at the start of a block just goes away. Don't even make a render object for this text.
     
    419421}
    420422
    421 static void createTextRendererIfNeeded(Text& textNode, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition)
     423static void createTextRendererIfNeeded(Text& textNode, RenderTreePosition& renderTreePosition)
    422424{
    423425    ASSERT(!textNode.renderer());
    424426
    425     if (!textRendererIsNeeded(textNode, renderingParentNode))
    426         return;
    427 
    428     auto newRenderer = textNode.createTextRenderer(*renderingParentNode.renderStyle());
     427    if (!textRendererIsNeeded(textNode, renderTreePosition))
     428        return;
     429
     430    auto newRenderer = textNode.createTextRenderer(renderTreePosition.parent()->style());
    429431    ASSERT(newRenderer);
    430432
    431     renderTreePosition.computeNextSibling(textNode, renderingParentNode);
     433    renderTreePosition.computeNextSibling(textNode);
    432434
    433435    if (!renderTreePosition.canInsert(*newRenderer))
     
    443445}
    444446
    445 void attachTextRenderer(Text& textNode, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition)
    446 {
    447     createTextRendererIfNeeded(textNode, renderingParentNode, renderTreePosition);
     447void attachTextRenderer(Text& textNode, RenderTreePosition& renderTreePosition)
     448{
     449    createTextRendererIfNeeded(textNode, renderTreePosition);
    448450
    449451    textNode.clearNeedsStyleRecalc();
     
    460462{
    461463    ContainerNode* renderingParentNode = NodeRenderingTraversal::parent(&textNode);
    462     if (!renderingParentNode)
     464    if (!renderingParentNode || !renderingParentNode->renderer())
    463465        return;
    464466
     
    466468
    467469    RenderTreePosition renderTreePosition(renderingParentNode->renderer());
    468     resolveTextNode(textNode, *renderingParentNode, renderTreePosition);
     470    resolveTextNode(textNode, renderTreePosition);
    469471
    470472    if (hadRenderer && textNode.renderer())
     
    472474}
    473475
    474 static void attachChildren(ContainerNode& current, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition)
     476static void attachChildren(ContainerNode& current, RenderStyle* inheritedStyle, RenderTreePosition& renderTreePosition)
    475477{
    476478    for (Node* child = current.firstChild(); child; child = child->nextSibling()) {
     
    481483        }
    482484        if (child->isTextNode()) {
    483             attachTextRenderer(*toText(child), renderingParentNode, renderTreePosition);
     485            attachTextRenderer(*toText(child), renderTreePosition);
    484486            continue;
    485487        }
    486488        if (child->isElementNode())
    487             attachRenderTree(*toElement(child), renderingParentNode, renderTreePosition, nullptr);
    488     }
    489 }
    490 
    491 static void attachDistributedChildren(InsertionPoint& insertionPoint, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition)
     489            attachRenderTree(*toElement(child), inheritedStyle, renderTreePosition, nullptr);
     490    }
     491}
     492
     493static void attachDistributedChildren(InsertionPoint& insertionPoint, RenderStyle* inheritedStyle, RenderTreePosition& renderTreePosition)
    492494{
    493495    if (ShadowRoot* shadowRoot = insertionPoint.containingShadowRoot())
     
    500502            if (current->renderer())
    501503                continue;
    502             attachTextRenderer(*toText(current), renderingParentNode, renderTreePosition);
     504            attachTextRenderer(*toText(current), renderTreePosition);
    503505            continue;
    504506        }
     
    507509            if (currentElement.renderer())
    508510                detachRenderTree(currentElement);
    509             attachRenderTree(currentElement, renderingParentNode, renderTreePosition, nullptr);
     511            attachRenderTree(currentElement, inheritedStyle, renderTreePosition, nullptr);
    510512        }
    511513    }
    512514    // Use actual children as fallback content.
    513515    if (!insertionPoint.hasDistribution())
    514         attachChildren(insertionPoint, renderingParentNode, renderTreePosition);
     516        attachChildren(insertionPoint, inheritedStyle, renderTreePosition);
    515517}
    516518
     
    520522
    521523    RenderTreePosition renderTreePosition(shadowRoot.hostElement()->renderer());
    522     attachChildren(shadowRoot, *shadowRoot.hostElement(), renderTreePosition);
     524    attachChildren(shadowRoot, shadowRoot.hostElement()->renderStyle(), renderTreePosition);
    523525
    524526    shadowRoot.clearNeedsStyleRecalc();
     
    573575    RefPtr<PseudoElement> pseudoElement = PseudoElement::create(current, pseudoId);
    574576    setBeforeOrAfterPseudoElement(current, pseudoElement, pseudoId);
    575     attachRenderTree(*pseudoElement, current, renderTreePosition, nullptr);
    576 }
    577 
    578 static void attachRenderTree(Element& current, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition, PassRefPtr<RenderStyle> resolvedStyle)
     577    attachRenderTree(*pseudoElement, current.renderStyle(), renderTreePosition, nullptr);
     578}
     579
     580static void attachRenderTree(Element& current, RenderStyle* inheritedStyle, RenderTreePosition& renderTreePosition, PassRefPtr<RenderStyle> resolvedStyle)
    579581{
    580582    PostResolutionCallbackDisabler callbackDisabler(current.document());
     
    584586        current.willAttachRenderers();
    585587
    586     createRendererIfNeeded(current, renderingParentNode, renderTreePosition, resolvedStyle);
     588    createRendererIfNeeded(current, inheritedStyle, renderTreePosition, resolvedStyle);
    587589
    588590    if (current.parentElement() && current.parentElement()->isInCanvasSubtree())
     
    601603
    602604    if (isInsertionPoint(current))
    603         attachDistributedChildren(toInsertionPoint(current), renderingParentNode, renderTreePosition);
     605        attachDistributedChildren(toInsertionPoint(current), inheritedStyle, renderTreePosition);
    604606    else
    605         attachChildren(current, current, childRenderTreePosition);
     607        attachChildren(current, current.renderStyle(), childRenderTreePosition);
    606608
    607609    current.clearNeedsStyleRecalc();
     
    614616
    615617    current.updateFocusAppearanceAfterAttachIfNeeded();
    616    
     618
    617619    if (current.hasCustomStyleResolveCallbacks())
    618620        current.didAttachRenderers();
     
    713715}
    714716
    715 static Change resolveLocal(Element& current, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition, Change inheritedChange)
     717static Change resolveLocal(Element& current, RenderStyle* inheritedStyle, RenderTreePosition& renderTreePosition, Change inheritedChange)
    716718{
    717719    Change localChange = Detach;
     
    721723    Document& document = current.document();
    722724    if (currentStyle && current.styleChangeType() != ReconstructRenderTree) {
    723         newStyle = styleForElement(current, renderingParentNode);
     725        newStyle = styleForElement(current, inheritedStyle);
    724726        localChange = determineChange(currentStyle.get(), newStyle.get());
    725727    }
     
    727729        if (current.renderer() || current.isNamedFlowContentNode())
    728730            detachRenderTree(current, ReattachDetach);
    729         attachRenderTree(current, renderingParentNode, renderTreePosition, newStyle.release());
     731        attachRenderTree(current, inheritedStyle, renderTreePosition, newStyle.release());
    730732        invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(current);
    731733
     
    759761}
    760762
    761 void resolveTextNode(Text& text, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition)
     763void resolveTextNode(Text& text, RenderTreePosition& renderTreePosition)
    762764{
    763765    text.clearNeedsStyleRecalc();
    764766
    765767    bool hasRenderer = text.renderer();
    766     bool needsRenderer = textRendererIsNeeded(text, renderingParentNode);
     768    bool needsRenderer = textRendererIsNeeded(text, renderTreePosition);
    767769    if (hasRenderer) {
    768770        if (needsRenderer)
     
    774776    if (!needsRenderer)
    775777        return;
    776     attachTextRenderer(text, renderingParentNode, renderTreePosition);
     778    attachTextRenderer(text, renderTreePosition);
    777779    invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(text);
    778780}
     
    786788            renderTreePosition.invalidateNextSibling(*child->renderer());
    787789        if (child->isTextNode() && child->needsStyleRecalc()) {
    788             resolveTextNode(*toText(child), host, renderTreePosition);
     790            resolveTextNode(*toText(child), renderTreePosition);
    789791            continue;
    790792        }
    791793        if (child->isElementNode())
    792             resolveTree(*toElement(child), host, renderTreePosition, change);
     794            resolveTree(*toElement(child), host.renderStyle(), renderTreePosition, change);
    793795    }
    794796
     
    804806
    805807        if (needsPseudoElement(current, pseudoId))
    806             resolveTree(*existingPseudoElement, current, renderTreePosition, current.needsStyleRecalc() ? Force : change);
     808            resolveTree(*existingPseudoElement, current.renderStyle(), renderTreePosition, current.needsStyleRecalc() ? Force : change);
    807809        else
    808810            clearBeforeOrAfterPseudoElement(current, pseudoId);
     
    864866#endif // PLATFORM(IOS)
    865867
    866 void resolveTree(Element& current, ContainerNode& renderingParentNode, RenderTreePosition& renderTreePosition, Change change)
     868void resolveTree(Element& current, RenderStyle* inheritedStyle, RenderTreePosition& renderTreePosition, Change change)
    867869{
    868870    ASSERT(change != Detach);
     
    873875    }
    874876
    875     bool hasParentStyle = renderingParentNode.renderStyle();
    876877    bool hasDirectAdjacentRules = current.childrenAffectedByDirectAdjacentRules();
    877878    bool hasIndirectAdjacentRules = current.childrenAffectedByForwardPositionalRules();
     
    884885        current.resetComputedStyle();
    885886
    886     if (hasParentStyle && (change >= Inherit || current.needsStyleRecalc()))
    887         change = resolveLocal(current, renderingParentNode, renderTreePosition, change);
     887    if (inheritedStyle && (change >= Inherit || current.needsStyleRecalc()))
     888        change = resolveLocal(current, inheritedStyle, renderTreePosition, change);
    888889
    889890    if (change != Detach) {
     
    909910                childRenderTreePosition.invalidateNextSibling(*child->renderer());
    910911            if (child->isTextNode() && child->needsStyleRecalc()) {
    911                 resolveTextNode(*toText(child), current, childRenderTreePosition);
     912                resolveTextNode(*toText(child), childRenderTreePosition);
    912913                continue;
    913914            }
     
    920921            if (change >= Inherit || childElement->childNeedsStyleRecalc() || childElement->needsStyleRecalc()) {
    921922                parentPusher.push();
    922                 resolveTree(*childElement, current, childRenderTreePosition, change);
     923                resolveTree(*childElement, current.renderStyle(), childRenderTreePosition, change);
    923924            }
    924925            forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
     
    961962    if (change < Inherit && !documentElement->childNeedsStyleRecalc() && !documentElement->needsStyleRecalc())
    962963        return;
    963     RenderTreePosition renderTreePosition(document.renderView());
    964     resolveTree(*documentElement, document, renderTreePosition, change);
     964    RenderTreePosition renderTreePosition(*document.renderView());
     965    resolveTree(*documentElement, document.renderStyle(), renderTreePosition, change);
    965966}
    966967
  • trunk/Source/WebCore/svg/SVGAElement.cpp

    r170774 r172409  
    249249    if (child.hasTagName(SVGNames::aTag))
    250250        return false;
    251     if (parentNode() && parentNode()->isSVGElement())
    252         return parentNode()->childShouldCreateRenderer(child);
     251
     252    if (parentElement() && parentElement()->isSVGElement())
     253        return parentElement()->childShouldCreateRenderer(child);
    253254
    254255    return SVGElement::childShouldCreateRenderer(child);
  • trunk/Source/WebCore/svg/SVGDocument.cpp

    r167798 r172409  
    7777}
    7878
    79 bool SVGDocument::childShouldCreateRenderer(const Node& child) const
    80 {
    81     if (isSVGSVGElement(child))
    82         return toSVGSVGElement(child).isValid();
    83     return true;
    84 }
    85 
    8679PassRefPtr<Document> SVGDocument::cloneDocumentWithoutChildren() const
    8780{
  • trunk/Source/WebCore/svg/SVGDocument.h

    r167798 r172409  
    4848    SVGDocument(Frame*, const URL&);
    4949
    50     virtual bool childShouldCreateRenderer(const Node&) const override;
    51 
    5250    virtual PassRefPtr<Document> cloneDocumentWithoutChildren() const override;
    5351
  • trunk/Source/WebCore/svg/SVGSVGElement.cpp

    r171591 r172409  
    460460bool SVGSVGElement::rendererIsNeeded(const RenderStyle& style)
    461461{
     462    if (!isValid())
     463        return false;
    462464    // FIXME: We should respect display: none on the documentElement svg element
    463465    // but many things in FrameView and SVGImage depend on the RenderSVGRoot when
Note: See TracChangeset for help on using the changeset viewer.