Changeset 30112 in webkit


Ignore:
Timestamp:
Feb 9, 2008 2:49:13 PM (16 years ago)
Author:
hyatt@apple.com
Message:

Fix for bug 17203, high CPU usage loading HTML5 spec. This patch significantly improves the performance
of CSS3 selectors.

(1) Split the notion of being affected by positional rules into "forward" and "backward." The "forward"
selectors do not need to re-resolve during parsing, since children are appended on the end. Only the
"backward" selectors like last-child or nth-last-child have to re-resolve when a close tag is encountered.

(2) Extend childrenChanged to specify whether the children were changed by the parser or not. This allows
Element::childrenChanged to know when the parser is adding children so that it can ignore those adds when
possible.

(3) Make sure all Elements now know whether or not their children are currently parsing. Backwards selectors
like last-child will always return false when children are still being parsed. When an Element finishes
parsing its children, finishParsingChildren() gets called and will make sure the children re-resolve properly.

(4) Added a beginParsingChildren method and renamed finishParsing to finishedParsingChildren.

(5) Eliminated one-off hacks that did the same thing in HTMLObjectElement and HTMLAppletElement.

(6) Patched many incorrect implementations of finishedParsingChildren that did not properly call into their
base class (mostly new SVG elements that got added for SVG fonts around the time this became a requirement).

Reviewed by Eric

  • css/CSSStyleSelector.cpp: (WebCore::CSSStyleSelector::checkSelector): (WebCore::CSSStyleSelector::checkOneSelector):
  • dom/Attr.cpp: (WebCore::Attr::childrenChanged):
  • dom/Attr.h:
  • dom/ContainerNode.cpp: (WebCore::ContainerNode::addChild):
  • dom/Document.cpp: (WebCore::Document::childrenChanged):
  • dom/Document.h:
  • dom/Element.cpp: (WebCore::Element::Element): (WebCore::Element::recalcStyle): (WebCore::checkFirstChildRules): (WebCore::checkLastChildRules): (WebCore::checkEmptyRules): (WebCore::checkStyleRules): (WebCore::Element::childrenChanged): (WebCore::Element::finishParsingChildren):
  • dom/Element.h: (WebCore::Element::finishedParsingChildren): (WebCore::Element::beginParsingChildren):
  • dom/Node.cpp:
  • dom/Node.h: (WebCore::Node::finishParsingChildren): (WebCore::Node::beginParsingChildren): (WebCore::Node::childrenChanged):
  • dom/StyledElement.cpp: (WebCore::StyledElement::StyledElement):
  • dom/StyledElement.h:
  • dom/XMLTokenizer.cpp: (WebCore::XMLTokenizer::startElementNs): (WebCore::XMLTokenizer::endElementNs): (WebCore::):
  • html/HTMLAppletElement.cpp: (WebCore::HTMLAppletElement::HTMLAppletElement): (WebCore::HTMLAppletElement::finishParsingChildren):
  • html/HTMLAppletElement.h:
  • html/HTMLElementFactory.cpp: (WebCore::objectConstructor):
  • html/HTMLGenericFormElement.cpp: (WebCore::HTMLFormControlElementWithState::finishParsingChildren):
  • html/HTMLGenericFormElement.h:
  • html/HTMLObjectElement.cpp: (WebCore::HTMLObjectElement::HTMLObjectElement): (WebCore::HTMLObjectElement::finishParsingChildren): (WebCore::HTMLObjectElement::childrenChanged):
  • html/HTMLObjectElement.h:
  • html/HTMLOptGroupElement.cpp: (WebCore::HTMLOptGroupElement::childrenChanged):
  • html/HTMLOptGroupElement.h:
  • html/HTMLOptionElement.cpp: (WebCore::HTMLOptionElement::childrenChanged):
  • html/HTMLOptionElement.h:
  • html/HTMLParser.cpp: (WebCore::HTMLParser::insertNode): (WebCore::HTMLParser::pushBlock): (WebCore::HTMLParser::popOneBlockCommon):
  • html/HTMLScriptElement.cpp: (WebCore::HTMLScriptElement::childrenChanged): (WebCore::HTMLScriptElement::finishParsingChildren):
  • html/HTMLScriptElement.h:
  • html/HTMLSelectElement.cpp: (WebCore::HTMLSelectElement::childrenChanged):
  • html/HTMLSelectElement.h:
  • html/HTMLStyleElement.cpp: (WebCore::HTMLStyleElement::finishParsingChildren): (WebCore::HTMLStyleElement::childrenChanged):
  • html/HTMLStyleElement.h:
  • html/HTMLTextAreaElement.cpp: (WebCore::HTMLTextAreaElement::childrenChanged):
  • html/HTMLTextAreaElement.h:
  • html/HTMLTitleElement.cpp: (WebCore::HTMLTitleElement::childrenChanged):
  • html/HTMLTitleElement.h:
    • rendering/RenderApplet.cpp:

(WebCore::RenderApplet::createWidgetIfNecessary):

  • rendering/RenderPartObject.cpp: (WebCore::RenderPartObject::updateWidget):
  • rendering/RenderStyle.cpp: (WebCore::RenderStyle::RenderStyle):
  • rendering/RenderStyle.h: (WebCore::RenderStyle::childrenAffectedByForwardPositionalRules): (WebCore::RenderStyle::setChildrenAffectedByForwardPositionalRules): (WebCore::RenderStyle::childrenAffectedByBackwardPositionalRules): (WebCore::RenderStyle::setChildrenAffectedByBackwardPositionalRules):
  • svg/SVGAnimationElement.cpp: (WebCore::SVGAnimationElement::finishParsingChildren):
  • svg/SVGAnimationElement.h:
  • svg/SVGClipPathElement.cpp: (WebCore::SVGClipPathElement::childrenChanged):
  • svg/SVGClipPathElement.h:
  • svg/SVGDefinitionSrcElement.cpp: (WebCore::SVGDefinitionSrcElement::childrenChanged):
  • svg/SVGDefinitionSrcElement.h:
  • svg/SVGElement.cpp: (WebCore::SVGElement::finishParsingChildren):
  • svg/SVGElement.h:
  • svg/SVGFontFaceElement.cpp: (WebCore::SVGFontFaceElement::childrenChanged):
  • svg/SVGFontFaceElement.h:
  • svg/SVGFontFaceFormatElement.cpp: (WebCore::SVGFontFaceFormatElement::childrenChanged):
  • svg/SVGFontFaceFormatElement.h:
  • svg/SVGFontFaceSrcElement.cpp: (WebCore::SVGFontFaceSrcElement::childrenChanged):
  • svg/SVGFontFaceSrcElement.h:
  • svg/SVGFontFaceUriElement.cpp: (WebCore::SVGFontFaceUriElement::childrenChanged):
  • svg/SVGFontFaceUriElement.h:
  • svg/SVGGElement.cpp: (WebCore::SVGGElement::childrenChanged):
  • svg/SVGGElement.h:
  • svg/SVGGradientElement.cpp: (WebCore::SVGGradientElement::childrenChanged):
  • svg/SVGGradientElement.h:
  • svg/SVGMarkerElement.cpp: (WebCore::SVGMarkerElement::childrenChanged):
  • svg/SVGMarkerElement.h:
  • svg/SVGMaskElement.cpp: (WebCore::SVGMaskElement::childrenChanged):
  • svg/SVGMaskElement.h:
  • svg/SVGPatternElement.cpp: (WebCore::SVGPatternElement::childrenChanged):
  • svg/SVGPatternElement.h:
  • svg/SVGStyleElement.cpp: (WebCore::SVGStyleElement::finishParsingChildren): (WebCore::SVGStyleElement::childrenChanged):
  • svg/SVGStyleElement.h:
  • svg/SVGStyledElement.cpp: (WebCore::SVGStyledElement::childrenChanged):
  • svg/SVGStyledElement.h:
  • svg/SVGTitleElement.cpp: (WebCore::SVGTitleElement::childrenChanged):
  • svg/SVGTitleElement.h:
  • svg/SVGUseElement.cpp: (WebCore::SVGUseElement::childrenChanged):
  • svg/SVGUseElement.h:
Location:
trunk/WebCore
Files:
70 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r30111 r30112  
     12008-02-09  David Hyatt  <hyatt@apple.com>
     2
     3        Fix for bug 17203, high CPU usage loading HTML5 spec.  This patch significantly improves the performance
     4        of CSS3 selectors.
     5
     6        (1) Split the notion of being affected by positional rules into "forward" and "backward."  The "forward"
     7        selectors do not need to re-resolve during parsing, since children are appended on the end.  Only the
     8        "backward" selectors like last-child or nth-last-child have to re-resolve when a close tag is encountered.
     9
     10        (2) Extend childrenChanged to specify whether the children were changed by the parser or not.  This allows
     11        Element::childrenChanged to know when the parser is adding children so that it can ignore those adds when
     12        possible.
     13
     14        (3) Make sure all Elements now know whether or not their children are currently parsing.  Backwards selectors
     15        like last-child will always return false when children are still being parsed.  When an Element finishes
     16        parsing its children, finishParsingChildren() gets called and will make sure the children re-resolve properly.
     17
     18        (4) Added a beginParsingChildren method and renamed finishParsing to finishedParsingChildren.
     19
     20        (5) Eliminated one-off hacks that did the same thing in HTMLObjectElement and HTMLAppletElement.
     21
     22        (6) Patched many incorrect implementations of finishedParsingChildren that did not properly call into their
     23        base class (mostly new SVG elements that got added for SVG fonts around the time this became a requirement).
     24
     25        Reviewed by Eric
     26
     27        * css/CSSStyleSelector.cpp:
     28        (WebCore::CSSStyleSelector::checkSelector):
     29        (WebCore::CSSStyleSelector::checkOneSelector):
     30        * dom/Attr.cpp:
     31        (WebCore::Attr::childrenChanged):
     32        * dom/Attr.h:
     33        * dom/ContainerNode.cpp:
     34        (WebCore::ContainerNode::addChild):
     35        * dom/Document.cpp:
     36        (WebCore::Document::childrenChanged):
     37        * dom/Document.h:
     38        * dom/Element.cpp:
     39        (WebCore::Element::Element):
     40        (WebCore::Element::recalcStyle):
     41        (WebCore::checkFirstChildRules):
     42        (WebCore::checkLastChildRules):
     43        (WebCore::checkEmptyRules):
     44        (WebCore::checkStyleRules):
     45        (WebCore::Element::childrenChanged):
     46        (WebCore::Element::finishParsingChildren):
     47        * dom/Element.h:
     48        (WebCore::Element::finishedParsingChildren):
     49        (WebCore::Element::beginParsingChildren):
     50        * dom/Node.cpp:
     51        * dom/Node.h:
     52        (WebCore::Node::finishParsingChildren):
     53        (WebCore::Node::beginParsingChildren):
     54        (WebCore::Node::childrenChanged):
     55        * dom/StyledElement.cpp:
     56        (WebCore::StyledElement::StyledElement):
     57        * dom/StyledElement.h:
     58        * dom/XMLTokenizer.cpp:
     59        (WebCore::XMLTokenizer::startElementNs):
     60        (WebCore::XMLTokenizer::endElementNs):
     61        (WebCore::):
     62        * html/HTMLAppletElement.cpp:
     63        (WebCore::HTMLAppletElement::HTMLAppletElement):
     64        (WebCore::HTMLAppletElement::finishParsingChildren):
     65        * html/HTMLAppletElement.h:
     66        * html/HTMLElementFactory.cpp:
     67        (WebCore::objectConstructor):
     68        * html/HTMLGenericFormElement.cpp:
     69        (WebCore::HTMLFormControlElementWithState::finishParsingChildren):
     70        * html/HTMLGenericFormElement.h:
     71        * html/HTMLObjectElement.cpp:
     72        (WebCore::HTMLObjectElement::HTMLObjectElement):
     73        (WebCore::HTMLObjectElement::finishParsingChildren):
     74        (WebCore::HTMLObjectElement::childrenChanged):
     75        * html/HTMLObjectElement.h:
     76        * html/HTMLOptGroupElement.cpp:
     77        (WebCore::HTMLOptGroupElement::childrenChanged):
     78        * html/HTMLOptGroupElement.h:
     79        * html/HTMLOptionElement.cpp:
     80        (WebCore::HTMLOptionElement::childrenChanged):
     81        * html/HTMLOptionElement.h:
     82        * html/HTMLParser.cpp:
     83        (WebCore::HTMLParser::insertNode):
     84        (WebCore::HTMLParser::pushBlock):
     85        (WebCore::HTMLParser::popOneBlockCommon):
     86        * html/HTMLScriptElement.cpp:
     87        (WebCore::HTMLScriptElement::childrenChanged):
     88        (WebCore::HTMLScriptElement::finishParsingChildren):
     89        * html/HTMLScriptElement.h:
     90        * html/HTMLSelectElement.cpp:
     91        (WebCore::HTMLSelectElement::childrenChanged):
     92        * html/HTMLSelectElement.h:
     93        * html/HTMLStyleElement.cpp:
     94        (WebCore::HTMLStyleElement::finishParsingChildren):
     95        (WebCore::HTMLStyleElement::childrenChanged):
     96        * html/HTMLStyleElement.h:
     97        * html/HTMLTextAreaElement.cpp:
     98        (WebCore::HTMLTextAreaElement::childrenChanged):
     99        * html/HTMLTextAreaElement.h:
     100        * html/HTMLTitleElement.cpp:
     101        (WebCore::HTMLTitleElement::childrenChanged):
     102        * html/HTMLTitleElement.h:
     103         * rendering/RenderApplet.cpp:
     104        (WebCore::RenderApplet::createWidgetIfNecessary):
     105        * rendering/RenderPartObject.cpp:
     106        (WebCore::RenderPartObject::updateWidget):
     107        * rendering/RenderStyle.cpp:
     108        (WebCore::RenderStyle::RenderStyle):
     109        * rendering/RenderStyle.h:
     110        (WebCore::RenderStyle::childrenAffectedByForwardPositionalRules):
     111        (WebCore::RenderStyle::setChildrenAffectedByForwardPositionalRules):
     112        (WebCore::RenderStyle::childrenAffectedByBackwardPositionalRules):
     113        (WebCore::RenderStyle::setChildrenAffectedByBackwardPositionalRules):
     114        * svg/SVGAnimationElement.cpp:
     115        (WebCore::SVGAnimationElement::finishParsingChildren):
     116        * svg/SVGAnimationElement.h:
     117        * svg/SVGClipPathElement.cpp:
     118        (WebCore::SVGClipPathElement::childrenChanged):
     119        * svg/SVGClipPathElement.h:
     120        * svg/SVGDefinitionSrcElement.cpp:
     121        (WebCore::SVGDefinitionSrcElement::childrenChanged):
     122        * svg/SVGDefinitionSrcElement.h:
     123        * svg/SVGElement.cpp:
     124        (WebCore::SVGElement::finishParsingChildren):
     125        * svg/SVGElement.h:
     126        * svg/SVGFontFaceElement.cpp:
     127        (WebCore::SVGFontFaceElement::childrenChanged):
     128        * svg/SVGFontFaceElement.h:
     129        * svg/SVGFontFaceFormatElement.cpp:
     130        (WebCore::SVGFontFaceFormatElement::childrenChanged):
     131        * svg/SVGFontFaceFormatElement.h:
     132        * svg/SVGFontFaceSrcElement.cpp:
     133        (WebCore::SVGFontFaceSrcElement::childrenChanged):
     134        * svg/SVGFontFaceSrcElement.h:
     135        * svg/SVGFontFaceUriElement.cpp:
     136        (WebCore::SVGFontFaceUriElement::childrenChanged):
     137        * svg/SVGFontFaceUriElement.h:
     138        * svg/SVGGElement.cpp:
     139        (WebCore::SVGGElement::childrenChanged):
     140        * svg/SVGGElement.h:
     141        * svg/SVGGradientElement.cpp:
     142        (WebCore::SVGGradientElement::childrenChanged):
     143        * svg/SVGGradientElement.h:
     144        * svg/SVGMarkerElement.cpp:
     145        (WebCore::SVGMarkerElement::childrenChanged):
     146        * svg/SVGMarkerElement.h:
     147        * svg/SVGMaskElement.cpp:
     148        (WebCore::SVGMaskElement::childrenChanged):
     149        * svg/SVGMaskElement.h:
     150        * svg/SVGPatternElement.cpp:
     151        (WebCore::SVGPatternElement::childrenChanged):
     152        * svg/SVGPatternElement.h:
     153        * svg/SVGStyleElement.cpp:
     154        (WebCore::SVGStyleElement::finishParsingChildren):
     155        (WebCore::SVGStyleElement::childrenChanged):
     156        * svg/SVGStyleElement.h:
     157        * svg/SVGStyledElement.cpp:
     158        (WebCore::SVGStyledElement::childrenChanged):
     159        * svg/SVGStyledElement.h:
     160        * svg/SVGTitleElement.cpp:
     161        (WebCore::SVGTitleElement::childrenChanged):
     162        * svg/SVGTitleElement.h:
     163        * svg/SVGUseElement.cpp:
     164        (WebCore::SVGUseElement::childrenChanged):
     165        * svg/SVGUseElement.h:
     166       
    11672008-02-09  Holger Hans Peter Freyther  <holger.freyther@trolltech.com>
    2168
    … …  
    150316        * dom/SelectorNodeList.cpp:
    151317        (WebCore::SelectorNodeList::SelectorNodeList): ditto.
     318
     319
    152320
    1533212008-02-08  David Hyatt  <hyatt@apple.com>

  • trunk/WebCore/css/CSSStyleSelector.cpp

    r30069 r30112  
    734734                    a = -1; // -n == -1n
    735735                else
    736                     a = nth.substring(1, n - 1).toInt();
     736                    a = nth.substring(0, n - 1).toInt();
    737737            } else if (!n)
    738738                a = 1; // n == 1n
    … …  
    14471447        case CSSSelector::DirectAdjacent:
    14481448        {
     1449            if (!m_collectRulesOnly && e->parentNode() && e->parentNode()->isElementNode()) {
     1450                RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
     1451                if (parentStyle)
     1452                    parentStyle->setChildrenAffectedByForwardPositionalRules();
     1453            }
    14491454            Node* n = e->previousSibling();
    14501455            while (n && !n->isElementNode())
    … …  
    14561461        }
    14571462        case CSSSelector::IndirectAdjacent:
     1463            if (!m_collectRulesOnly && e->parentNode() && e->parentNode()->isElementNode()) {
     1464                RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
     1465                if (parentStyle)
     1466                    parentStyle->setChildrenAffectedByForwardPositionalRules();
     1467            }
    14581468            while (true) {
    14591469                Node* n = e->previousSibling();
    … …  
    16951705                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
    16961706                        if (parentStyle)
    1697                             parentStyle->setChildrenAffectedByPositionalRules();
     1707                            parentStyle->setChildrenAffectedByForwardPositionalRules();
    16981708                    }
    16991709                    return result;
    … …  
    17041714                // last-child matches the last child that is an element
    17051715                if (e->parentNode() && e->parentNode()->isElementNode()) {
     1716                    Element* parentNode = static_cast<Element*>(e->parentNode());
    17061717                    bool result = false;
    1707                     Node* n = e->nextSibling();
    1708                     while (n && !n->isElementNode())
    1709                         n = n->nextSibling();
    1710                     if (!n)
    1711                         result = true;
     1718                    if (parentNode->isFinishedParsingChildren()) {
     1719                        Node* n = e->nextSibling();
     1720                        while (n && !n->isElementNode())
     1721                            n = n->nextSibling();
     1722                        if (!n)
     1723                            result = true;
     1724                    }
    17121725                    if (!m_collectRulesOnly) {
    17131726                        RenderStyle* childStyle = (m_element == e) ? m_style : e->renderStyle();
    1714                         RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
     1727                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : parentNode->renderStyle();
    17151728                        if (parentStyle)
    17161729                            parentStyle->setChildrenAffectedByLastChildRules();
    … …  
    17251738                // last-of-type matches the last element of its type
    17261739                if (e->parentNode() && e->parentNode()->isElementNode()) {
     1740                    Element* parentNode = static_cast<Element*>(e->parentNode());
     1741                    if (!m_collectRulesOnly) {
     1742                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : parentNode->renderStyle();
     1743                        if (parentStyle)
     1744                            parentStyle->setChildrenAffectedByBackwardPositionalRules();
     1745                    }
     1746                    if (!parentNode->isFinishedParsingChildren())
     1747                        return false;
    17271748                    bool result = false;
    17281749                    const QualifiedName& type = e->tagQName();
    … …  
    17351756                    if (!n)
    17361757                        result = true;
    1737                     if (!m_collectRulesOnly) {
    1738                         RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
    1739                         if (parentStyle)
    1740                             parentStyle->setChildrenAffectedByPositionalRules();
    1741                     }
    17421758                    return result;
    17431759                }
    … …  
    17461762            case CSSSelector::PseudoOnlyChild: {
    17471763                if (e->parentNode() && e->parentNode()->isElementNode()) {
     1764                    Element* parentNode = static_cast<Element*>(e->parentNode());
    17481765                    bool firstChild = false;
    17491766                    bool lastChild = false;
    … …  
    17541771                    if (!n)
    17551772                        firstChild = true;
    1756                     if (firstChild) {
     1773                    if (firstChild && parentNode->isFinishedParsingChildren()) {
    17571774                        n = e->nextSibling();
    17581775                        while (n && !n->isElementNode())
    … …  
    17631780                    if (!m_collectRulesOnly) {
    17641781                        RenderStyle* childStyle = (m_element == e) ? m_style : e->renderStyle();
    1765                         RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
     1782                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : parentNode->renderStyle();
    17661783                        if (parentStyle) {
    17671784                            parentStyle->setChildrenAffectedByFirstChildRules();
    … …  
    17801797                // FIXME: This selector is very slow.
    17811798                if (e->parentNode() && e->parentNode()->isElementNode()) {
     1799                    Element* parentNode = static_cast<Element*>(e->parentNode());
     1800                    if (!m_collectRulesOnly) {
     1801                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : parentNode->renderStyle();
     1802                        if (parentStyle) {
     1803                            parentStyle->setChildrenAffectedByForwardPositionalRules();
     1804                            parentStyle->setChildrenAffectedByBackwardPositionalRules();
     1805                        }
     1806                    }
     1807                    if (!parentNode->isFinishedParsingChildren())
     1808                        return false;
    17821809                    bool firstChild = false;
    17831810                    bool lastChild = false;
    … …  
    18001827                        if (!n)
    18011828                            lastChild = true;
    1802                     }
    1803                     if (!m_collectRulesOnly) {
    1804                         RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
    1805                         if (parentStyle)
    1806                             parentStyle->setChildrenAffectedByPositionalRules();
    18071829                    }
    18081830                    return firstChild && lastChild;
    … …  
    18391861                            childStyle->setChildIndex(count);
    18401862                        if (parentStyle)
    1841                             parentStyle->setChildrenAffectedByPositionalRules();
     1863                            parentStyle->setChildrenAffectedByForwardPositionalRules();
    18421864                    }
    18431865                   
    … …  
    18661888                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
    18671889                        if (parentStyle)
    1868                             parentStyle->setChildrenAffectedByPositionalRules();
     1890                            parentStyle->setChildrenAffectedByForwardPositionalRules();
    18691891                    }
    18701892
    … …  
    18821904                    break;
    18831905                if (e->parentNode() && e->parentNode()->isElementNode()) {
     1906                    Element* parentNode = static_cast<Element*>(e->parentNode());
     1907                    if (!m_collectRulesOnly) {
     1908                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : parentNode->renderStyle();
     1909                        if (parentStyle)
     1910                            parentStyle->setChildrenAffectedByBackwardPositionalRules();
     1911                    }
     1912                    if (!parentNode->isFinishedParsingChildren())
     1913                        return false;
    18841914                    int count = 1;
    18851915                    Node* n = e->nextSibling();
    … …  
    18891919                        n = n->nextSibling();
    18901920                    }
    1891                    
    1892                     if (!m_collectRulesOnly) {
    1893                         RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
    1894                         if (parentStyle)
    1895                             parentStyle->setChildrenAffectedByPositionalRules();
    1896                     }
    1897                    
    18981921                    if (matchNth(count, a, b))
    18991922                        return true;
    … …  
    19081931                    break;
    19091932                if (e->parentNode() && e->parentNode()->isElementNode()) {
     1933                    Element* parentNode = static_cast<Element*>(e->parentNode());
     1934                    if (!m_collectRulesOnly) {
     1935                        RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : parentNode->renderStyle();
     1936                        if (parentStyle)
     1937                            parentStyle->setChildrenAffectedByBackwardPositionalRules();
     1938                    }
     1939                    if (!parentNode->isFinishedParsingChildren())
     1940                        return false;
    19101941                    int count = 1;
    19111942                    const QualifiedName& type = e->tagQName();
    … …  
    19161947                        n = n->nextSibling();
    19171948                    }
    1918                    
    1919                     if (!m_collectRulesOnly) {
    1920                         RenderStyle* parentStyle = (m_element == e) ? m_parentStyle : e->parentNode()->renderStyle();
    1921                         if (parentStyle)
    1922                             parentStyle->setChildrenAffectedByPositionalRules();
    1923                     }
    1924 
    19251949                    if (matchNth(count, a, b))
    19261950                        return true;

  • trunk/WebCore/dom/Attr.cpp

    r29098 r30112  
    150150}
    151151
    152 void Attr::childrenChanged()
     152void Attr::childrenChanged(bool changedByParser)
    153153{
    154     Node::childrenChanged();
     154    Node::childrenChanged(changedByParser);
    155155   
    156156    if (m_ignoreChildrenChanged > 0)

  • trunk/WebCore/dom/Attr.h

    r25754 r30112  
    7878    virtual bool childTypeAllowed(NodeType);
    7979
    80     virtual void childrenChanged();
     80    virtual void childrenChanged(bool changedByParser = false);
    8181    virtual String toString() const;
    8282

  • trunk/WebCore/dom/ContainerNode.cpp

    r29053 r30112  
    582582    if (document()->hasNodeLists())
    583583        notifyNodeListsChildrenChanged();
    584     childrenChanged();
     584    childrenChanged(true);
    585585   
    586586    if (newChild->isElementNode())

  • trunk/WebCore/dom/Document.cpp

    r30098 r30112  
    483483}
    484484
    485 void Document::childrenChanged()
     485void Document::childrenChanged(bool changedByParser)
    486486{
    487487    // invalidate the document element we have cached in case it was replaced

  • trunk/WebCore/dom/Document.h

    r30089 r30112  
    181181
    182182    DOMImplementation* implementation() const;
    183     virtual void childrenChanged();
     183    virtual void childrenChanged(bool changedByParser = false);
    184184    Element* documentElement() const;
    185185    virtual PassRefPtr<Element> createElement(const String& tagName, ExceptionCode&);

  • trunk/WebCore/dom/Element.cpp

    r29932 r30112  
    9999    : ContainerNode(doc)
    100100    , m_tagName(qName)
     101    , m_isStyleAttributeValid(true)
     102    , m_synchronizingStyleAttribute(false)
     103    , m_parsingChildrenFinished(true)
    101104{
    102105}
    … …  
    702705    bool hasParentStyle = parentNode() ? parentNode()->renderStyle() : false;
    703706    bool hasPositionalChildren = currentStyle && (currentStyle->childrenAffectedByFirstChildRules() || currentStyle->childrenAffectedByLastChildRules() ||
    704                                                   currentStyle->childrenAffectedByPositionalRules());
     707                                                  currentStyle->childrenAffectedByForwardPositionalRules() || currentStyle->childrenAffectedByBackwardPositionalRules());
    705708
    706709#if ENABLE(SVG)
    … …  
    737740            if (currentStyle->affectedByDragRules())
    738741                newStyle->setAffectedByDragRules(true);
    739             if (currentStyle->childrenAffectedByPositionalRules())
    740                 newStyle->setChildrenAffectedByPositionalRules();
     742            if (currentStyle->childrenAffectedByForwardPositionalRules())
     743                newStyle->setChildrenAffectedByForwardPositionalRules();
     744            if (currentStyle->childrenAffectedByBackwardPositionalRules())
     745                newStyle->setChildrenAffectedByBackwardPositionalRules();
    741746            if (currentStyle->childrenAffectedByFirstChildRules())
    742747                newStyle->setChildrenAffectedByFirstChildRules();
    … …  
    794799}
    795800
    796 static bool checkFirstChildRules(Element* e, RenderStyle* style)
     801static void checkFirstChildRules(Element* e, RenderStyle* style)
    797802{
    798803    if (style->childrenAffectedByFirstChildRules()) {
    … …  
    803808                if (checkingFirstChild) {
    804809                    if (n->attached() && n->renderStyle() && !n->renderStyle()->firstChildState())
    805                         return true;
     810                        n->setChanged();
    806811                    checkingFirstChild = false;
    807812                } else {
    808813                    if (n->attached() && n->renderStyle() && n->renderStyle()->firstChildState())
    809                         return true;
     814                        n->setChanged();
    810815                    break;
    811816                }
    … …  
    813818        }
    814819    }
    815     return false;
    816 }
    817 
    818 static bool checkLastChildRules(Element* e, RenderStyle* style)
     820}
     821
     822static void checkLastChildRules(Element* e, RenderStyle* style)
    819823{
    820824    if (style->childrenAffectedByLastChildRules()) {
    … …  
    825829                if (checkingLastChild) {
    826830                    if (n->attached() && n->renderStyle() && !n->renderStyle()->lastChildState())
    827                         return true;
     831                        n->setChanged();
    828832                    checkingLastChild = false;
    829833                } else {
    830834                    if (n->attached() && n->renderStyle() && n->renderStyle()->lastChildState())
    831                         return true;
     835                        n->setChanged();
    832836                    break;
    833837                }
    … …  
    835839        }
    836840    }
    837     return false;
    838841}
    839842
    840843static bool checkEmptyRules(Element* e, RenderStyle* style)
    841844{
    842     return (style->affectedByEmpty() && (!style->emptyState() || e->hasChildNodes()));
    843 }
    844 
    845 void Element::childrenChanged()
    846 {
    847     ContainerNode::childrenChanged();
    848    
    849     if (changed())
    850         return;
    851 
    852     RenderStyle* style  = renderStyle();
    853     if (!style)
    854         return;
    855 
    856     if (style->childrenAffectedByPositionalRules()) {
    857         setChanged();
    858         return;
    859     }
    860 
    861     if (checkFirstChildRules(this, style) || checkLastChildRules(this, style) || checkEmptyRules(this, style)) {
    862         setChanged();
    863         return;
    864     }
     845    return style->affectedByEmpty() && (!style->emptyState() || e->hasChildNodes());
     846}
     847
     848static void checkStyleRules(Element* e, RenderStyle* style, bool changedByParser)
     849{
     850    if (e->changed() || !style)
     851        return;
     852
     853    if (style->childrenAffectedByBackwardPositionalRules() ||
     854        (!changedByParser && style->childrenAffectedByForwardPositionalRules()) ||
     855        checkEmptyRules(e, style)) {
     856        e->setChanged();
     857        return;
     858    }
     859
     860    checkFirstChildRules(e, style);
     861    checkLastChildRules(e, style);
     862}
     863
     864void Element::childrenChanged(bool changedByParser)
     865{
     866    ContainerNode::childrenChanged(changedByParser);
     867    if (!changedByParser)
     868        checkStyleRules(this, renderStyle(), false);
     869}
     870
     871void Element::finishParsingChildren()
     872{
     873    ContainerNode::finishParsingChildren();
     874    m_parsingChildrenFinished = true;
     875    checkStyleRules(this, renderStyle(), true);
    865876}
    866877

  • trunk/WebCore/dom/Element.h

    r29918 r30112  
    119119    virtual void insertedIntoDocument();
    120120    virtual void removedFromDocument();
    121     virtual void childrenChanged();
     121    virtual void childrenChanged(bool changedByParser = false);
    122122
    123123    virtual bool isInputTypeHidden() const { return false; }
    … …  
    191191    virtual void didRestoreFromCache() { }
    192192   
     193    bool isFinishedParsingChildren() const { return m_parsingChildrenFinished; }
     194    virtual void finishParsingChildren();
     195    virtual void beginParsingChildren() { m_parsingChildrenFinished = false; }
     196
    193197private:
    194198    ElementRareData* rareData();
    … …  
    205209    virtual bool virtualHasTagName(const QualifiedName&) const;
    206210
     211private:
     212    QualifiedName m_tagName;
     213
    207214protected:
    208215    mutable RefPtr<NamedAttrMap> namedAttrMap;
    209216
     217    // These two bits are really used by the StyledElement subclass, but they are pulled up here in order to be shared with other
     218    // Element bits.
     219    mutable bool m_isStyleAttributeValid : 1;
     220    mutable bool m_synchronizingStyleAttribute : 1;
     221   
    210222private:
    211     QualifiedName m_tagName;
     223    bool m_parsingChildrenFinished : 1;
    212224};
    213225

  • trunk/WebCore/dom/Node.cpp

    r30096 r30112  
    858858}
    859859
    860 void Node::childrenChanged()
    861 {
    862 }
    863 
    864860bool Node::isReadOnlyNode()
    865861{

  • trunk/WebCore/dom/Node.h

    r30089 r30112  
    215215    // Also used for script elements and some SVG elements for similar purposes,
    216216    // but making parsing a special case in this respect should be avoided if possible.
    217     virtual void finishedParsing() { }
     217    virtual void finishParsingChildren() { }
     218    virtual void beginParsingChildren() { }
    218219
    219220    // Called by the frame right before dispatching an unloadEvent. [Radar 4532113]
    … …  
    436437     * node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
    437438     */
    438     virtual void childrenChanged();
     439    virtual void childrenChanged(bool changedByParser = false) {};
    439440
    440441    virtual String toString() const = 0;

  • trunk/WebCore/dom/StyledElement.cpp

    r29647 r30112  
    108108    : Element(name, doc)
    109109{
    110     m_isStyleAttributeValid = true;
    111     m_synchronizingStyleAttribute = false;
    112110}
    113111

  • trunk/WebCore/dom/StyledElement.h

    r29647 r30112  
    7979protected:
    8080    RefPtr<CSSMutableStyleDeclaration> m_inlineStyleDecl;
    81     mutable bool m_isStyleAttributeValid : 1;
    82     mutable bool m_synchronizingStyleAttribute : 1;
    8381};
    8482

  • trunk/WebCore/dom/XMLTokenizer.cpp

    r30013 r30112  
    766766    }
    767767
     768    newElement->beginParsingChildren();
     769
    768770    if (newElement->hasTagName(scriptTag))
    769771        static_cast<HTMLScriptElement*>(newElement.get())->setCreatedByParser(true);
    … …  
    806808    Node* n = m_currentNode;
    807809    RefPtr<Node> parent = n->parentNode();
    808     n->finishedParsing();
     810    n->finishParsingChildren();
    809811   
    810812    // don't load external scripts for standalone documents (for now)
    … …  
    18831885   
    18841886    RefPtr<Node> parent = n->parentNode();
    1885     n->finishedParsing();
     1887    n->finishParsingChildren();
    18861888
    18871889    // don't load external scripts for standalone documents (for now)

  • trunk/WebCore/html/HTMLAppletElement.cpp

    r25754 r30112  
    3939HTMLAppletElement::HTMLAppletElement(Document *doc)
    4040: HTMLPlugInElement(appletTag, doc)
    41 , m_allParamsAvailable(false)
    4241{
    4342}
    … …  
    160159#endif
    161160
    162 void HTMLAppletElement::finishedParsing()
     161void HTMLAppletElement::finishParsingChildren()
    163162{
    164163    // The parser just reached </applet>, so all the params are available now.
    165     m_allParamsAvailable = true;
     164    HTMLPlugInElement::finishParsingChildren();
    166165    if (renderer())
    167166        renderer()->setNeedsLayout(true); // This will cause it to create its widget & the Java applet
    168     HTMLPlugInElement::finishedParsing();
    169167}
    170168
    … …  
    177175}
    178176
    179 bool HTMLAppletElement::allParamsAvailable()
    180 {
    181     return m_allParamsAvailable;
    182 }
    183 
    184177String HTMLAppletElement::alt() const
    185178{

  • trunk/WebCore/html/HTMLAppletElement.h

    r25754 r30112  
    5151    virtual bool rendererIsNeeded(RenderStyle*);
    5252    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    53     virtual void finishedParsing();
     53    virtual void finishParsingChildren();
    5454    virtual void detach();
    5555   
    … …  
    7979    void setVspace(const String&);
    8080
    81     virtual bool allParamsAvailable();
    8281    void setupApplet() const;
    8382
    … …  
    8786private:
    8887    String oldIdAttr;
    89     bool m_allParamsAvailable;
    9088};
    9189

  • trunk/WebCore/html/HTMLElementFactory.cpp

    r29175 r30112  
    323323static PassRefPtr<HTMLElement> objectConstructor(const AtomicString&, Document* doc, HTMLFormElement*, bool createdByParser)
    324324{
    325     RefPtr<HTMLObjectElement> object = new HTMLObjectElement(doc);
    326     object->setComplete(!createdByParser);
     325    RefPtr<HTMLObjectElement> object = new HTMLObjectElement(doc, createdByParser);
    327326    return object.release();
    328327}

  • trunk/WebCore/html/HTMLGenericFormElement.cpp

    r27380 r30112  
    248248}
    249249
    250 void HTMLFormControlElementWithState::finishedParsing()
    251 {
     250void HTMLFormControlElementWithState::finishParsingChildren()
     251{
     252    HTMLGenericFormElement::finishParsingChildren();
    252253    Document* doc = document();
    253254    if (doc->hasStateForNewFormElements()) {

  • trunk/WebCore/html/HTMLGenericFormElement.h

    r27380 r30112  
    110110    virtual ~HTMLFormControlElementWithState();
    111111
    112     virtual void finishedParsing();
     112    virtual void finishParsingChildren();
    113113
    114114    virtual bool saveState(String& value) const = 0;

  • trunk/WebCore/html/HTMLObjectElement.cpp

    r30044 r30112  
    4848using namespace HTMLNames;
    4949
    50 HTMLObjectElement::HTMLObjectElement(Document* doc)
     50HTMLObjectElement::HTMLObjectElement(Document* doc, bool createdByParser)
    5151    : HTMLPlugInElement(objectTag, doc)
    52     , m_needWidgetUpdate(false)
     52    , m_needWidgetUpdate(!createdByParser)
    5353    , m_useFallbackContent(false)
    54     , m_complete(false)
    5554    , m_docNamedItem(true)
    5655{
    … …  
    186185}
    187186
    188 void HTMLObjectElement::finishedParsing()
    189 {
    190     // The parser just reached </object>.
    191     setComplete(true);
    192    
    193     HTMLPlugInElement::finishedParsing();
    194 }
    195 
    196 void HTMLObjectElement::setComplete(bool complete)
    197 {
    198     if (complete != m_complete) {
    199         m_complete = complete;
    200         if (complete && !m_useFallbackContent) {
    201             m_needWidgetUpdate = true;
    202             if (inDocument())
    203                 setChanged();
    204         }
     187void HTMLObjectElement::finishParsingChildren()
     188{
     189    HTMLPlugInElement::finishParsingChildren();
     190    if (!m_useFallbackContent) {
     191        m_needWidgetUpdate = true;
     192        if (inDocument())
     193            setChanged();
    205194    }
    206195}
    … …  
    250239}
    251240
    252 void HTMLObjectElement::childrenChanged()
     241void HTMLObjectElement::childrenChanged(bool changedByParser)
    253242{
    254243    updateDocNamedItem();
    … …  
    257246        setChanged();
    258247    }
    259     HTMLPlugInElement::childrenChanged();
     248    HTMLPlugInElement::childrenChanged(changedByParser);
    260249}
    261250

  • trunk/WebCore/html/HTMLObjectElement.h

    r29913 r30112  
    3333class HTMLObjectElement : public HTMLPlugInElement {
    3434public:
    35     HTMLObjectElement(Document*);
     35    HTMLObjectElement(Document*, bool createdByParser);
    3636    ~HTMLObjectElement();
    3737
    … …  
    4343    virtual bool rendererIsNeeded(RenderStyle*);
    4444    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    45     virtual void finishedParsing();
     45    virtual void finishParsingChildren();
    4646    virtual void detach();
    4747    virtual void insertedIntoDocument();
    … …  
    4949   
    5050    virtual void recalcStyle(StyleChange);
    51     virtual void childrenChanged();
     51    virtual void childrenChanged(bool changedByParser = false);
    5252
    5353    virtual bool isURLAttribute(Attribute*) const;
    … …  
    103103    void setVspace(int);
    104104
    105     bool isComplete() const { return m_complete; }
    106     void setComplete(bool complete);
    107    
    108105    bool isDocNamedItem() const { return m_docNamedItem; }
    109106
    … …  
    120117    void updateDocNamedItem();
    121118    String oldIdAttr;
    122     bool m_complete;
    123119    bool m_docNamedItem;
    124120};

  • trunk/WebCore/html/HTMLOptGroupElement.cpp

    r28524 r30112  
    9393}
    9494
    95 void HTMLOptGroupElement::childrenChanged()
     95void HTMLOptGroupElement::childrenChanged(bool changedByParser)
    9696{
    9797    recalcSelectOptions();
    98     HTMLGenericFormElement::childrenChanged();
     98    HTMLGenericFormElement::childrenChanged(changedByParser);
    9999}
    100100

  • trunk/WebCore/html/HTMLOptGroupElement.h

    r28524 r30112  
    4848    virtual bool appendChild(PassRefPtr<Node> newChild, ExceptionCode&);
    4949    virtual bool removeChildren();
    50     virtual void childrenChanged();
     50    virtual void childrenChanged(bool changedByParser = false);
    5151
    5252    String label() const;

  • trunk/WebCore/html/HTMLOptionElement.cpp

    r29918 r30112  
    188188}
    189189
    190 void HTMLOptionElement::childrenChanged()
     190void HTMLOptionElement::childrenChanged(bool changedByParser)
    191191{
    192192   HTMLSelectElement *select = getSelect();
    193193   if (select)
    194        select->childrenChanged();
    195    HTMLGenericFormElement::childrenChanged();
     194       select->childrenChanged(changedByParser);
     195   HTMLGenericFormElement::childrenChanged(changedByParser);
    196196}
    197197

  • trunk/WebCore/html/HTMLOptionElement.h

    r27217 r30112  
    6969    HTMLSelectElement* getSelect() const;
    7070
    71     virtual void childrenChanged();
     71    virtual void childrenChanged(bool changedByParser = false);
    7272
    7373    bool defaultSelected() const;

  • trunk/WebCore/html/HTMLParser.cpp

    r30097 r30112  
    329329        if (parentAttached && !n->attached() && !m_isParsingFragment)
    330330            n->attach();
    331         n->finishedParsing();
     331        n->finishParsingChildren();
    332332    }
    333333
    … …  
    12241224void HTMLParser::pushBlock(const AtomicString& tagName, int level)
    12251225{
     1226    current->beginParsingChildren();
    12261227    blockStack = new HTMLStackElem(tagName, level, current, didRefCurrent, blockStack);
    12271228    didRefCurrent = false;
    … …  
    13121313    // Also, a few elements (<applet>, <object>) need to know when all child elements (<param>s) are available.
    13131314    if (current && elem->node != current)
    1314         current->finishedParsing();
     1315        current->finishParsingChildren();
    13151316
    13161317    blockStack = elem->next;

  • trunk/WebCore/html/HTMLScriptElement.cpp

    r29918 r30112  
    6060}
    6161
    62 void HTMLScriptElement::childrenChanged()
     62void HTMLScriptElement::childrenChanged(bool changedByParser)
    6363{
    6464    // If a node is inserted as a child of the script element
    … …  
    6767    if (!m_createdByParser && inDocument() && firstChild())
    6868        evaluateScript(document()->url(), text());
    69     HTMLElement::childrenChanged();
     69    HTMLElement::childrenChanged(changedByParser);
    7070}
    7171
    … …  
    9696}
    9797
    98 void HTMLScriptElement::finishedParsing()
     98void HTMLScriptElement::finishParsingChildren()
    9999{
    100100    // The parser just reached </script>. If we have no src and no text,
    … …  
    102102    if (getAttribute(srcAttr).isEmpty() && text().isEmpty())
    103103        setCreatedByParser(false);
    104     HTMLElement::finishedParsing();
     104    HTMLElement::finishParsingChildren();
    105105}
    106106

  • trunk/WebCore/html/HTMLScriptElement.h

    r28639 r30112  
    4545    virtual void notifyFinished(CachedResource*);
    4646
    47     virtual void childrenChanged();
     47    virtual void childrenChanged(bool changedByParser = false);
    4848
    4949    virtual bool isURLAttribute(Attribute*) const;
    5050
    5151    void setCreatedByParser(bool createdByParser) { m_createdByParser = createdByParser; }
    52     virtual void finishedParsing();
     52    virtual void finishParsingChildren();
    5353
    5454    bool shouldExecuteAsJavaScript();

  • trunk/WebCore/html/HTMLSelectElement.cpp

    r28666 r30112  
    530530}
    531531
    532 void HTMLSelectElement::childrenChanged()
     532void HTMLSelectElement::childrenChanged(bool changedByParser)
    533533{
    534534    setRecalcListItems();
    535     HTMLFormControlElementWithState::childrenChanged();
     535    HTMLFormControlElementWithState::childrenChanged(changedByParser);
    536536}
    537537

  • trunk/WebCore/html/HTMLSelectElement.h

    r28666 r30112  
    8888    virtual bool appendChild(PassRefPtr<Node> newChild, ExceptionCode&);
    8989    virtual bool removeChildren();
    90     virtual void childrenChanged();
     90    virtual void childrenChanged(bool changedByParser = false);
    9191
    9292    virtual void parseMappedAttribute(MappedAttribute*);

  • trunk/WebCore/html/HTMLStyleElement.cpp

    r29918 r30112  
    5151}
    5252
    53 void HTMLStyleElement::finishedParsing()
     53void HTMLStyleElement::finishParsingChildren()
    5454{
    5555    StyleElement::sheet(this);
    5656    m_createdByParser = false;
    57     HTMLElement::finishedParsing();
     57    HTMLElement::finishParsingChildren();
    5858}
    5959
    … …  
    7272}
    7373
    74 void HTMLStyleElement::childrenChanged()
     74void HTMLStyleElement::childrenChanged(bool changedByParser)
    7575{
    7676    StyleElement::process(this);
    77     HTMLElement::childrenChanged();
     77    HTMLElement::childrenChanged(changedByParser);
    7878}
    7979

  • trunk/WebCore/html/HTMLStyleElement.h

    r25754 r30112  
    4444    virtual void insertedIntoDocument();
    4545    virtual void removedFromDocument();
    46     virtual void childrenChanged();
     46    virtual void childrenChanged(bool changedByParser = false);
    4747
    4848    void setCreatedByParser(bool createdByParser) { m_createdByParser = createdByParser; }
    49     virtual void finishedParsing();
     49    virtual void finishParsingChildren();
    5050
    5151    virtual bool isLoading() const;

  • trunk/WebCore/html/HTMLTextAreaElement.cpp

    r29918 r30112  
    120120}
    121121
    122 void HTMLTextAreaElement::childrenChanged()
     122void HTMLTextAreaElement::childrenChanged(bool changedByParser)
    123123{
    124124    setValue(defaultValue());
    125     HTMLElement::childrenChanged();
     125    HTMLElement::childrenChanged(changedByParser);
    126126}
    127127   

  • trunk/WebCore/html/HTMLTextAreaElement.h

    r25754 r30112  
    6262    void setSelectionRange(int, int);
    6363
    64     virtual void childrenChanged();
     64    virtual void childrenChanged(bool changedByParser = false);
    6565    virtual void parseMappedAttribute(MappedAttribute*);
    6666    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

  • trunk/WebCore/html/HTMLTitleElement.cpp

    r29918 r30112  
    5555}
    5656
    57 void HTMLTitleElement::childrenChanged()
     57void HTMLTitleElement::childrenChanged(bool changedByParser)
    5858{
    59     HTMLElement::childrenChanged();
    6059    m_title = "";
    6160    for (Node* c = firstChild(); c != 0; c = c->nextSibling())
    … …  
    6463    if (inDocument())
    6564        document()->setTitle(m_title, this);
    66     HTMLElement::childrenChanged();
     65    HTMLElement::childrenChanged(changedByParser);
    6766}
    6867

  • trunk/WebCore/html/HTMLTitleElement.h

    r25754 r30112  
    3939    virtual void insertedIntoDocument();
    4040    virtual void removedFromDocument();
    41     virtual void childrenChanged();
     41    virtual void childrenChanged(bool changedByParser = false);
    4242
    4343    String text() const;

  • trunk/WebCore/svg/SVGAnimationElement.cpp

    r29951 r30112  
    391391}
    392392
    393 void SVGAnimationElement::finishedParsing()
    394 {
    395     ownerSVGElement()->timeScheduler()->addTimer(this, lround(getStartTime()));
    396     SVGElement::finishedParsing();
     393void SVGAnimationElement::finishParsingChildren()
     394{
     395    if (ownerSVGElement())
     396        ownerSVGElement()->timeScheduler()->addTimer(this, lround(getStartTime()));
     397    SVGElement::finishParsingChildren();
    397398}
    398399

  • trunk/WebCore/svg/SVGAnimationElement.h

    r25754 r30112  
    9999        virtual void parseMappedAttribute(MappedAttribute* attr);
    100100
    101         virtual void finishedParsing();
     101        virtual void finishParsingChildren();
    102102
    103103        virtual bool updateAnimationBaseValueFromElement();

  • trunk/WebCore/svg/SVGClipPathElement.cpp

    r29951 r30112  
    8282}
    8383
    84 void SVGClipPathElement::childrenChanged()
     84void SVGClipPathElement::childrenChanged(bool changedByParser)
    8585{
    86     SVGStyledTransformableElement::childrenChanged();
     86    SVGStyledTransformableElement::childrenChanged(changedByParser);
    8787
    8888    if (!m_clipper)

  • trunk/WebCore/svg/SVGClipPathElement.h

    r29951 r30112  
    4747        virtual void parseMappedAttribute(MappedAttribute*);
    4848        virtual void svgAttributeChanged(const QualifiedName&);
    49         virtual void childrenChanged();
     49        virtual void childrenChanged(bool changedByParser = false);
    5050
    5151        virtual SVGResource* canvasResource();

  • trunk/WebCore/svg/SVGDefinitionSrcElement.cpp

    r29663 r30112  
    3333}
    3434
    35 void SVGDefinitionSrcElement::childrenChanged()
     35void SVGDefinitionSrcElement::childrenChanged(bool changedByParser)
    3636{
     37    SVGElement::childrenChanged(changedByParser);
    3738    if (parentNode() && parentNode()->hasTagName(SVGNames::font_faceTag))
    3839        static_cast<SVGFontFaceElement*>(parentNode())->rebuildFontFace();

  • trunk/WebCore/svg/SVGDefinitionSrcElement.h

    r29663 r30112  
    2929        SVGDefinitionSrcElement(const QualifiedName&, Document*);
    3030   
    31         virtual void childrenChanged();
     31        virtual void childrenChanged(bool changedByParser = false);
    3232    };
    3333

  • trunk/WebCore/svg/SVGElement.cpp

    r29951 r30112  
    175175}
    176176
    177 void SVGElement::finishedParsing()
    178 {
    179     // finishedParsing() is called when the close tag is reached for an element (e.g. </svg>)
     177void SVGElement::finishParsingChildren()
     178{
     179    // finishParsingChildren() is called when the close tag is reached for an element (e.g. </svg>)
    180180    // we send SVGLoad events here if we can, otherwise they'll be sent when any required loads finish
    181181    sendSVGLoadEventIfPossible();

  • trunk/WebCore/svg/SVGElement.h

    r29951 r30112  
    214214        virtual bool isValid() const { return true; }
    215215 
    216         virtual void finishedParsing();
     216        virtual void finishParsingChildren();
    217217        virtual bool rendererIsNeeded(RenderStyle*) { return false; }
    218218        virtual bool childShouldCreateRenderer(Node*) const;

  • trunk/WebCore/svg/SVGFontFaceElement.cpp

    r29839 r30112  
    360360}
    361361
    362 void SVGFontFaceElement::childrenChanged()
    363 {
     362void SVGFontFaceElement::childrenChanged(bool changedByParser)
     363{
     364    SVGElement::childrenChanged(changedByParser);
    364365    rebuildFontFace();
    365366}

  • trunk/WebCore/svg/SVGFontFaceElement.h

    r29700 r30112  
    3838        virtual void parseMappedAttribute(MappedAttribute*);
    3939
    40         virtual void childrenChanged();
     40        virtual void childrenChanged(bool changedByParser = false);
    4141        virtual void insertedIntoDocument();
    4242

  • trunk/WebCore/svg/SVGFontFaceFormatElement.cpp

    r29663 r30112  
    3535}
    3636
    37 void SVGFontFaceFormatElement::childrenChanged()
     37void SVGFontFaceFormatElement::childrenChanged(bool changedByParser)
    3838{
     39    SVGElement::childrenChanged(changedByParser);
     40
    3941    if (!parentNode() || !parentNode()->hasTagName(font_face_uriTag))
    4042        return;

  • trunk/WebCore/svg/SVGFontFaceFormatElement.h

    r29663 r30112  
    3030    SVGFontFaceFormatElement(const QualifiedName&, Document*);
    3131
    32     virtual void childrenChanged();
     32    virtual void childrenChanged(bool changedByParser = false);
    3333};
    3434

  • trunk/WebCore/svg/SVGFontFaceSrcElement.cpp

    r29663 r30112  
    5151}
    5252
    53 void SVGFontFaceSrcElement::childrenChanged()
     53void SVGFontFaceSrcElement::childrenChanged(bool changedByParser)
    5454{
     55    SVGElement::childrenChanged(changedByParser);
    5556    if (parentNode() && parentNode()->hasTagName(font_faceTag))
    5657        static_cast<SVGFontFaceElement*>(parentNode())->rebuildFontFace();

  • trunk/WebCore/svg/SVGFontFaceSrcElement.h

    r29663 r30112  
    3232        PassRefPtr<CSSValueList> srcValue() const;
    3333       
    34         virtual void childrenChanged();
     34        virtual void childrenChanged(bool changedByParser = false);
    3535    };
    3636

  • trunk/WebCore/svg/SVGFontFaceUriElement.cpp

    r29839 r30112  
    4545}
    4646
    47 void SVGFontFaceUriElement::childrenChanged()
     47void SVGFontFaceUriElement::childrenChanged(bool changedByParser)
    4848{
     49    SVGElement::childrenChanged(changedByParser);
     50
    4951    if (!parentNode() || !parentNode()->hasTagName(font_face_srcTag))
    5052        return;

  • trunk/WebCore/svg/SVGFontFaceUriElement.h

    r29663 r30112  
    3232        PassRefPtr<CSSFontFaceSrcValue> srcValue() const;
    3333       
    34         virtual void childrenChanged();
     34        virtual void childrenChanged(bool changedByParser = false);
    3535    };
    3636

  • trunk/WebCore/svg/SVGGElement.cpp

    r29951 r30112  
    6868}
    6969
    70 void SVGGElement::childrenChanged()
     70void SVGGElement::childrenChanged(bool changedByParser)
    7171{
    72     SVGStyledTransformableElement::childrenChanged();
     72    SVGStyledTransformableElement::childrenChanged(changedByParser);
    7373
    7474    if (renderer())

  • trunk/WebCore/svg/SVGGElement.h

    r29951 r30112  
    4444        virtual void parseMappedAttribute(MappedAttribute*);
    4545        virtual void svgAttributeChanged(const QualifiedName&);
    46         virtual void childrenChanged();
     46        virtual void childrenChanged(bool changedByParser = false);
    4747
    4848        virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

  • trunk/WebCore/svg/SVGGradientElement.cpp

    r29951 r30112  
    103103}
    104104
    105 void SVGGradientElement::childrenChanged()
     105void SVGGradientElement::childrenChanged(bool changedByParser)
    106106{
    107     SVGStyledElement::childrenChanged();
     107    SVGStyledElement::childrenChanged(changedByParser);
    108108
    109109    if (m_resource)

  • trunk/WebCore/svg/SVGGradientElement.h

    r29951 r30112  
    5252        virtual void svgAttributeChanged(const QualifiedName&);
    5353
    54         virtual void childrenChanged();
     54        virtual void childrenChanged(bool changedByParser = false);
    5555        virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    5656

  • trunk/WebCore/svg/SVGMarkerElement.cpp

    r29951 r30112  
    121121}
    122122
    123 void SVGMarkerElement::childrenChanged()
     123void SVGMarkerElement::childrenChanged(bool changedByParser)
    124124{
    125     SVGStyledElement::childrenChanged();
     125    SVGStyledElement::childrenChanged(changedByParser);
    126126
    127127    if (renderer())

  • trunk/WebCore/svg/SVGMarkerElement.h

    r29951 r30112  
    6161        virtual void parseMappedAttribute(MappedAttribute*);
    6262        virtual void svgAttributeChanged(const QualifiedName&);
    63         virtual void childrenChanged();
     63        virtual void childrenChanged(bool changedByParser = false);
    6464
    6565        virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

  • trunk/WebCore/svg/SVGMaskElement.cpp

    r29951 r30112  
    127127}
    128128
    129 void SVGMaskElement::childrenChanged()
    130 {
    131     SVGStyledElement::childrenChanged();
     129void SVGMaskElement::childrenChanged(bool changedByParser)
     130{
     131    SVGStyledElement::childrenChanged(changedByParser);
    132132
    133133    if (!m_masker)

  • trunk/WebCore/svg/SVGMaskElement.h

    r29951 r30112  
    4747        virtual void parseMappedAttribute(MappedAttribute*);
    4848        virtual void svgAttributeChanged(const QualifiedName&);
    49         virtual void childrenChanged();
     49        virtual void childrenChanged(bool changedByParser = false);
    5050
    5151        virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

  • trunk/WebCore/svg/SVGPatternElement.cpp

    r29951 r30112  
    145145}
    146146
    147 void SVGPatternElement::childrenChanged()
    148 {
    149     SVGStyledElement::childrenChanged();
     147void SVGPatternElement::childrenChanged(bool changedByParser)
     148{
     149    SVGStyledElement::childrenChanged(changedByParser);
    150150
    151151    if (!m_resource)

  • trunk/WebCore/svg/SVGPatternElement.h

    r29951 r30112  
    5555        virtual void parseMappedAttribute(MappedAttribute*);
    5656        virtual void svgAttributeChanged(const QualifiedName&);
    57         virtual void childrenChanged();
     57        virtual void childrenChanged(bool changedByParser = false);
    5858
    5959        virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

  • trunk/WebCore/svg/SVGStyleElement.cpp

    r28567 r30112  
    9494}
    9595
    96 void SVGStyleElement::finishedParsing()
     96void SVGStyleElement::finishParsingChildren()
    9797{
    9898    StyleElement::sheet(this);
    9999    m_createdByParser = false;
    100     SVGElement::finishedParsing();
     100    SVGElement::finishParsingChildren();
    101101}
    102102
    … …  
    115115}
    116116
    117 void SVGStyleElement::childrenChanged()
     117void SVGStyleElement::childrenChanged(bool changedByParser)
    118118{
     119    SVGElement::childrenChanged(changedByParser);
    119120    StyleElement::process(this);
    120121}

  • trunk/WebCore/svg/SVGStyleElement.h

    r25754 r30112  
    3838        virtual void insertedIntoDocument();
    3939        virtual void removedFromDocument();
    40         virtual void childrenChanged();
     40        virtual void childrenChanged(bool changedByParser = false);
    4141
    4242        void setCreatedByParser(bool createdByParser) { m_createdByParser = createdByParser; }
    43         virtual void finishedParsing();
     43        virtual void finishParsingChildren();
    4444
    4545        // 'SVGStyleElement' functions

  • trunk/WebCore/svg/SVGStyledElement.cpp

    r29951 r30112  
    225225}
    226226
    227 void SVGStyledElement::childrenChanged()
    228 {
    229     SVGElement::childrenChanged();
     227void SVGStyledElement::childrenChanged(bool changedByParser)
     228{
     229    SVGElement::childrenChanged(changedByParser);
    230230    if (document()->parsing())
    231231        return;

  • trunk/WebCore/svg/SVGStyledElement.h

    r29951 r30112  
    5656        virtual void svgAttributeChanged(const QualifiedName&);
    5757
    58         virtual void childrenChanged();
     58        virtual void childrenChanged(bool changedByParser = false);
    5959
    6060        // Centralized place to force a manual style resolution. Hacky but needed for now.

  • trunk/WebCore/svg/SVGTitleElement.cpp

    r25754 r30112  
    4747}
    4848
    49 void SVGTitleElement::childrenChanged()
     49void SVGTitleElement::childrenChanged(bool changedByParser)
    5050{
    51     SVGElement::childrenChanged();
     51    SVGElement::childrenChanged(changedByParser);
    5252    if (inDocument())
    5353        document()->setTitle(textContent(), this);

  • trunk/WebCore/svg/SVGTitleElement.h

    r25754 r30112  
    3838        virtual void insertedIntoDocument();
    3939        virtual void removedFromDocument();
    40         virtual void childrenChanged();
     40        virtual void childrenChanged(bool changedByParser = false);
    4141
    4242        virtual bool rendererIsNeeded(RenderStyle*) { return false; }

  • trunk/WebCore/svg/SVGUseElement.cpp

    r29951 r30112  
    149149}
    150150
    151 void SVGUseElement::childrenChanged()
    152 {
     151void SVGUseElement::childrenChanged(bool changedByParser)
     152{
     153    SVGElement::childrenChanged(changedByParser);
     154
    153155    if (!attached())
    154156        return;

  • trunk/WebCore/svg/SVGUseElement.h

    r29951 r30112  
    5555
    5656        virtual void parseMappedAttribute(MappedAttribute*);
    57         virtual void childrenChanged();
     57        virtual void childrenChanged(bool changedByParser = false);
    5858
    5959        virtual void svgAttributeChanged(const QualifiedName&);
Note: See TracChangeset for help on using the changeset viewer.