2010-05-06 Maciej Stachowiak <mjs@apple.com>
authormjs@apple.com <mjs@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 6 May 2010 22:41:15 +0000 (22:41 +0000)
committermjs@apple.com <mjs@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 6 May 2010 22:41:15 +0000 (22:41 +0000)
        Reviewed by Darin Adler.

        further fixes towards REGRESSION (r57292): 1% PLT regression from visited link information leak fix
        https://bugs.webkit.org/show_bug.cgi?id=38682
        <rdar://problem/7859794>

        Looks like a 1-2% speedup on PLT.

        - Reorder CSS properties.
        - Remove short circuit tag check in matchRulesForList which costs more than it saves.
        - Inline initForStyleResolve.
        - Optimize applyDeclarations to avoid switch and take fewer branches in the inner loop.

        - Change the way Node handles flags - replace bitfield with a uint32_t and explicit masking,
        to make it cheaper to initialize the bits and give faster access.
        - Added new Node flags to check for isStyledElement, isHTMLElement, isSVGElement, isComment,
        and devirtualize those methods.
        - Inline constructors for Node, Element, Text, CharacterData, StyledElement, etc since
        they are very simple and lots of nodes get constructed.

        * css/CSSPropertyNames.in: Move a few of the properties up front so we can check for them
        with < instead of switch statements
        * css/CSSStyleSelector.cpp:
        (WebCore::CSSStyleSelector::matchRulesForList): Remove unnecessary preflight check
        for tag match before checking selector. This check very rarely short circuits anything,
        since most rules with a tag end up in the appropriate tag bucket. So doing the check
        cost more time than the time saved.
        (WebCore::CSSStyleSelector::initForStyleResolve): Inline. Create RenderStyle in a better way.
        (WebCore::CSSStyleSelector::applyDeclarations): Get rid of switch statement and use <= to
        check for the high priority properties. Convert to template to avoid checking "applyFirst"
        each time through the loop.
        (WebCore::CSSStyleSelector::styleForElement): Adjust for new applyDeclarations() signature.
        (WebCore::CSSStyleSelector::keyframeStylesForAnimation): ditto
        (WebCore::CSSStyleSelector::pseudoStyleForElement): ditto
        * css/CSSStyleSelector.h: Adjust for new applyDeclarations() signature.
        * rendering/style/RenderStyle.cpp:
        (WebCore::RenderStyle::RenderStyle): Inline constructor.
        * rendering/style/RenderStyle.h: Make constructor private so it can be inline.
        * dom/Node.h:
        (WebCore::): See high-level description of changes above. Redid the
        way boolean flags work.
        (WebCore::Node::isElementNode):
        (WebCore::Node::isContainerNode):
        (WebCore::Node::isTextNode):
        (WebCore::Node::isHTMLElement):
        (WebCore::Node::isSVGElement):
        (WebCore::Node::isStyledElement):
        (WebCore::Node::isCommentNode):
        (WebCore::Node::hasID):
        (WebCore::Node::hasClass):
        (WebCore::Node::active):
        (WebCore::Node::inActiveChain):
        (WebCore::Node::inDetach):
        (WebCore::Node::hovered):
        (WebCore::Node::attached):
        (WebCore::Node::setAttached):
        (WebCore::Node::needsStyleRecalc):
        (WebCore::Node::styleChangeType):
        (WebCore::Node::childNeedsStyleRecalc):
        (WebCore::Node::isLink):
        (WebCore::Node::setHasID):
        (WebCore::Node::setHasClass):
        (WebCore::Node::setChildNeedsStyleRecalc):
        (WebCore::Node::clearChildNeedsStyleRecalc):
        (WebCore::Node::setInDocument):
        (WebCore::Node::clearInDocument):
        (WebCore::Node::setInActiveChain):
        (WebCore::Node::clearInActiveChain):
        (WebCore::Node::setIsLink):
        (WebCore::Node::clearIsLink):
        (WebCore::Node::setActive):
        (WebCore::Node::setHovered):
        (WebCore::Node::inDocument):
        (WebCore::Node::):
        (WebCore::Node::getFlag):
        (WebCore::Node::setFlag):
        (WebCore::Node::clearFlag):
        (WebCore::Node::hasRareData):
        (WebCore::Node::isParsingChildrenFinished):
        (WebCore::Node::setIsParsingChildrenFinished):
        (WebCore::Node::clearIsParsingChildrenFinished):
        (WebCore::Node::isStyleAttributeValid):
        (WebCore::Node::setIsStyleAttributeValid):
        (WebCore::Node::clearIsStyleAttributeValid):
        (WebCore::Node::isSynchronizingStyleAttribute):
        (WebCore::Node::setIsSynchronizingStyleAttribute):
        (WebCore::Node::clearIsSynchronizingStyleAttribute):
        (WebCore::Node::areSVGAttributesValid):
        (WebCore::Node::setAreSVGAttributesValid):
        (WebCore::Node::clearAreSVGAttributesValid):
        (WebCore::Node::isSynchronizingSVGAttributes):
        (WebCore::Node::setIsSynchronizingSVGAttributes):
        (WebCore::Node::clearIsSynchronizingSVGAttributes):
        (WebCore::Node::hasRareSVGData):
        (WebCore::Node::setHasRareSVGData):
        (WebCore::Node::clearHasRareSVGData):
        (WebCore::Node::initialRefCount):
        * dom/Node.cpp:
        (WebCore::Node::trackForDebugging): Adjusted for changes in
        flag handling.
        (WebCore::Node::ensureRareData): ditto
        (WebCore::Node::setStyleChange): ditto
        (WebCore::Node::setNeedsStyleRecalc): ditto
        (WebCore::Node::lazyAttach): ditto
        (WebCore::Node::attach): ditto
        (WebCore::Node::detach): ditto
        (WebCore::Node::insertedIntoDocument): ditto
        (WebCore::Node::removedFromDocument): ditto
        * dom/CharacterData.cpp:
        * dom/CharacterData.h:
        (WebCore::CharacterData::CharacterData): Inline the constructor (moved from .cpp)
        * dom/Comment.cpp:
        (WebCore::Comment::Comment): Tell the base class that we're a comment.
        * dom/Comment.h: Remove isCommentNode override.
        * dom/ContainerNode.cpp:
        (WebCore::ContainerNode::detach): Adjusted for changes in flag
        handling.
        (WebCore::ContainerNode::removedFromDocument): ditto
        * dom/Document.cpp:
        (WebCore::Document::Document): Adjusted for changes in flag handling.
        (WebCore::Document::recalcStyle): ditto
        (WebCore::Document::setFocusedNode): ditto
        * dom/Document.h:
        (WebCore::Node::Node): Inline the Node constructor - goes here
        because it uses Document.
        * dom/DocumentFragment.cpp: include Document.h due to above change
        * dom/EditingText.cpp: ditto
        * dom/EntityReference.cpp: ditto
        * dom/Element.cpp:
        (WebCore::Element::getAttribute): Adjusted for changes in flag
        handling.
        (WebCore::Element::setAttribute): ditto
        (WebCore::Element::hasAttributes): ditto
        (WebCore::Element::recalcStyle): ditto
        (WebCore::Element::finishParsingChildren): ditto
        * dom/Element.h:
        (WebCore::Element::Element): Inline (moved from .cpp)
        (WebCore::Element::isFinishedParsingChildren):
        (WebCore::Element::beginParsingChildren):
        (WebCore::Element::attributes): Adjusted for changes in flag
        handling.
        * dom/StyledElement.cpp:
        (WebCore::StyledElement::updateStyleAttribute): Adjust for
        changes to flag handling.
        (WebCore::StyledElement::mapToEntry): ditto
        (WebCore::StyledElement::parseMappedAttribute): ditto
        (WebCore::StyledElement::copyNonAttributeProperties): ditto
        * dom/StyledElement.h:
        (WebCore::StyledElement::StyledElement): Inline (moved from.cpp)
        (WebCore::StyledElement::invalidateStyleAttribute): Adjust for
        changes in flag handling.
        * dom/Text.h:
        (WebCore::Text::Text): Inline (moved from .cpp)
        * dom/Text.cpp:
        * html/HTMLAnchorElement.cpp:
        (WebCore::HTMLAnchorElement::HTMLAnchorElement): Adjust for changes in
        flag handling.
        (WebCore::HTMLAnchorElement::parseMappedAttribute): ditto
        * html/HTMLElement.cpp:
        (WebCore::HTMLElement::create): Tell base class we're an HTML element.
        * html/HTMLElement.h: ditto above; remove isHTMLElement override.
        * html/HTMLFormControlElement.h: Tell base class we're an HTML element.
        * html/HTMLFrameOwnerElement.cpp:
        (WebCore::HTMLFrameOwnerElement::HTMLFrameOwnerElement): ditto
        * html/HTMLProgressElement.cpp:
        (WebCore::HTMLProgressElement::HTMLProgressElement): ditto
        * mathml/MathMLElement.cpp:
        (WebCore::MathMLElement::MathMLElement): Tell base class we're a styled
        element.
        * rendering/MediaControlElements.cpp:
        (WebCore::MediaControlShadowRootElement::MediaControlShadowRootElement):
        Adjust for changes in flag handling.
        (WebCore::MediaControlElement::MediaControlElement): ditto
        (WebCore::MediaControlInputElement::MediaControlInputElement): ditto
        * rendering/RenderFileUploadControl.cpp:
        (WebCore::RenderFileUploadControl::updateFromElement): ditto
        * rendering/RenderLayer.cpp:
        (WebCore::RenderLayer::updateHoverActiveState): ditto
        * rendering/RenderProgress.cpp:
        (WebCore::RenderProgress::updateValuePartState): ditto
        * rendering/RenderSlider.cpp:
        (WebCore::RenderSlider::updateFromElement): ditto
        * rendering/SVGShadowTreeElements.cpp:
        (WebCore::SVGShadowTreeRootElement::SVGShadowTreeRootElement): ditto
        * rendering/TextControlInnerElements.cpp:
        (WebCore::TextControlInnerElement::attachInnerElement): ditto
        * svg/SVGAnimatedProperty.h:
        (WebCore::SVGAnimatedPropertyTearOff::setBaseVal): ditto
        (WebCore::SVGAnimatedPropertyTearOff::setAnimVal): ditto
        * svg/SVGElement.cpp:
        (WebCore::SVGElement::SVGElement): Tell base class we're
        an svg element.
        (WebCore::SVGElement::ensureRareSVGData): Adjust for flag handling
        changes.
        (WebCore::SVGElement::updateAnimatedSVGAttribute): ditto
        * svg/SVGElement.h:
        (WebCore::SVGElement::invalidateSVGAttributes): ditto
        * svg/SVGPolyElement.cpp:
        (WebCore::SVGPolyElement::svgAttributeChanged): ditto
        * wml/WMLAnchorElement.cpp:
        (WebCore::WMLAnchorElement::WMLAnchorElement): ditto
        * wml/WMLElement.cpp:
        (WebCore::WMLElement::WMLElement): Tell base class we're a styled
        element.

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@58914 268f45cc-cd09-0410-ab3c-d52691b4dbfc

44 files changed:
WebCore/ChangeLog
WebCore/css/CSSPropertyNames.in
WebCore/css/CSSStyleSelector.cpp
WebCore/css/CSSStyleSelector.h
WebCore/dom/CharacterData.cpp
WebCore/dom/CharacterData.h
WebCore/dom/Comment.cpp
WebCore/dom/Comment.h
WebCore/dom/ContainerNode.cpp
WebCore/dom/Document.cpp
WebCore/dom/Document.h
WebCore/dom/DocumentFragment.cpp
WebCore/dom/EditingText.cpp
WebCore/dom/Element.cpp
WebCore/dom/Element.h
WebCore/dom/EntityReference.cpp
WebCore/dom/Node.cpp
WebCore/dom/Node.h
WebCore/dom/StyledElement.cpp
WebCore/dom/StyledElement.h
WebCore/dom/Text.cpp
WebCore/dom/Text.h
WebCore/html/HTMLAnchorElement.cpp
WebCore/html/HTMLElement.cpp
WebCore/html/HTMLElement.h
WebCore/html/HTMLFormControlElement.h
WebCore/html/HTMLFrameOwnerElement.cpp
WebCore/html/HTMLProgressElement.cpp
WebCore/mathml/MathMLElement.cpp
WebCore/rendering/MediaControlElements.cpp
WebCore/rendering/RenderFileUploadControl.cpp
WebCore/rendering/RenderLayer.cpp
WebCore/rendering/RenderProgress.cpp
WebCore/rendering/RenderSlider.cpp
WebCore/rendering/SVGShadowTreeElements.cpp
WebCore/rendering/TextControlInnerElements.cpp
WebCore/rendering/style/RenderStyle.cpp
WebCore/rendering/style/RenderStyle.h
WebCore/svg/SVGAnimatedProperty.h
WebCore/svg/SVGElement.cpp
WebCore/svg/SVGElement.h
WebCore/svg/SVGPolyElement.cpp
WebCore/wml/WMLAnchorElement.cpp
WebCore/wml/WMLElement.cpp

index e465c20c497aed059d20da4a78fd975e15e8a29b..c422b725a1cdd361e7b1f03db0e9710f3247f871 100644 (file)
@@ -1,3 +1,210 @@
+2010-05-06  Maciej Stachowiak  <mjs@apple.com>
+
+        Reviewed by Darin Adler.
+
+        further fixes towards REGRESSION (r57292): 1% PLT regression from visited link information leak fix
+        https://bugs.webkit.org/show_bug.cgi?id=38682
+        <rdar://problem/7859794>
+
+        Looks like a 1-2% speedup on PLT.
+
+        - Reorder CSS properties.
+        - Remove short circuit tag check in matchRulesForList which costs more than it saves.
+        - Inline initForStyleResolve.
+        - Optimize applyDeclarations to avoid switch and take fewer branches in the inner loop.
+        
+        - Change the way Node handles flags - replace bitfield with a uint32_t and explicit masking, 
+        to make it cheaper to initialize the bits and give faster access.
+        - Added new Node flags to check for isStyledElement, isHTMLElement, isSVGElement, isComment, 
+        and devirtualize those methods.
+        - Inline constructors for Node, Element, Text, CharacterData, StyledElement, etc since
+        they are very simple and lots of nodes get constructed.
+        
+        * css/CSSPropertyNames.in: Move a few of the properties up front so we can check for them
+        with < instead of switch statements
+        * css/CSSStyleSelector.cpp:
+        (WebCore::CSSStyleSelector::matchRulesForList): Remove unnecessary preflight check
+        for tag match before checking selector. This check very rarely short circuits anything,
+        since most rules with a tag end up in the appropriate tag bucket. So doing the check
+        cost more time than the time saved.
+        (WebCore::CSSStyleSelector::initForStyleResolve): Inline. Create RenderStyle in a better way.
+        (WebCore::CSSStyleSelector::applyDeclarations): Get rid of switch statement and use <= to
+        check for the high priority properties. Convert to template to avoid checking "applyFirst"
+        each time through the loop.
+        (WebCore::CSSStyleSelector::styleForElement): Adjust for new applyDeclarations() signature.
+        (WebCore::CSSStyleSelector::keyframeStylesForAnimation): ditto
+        (WebCore::CSSStyleSelector::pseudoStyleForElement): ditto
+        * css/CSSStyleSelector.h: Adjust for new applyDeclarations() signature.
+        * rendering/style/RenderStyle.cpp:
+        (WebCore::RenderStyle::RenderStyle): Inline constructor.
+        * rendering/style/RenderStyle.h: Make constructor private so it can be inline.
+        * dom/Node.h:
+        (WebCore::): See high-level description of changes above. Redid the
+        way boolean flags work.
+        (WebCore::Node::isElementNode):
+        (WebCore::Node::isContainerNode):
+        (WebCore::Node::isTextNode):
+        (WebCore::Node::isHTMLElement):
+        (WebCore::Node::isSVGElement):
+        (WebCore::Node::isStyledElement):
+        (WebCore::Node::isCommentNode):
+        (WebCore::Node::hasID):
+        (WebCore::Node::hasClass):
+        (WebCore::Node::active):
+        (WebCore::Node::inActiveChain):
+        (WebCore::Node::inDetach):
+        (WebCore::Node::hovered):
+        (WebCore::Node::attached):
+        (WebCore::Node::setAttached):
+        (WebCore::Node::needsStyleRecalc):
+        (WebCore::Node::styleChangeType):
+        (WebCore::Node::childNeedsStyleRecalc):
+        (WebCore::Node::isLink):
+        (WebCore::Node::setHasID):
+        (WebCore::Node::setHasClass):
+        (WebCore::Node::setChildNeedsStyleRecalc):
+        (WebCore::Node::clearChildNeedsStyleRecalc):
+        (WebCore::Node::setInDocument):
+        (WebCore::Node::clearInDocument):
+        (WebCore::Node::setInActiveChain):
+        (WebCore::Node::clearInActiveChain):
+        (WebCore::Node::setIsLink):
+        (WebCore::Node::clearIsLink):
+        (WebCore::Node::setActive):
+        (WebCore::Node::setHovered):
+        (WebCore::Node::inDocument):
+        (WebCore::Node::):
+        (WebCore::Node::getFlag):
+        (WebCore::Node::setFlag):
+        (WebCore::Node::clearFlag):
+        (WebCore::Node::hasRareData):
+        (WebCore::Node::isParsingChildrenFinished):
+        (WebCore::Node::setIsParsingChildrenFinished):
+        (WebCore::Node::clearIsParsingChildrenFinished):
+        (WebCore::Node::isStyleAttributeValid):
+        (WebCore::Node::setIsStyleAttributeValid):
+        (WebCore::Node::clearIsStyleAttributeValid):
+        (WebCore::Node::isSynchronizingStyleAttribute):
+        (WebCore::Node::setIsSynchronizingStyleAttribute):
+        (WebCore::Node::clearIsSynchronizingStyleAttribute):
+        (WebCore::Node::areSVGAttributesValid):
+        (WebCore::Node::setAreSVGAttributesValid):
+        (WebCore::Node::clearAreSVGAttributesValid):
+        (WebCore::Node::isSynchronizingSVGAttributes):
+        (WebCore::Node::setIsSynchronizingSVGAttributes):
+        (WebCore::Node::clearIsSynchronizingSVGAttributes):
+        (WebCore::Node::hasRareSVGData):
+        (WebCore::Node::setHasRareSVGData):
+        (WebCore::Node::clearHasRareSVGData):
+        (WebCore::Node::initialRefCount):
+        * dom/Node.cpp:
+        (WebCore::Node::trackForDebugging): Adjusted for changes in
+        flag handling.
+        (WebCore::Node::ensureRareData): ditto
+        (WebCore::Node::setStyleChange): ditto
+        (WebCore::Node::setNeedsStyleRecalc): ditto
+        (WebCore::Node::lazyAttach): ditto
+        (WebCore::Node::attach): ditto
+        (WebCore::Node::detach): ditto
+        (WebCore::Node::insertedIntoDocument): ditto
+        (WebCore::Node::removedFromDocument): ditto
+        * dom/CharacterData.cpp:
+        * dom/CharacterData.h:
+        (WebCore::CharacterData::CharacterData): Inline the constructor (moved from .cpp)
+        * dom/Comment.cpp:
+        (WebCore::Comment::Comment): Tell the base class that we're a comment.
+        * dom/Comment.h: Remove isCommentNode override.
+        * dom/ContainerNode.cpp:
+        (WebCore::ContainerNode::detach): Adjusted for changes in flag
+        handling.
+        (WebCore::ContainerNode::removedFromDocument): ditto
+        * dom/Document.cpp:
+        (WebCore::Document::Document): Adjusted for changes in flag handling.
+        (WebCore::Document::recalcStyle): ditto
+        (WebCore::Document::setFocusedNode): ditto
+        * dom/Document.h:
+        (WebCore::Node::Node): Inline the Node constructor - goes here
+        because it uses Document.
+        * dom/DocumentFragment.cpp: include Document.h due to above change
+        * dom/EditingText.cpp: ditto
+        * dom/EntityReference.cpp: ditto
+        * dom/Element.cpp:
+        (WebCore::Element::getAttribute): Adjusted for changes in flag
+        handling.
+        (WebCore::Element::setAttribute): ditto
+        (WebCore::Element::hasAttributes): ditto
+        (WebCore::Element::recalcStyle): ditto
+        (WebCore::Element::finishParsingChildren): ditto
+        * dom/Element.h:
+        (WebCore::Element::Element): Inline (moved from .cpp)
+        (WebCore::Element::isFinishedParsingChildren):
+        (WebCore::Element::beginParsingChildren):
+        (WebCore::Element::attributes): Adjusted for changes in flag
+        handling.
+        * dom/StyledElement.cpp:
+        (WebCore::StyledElement::updateStyleAttribute): Adjust for
+        changes to flag handling.
+        (WebCore::StyledElement::mapToEntry): ditto
+        (WebCore::StyledElement::parseMappedAttribute): ditto
+        (WebCore::StyledElement::copyNonAttributeProperties): ditto
+        * dom/StyledElement.h:
+        (WebCore::StyledElement::StyledElement): Inline (moved from.cpp)
+        (WebCore::StyledElement::invalidateStyleAttribute): Adjust for
+        changes in flag handling.
+        * dom/Text.h:
+        (WebCore::Text::Text): Inline (moved from .cpp)
+        * dom/Text.cpp:
+        * html/HTMLAnchorElement.cpp:
+        (WebCore::HTMLAnchorElement::HTMLAnchorElement): Adjust for changes in
+        flag handling.
+        (WebCore::HTMLAnchorElement::parseMappedAttribute): ditto
+        * html/HTMLElement.cpp:
+        (WebCore::HTMLElement::create): Tell base class we're an HTML element.
+        * html/HTMLElement.h: ditto above; remove isHTMLElement override.
+        * html/HTMLFormControlElement.h: Tell base class we're an HTML element.
+        * html/HTMLFrameOwnerElement.cpp:
+        (WebCore::HTMLFrameOwnerElement::HTMLFrameOwnerElement): ditto
+        * html/HTMLProgressElement.cpp:
+        (WebCore::HTMLProgressElement::HTMLProgressElement): ditto
+        * mathml/MathMLElement.cpp:
+        (WebCore::MathMLElement::MathMLElement): Tell base class we're a styled
+        element.
+        * rendering/MediaControlElements.cpp:
+        (WebCore::MediaControlShadowRootElement::MediaControlShadowRootElement):
+        Adjust for changes in flag handling.
+        (WebCore::MediaControlElement::MediaControlElement): ditto
+        (WebCore::MediaControlInputElement::MediaControlInputElement): ditto
+        * rendering/RenderFileUploadControl.cpp:
+        (WebCore::RenderFileUploadControl::updateFromElement): ditto
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::updateHoverActiveState): ditto
+        * rendering/RenderProgress.cpp:
+        (WebCore::RenderProgress::updateValuePartState): ditto
+        * rendering/RenderSlider.cpp:
+        (WebCore::RenderSlider::updateFromElement): ditto
+        * rendering/SVGShadowTreeElements.cpp:
+        (WebCore::SVGShadowTreeRootElement::SVGShadowTreeRootElement): ditto
+        * rendering/TextControlInnerElements.cpp:
+        (WebCore::TextControlInnerElement::attachInnerElement): ditto
+        * svg/SVGAnimatedProperty.h:
+        (WebCore::SVGAnimatedPropertyTearOff::setBaseVal): ditto
+        (WebCore::SVGAnimatedPropertyTearOff::setAnimVal): ditto
+        * svg/SVGElement.cpp:
+        (WebCore::SVGElement::SVGElement): Tell base class we're
+        an svg element.
+        (WebCore::SVGElement::ensureRareSVGData): Adjust for flag handling
+        changes.
+        (WebCore::SVGElement::updateAnimatedSVGAttribute): ditto
+        * svg/SVGElement.h:
+        (WebCore::SVGElement::invalidateSVGAttributes): ditto
+        * svg/SVGPolyElement.cpp:
+        (WebCore::SVGPolyElement::svgAttributeChanged): ditto
+        * wml/WMLAnchorElement.cpp:
+        (WebCore::WMLAnchorElement::WMLAnchorElement): ditto
+        * wml/WMLElement.cpp:
+        (WebCore::WMLElement::WMLElement): Tell base class we're a styled
+        element.
+
 2010-05-06  Adam Barth  <abarth@webkit.org>
 
         Unreviewed.  Fix indent.  Sorry, my OCD was acting up.
index 5f7b188f6b7250e5e55cc454a15eccf0edb377f5..8049f748c7b06d689f214b719524aa30d0bc5ee7 100644 (file)
@@ -8,6 +8,24 @@
 # http://msdn.microsoft.com/workshop/author/css/reference/attributes.asp
 #
 
+# high-priority property names have to be listed first, to simplify the check
+# for applying them first.
+color
+direction
+display
+font
+font-family
+font-size
+font-style
+font-variant
+font-weight
+-webkit-text-size-adjust
+zoom
+
+# line height needs to be right after the above high-priority properties
+line-height
+
+# The remaining properties are listed in alphabetical order
 background
 background-attachment
 background-clip
@@ -52,26 +70,16 @@ bottom
 caption-side
 clear
 clip
-color
 content
 counter-increment
 counter-reset
 cursor
-direction
-display
 empty-cells
 float
-font
-font-family
-font-size
 font-stretch
-font-style
-font-variant
-font-weight
 height
 left
 letter-spacing
-line-height
 list-style
 list-style-image
 list-style-position
@@ -146,7 +154,6 @@ word-break
 word-spacing
 word-wrap
 z-index
-zoom
 -webkit-animation
 -webkit-animation-delay
 -webkit-animation-direction
@@ -238,7 +245,6 @@ zoom
 -webkit-text-decorations-in-effect
 -webkit-text-fill-color
 -webkit-text-security
--webkit-text-size-adjust
 -webkit-text-stroke
 -webkit-text-stroke-color
 -webkit-text-stroke-width
index 12d44ee5dd47553b4723ec119970ce1e8a8c384b..96b36bbd08bd535d80b3ee3b3192ae7f5a7b653e 100644 (file)
@@ -700,11 +700,9 @@ void CSSStyleSelector::matchRulesForList(CSSRuleDataList* rules, int& firstRuleI
     if (!rules)
         return;
 
-    const AtomicString& localName = m_element->localName();
     for (CSSRuleData* d = rules->first(); d; d = d->next()) {
         CSSStyleRule* rule = d->rule();
-        const AtomicString& selectorLocalName = d->selector()->m_tag.localName();
-        if ((localName == selectorLocalName || selectorLocalName == starAtom) && checkSelector(d->selector())) {
+        if (checkSelector(d->selector())) {
             // If the rule has no properties to apply, then ignore it.
             CSSMutableStyleDeclaration* decl = rule->declaration();
             if (!decl || !decl->length())
@@ -815,7 +813,7 @@ inline void CSSStyleSelector::initElement(Element* e, bool helperCallForVisitedS
     m_styledElement = m_element && m_element->isStyledElement() ? static_cast<StyledElement*>(m_element) : 0;
 }
 
-void CSSStyleSelector::initForStyleResolve(Element* e, RenderStyle* parentStyle, PseudoId pseudoID)
+inline void CSSStyleSelector::initForStyleResolve(Element* e, RenderStyle* parentStyle, PseudoId pseudoID)
 {
     m_checker.m_pseudoStyle = pseudoID;
 
@@ -1140,7 +1138,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* e, RenderStyl
     // will vanish if a style recalc happens during loading.
     if (allowSharing && !e->document()->haveStylesheetsLoaded() && !e->renderer()) {
         if (!s_styleNotYetAvailable) {
-            s_styleNotYetAvailable = ::new RenderStyle;
+            s_styleNotYetAvailable = RenderStyle::create().releaseRef();
             s_styleNotYetAvailable->ref();
             s_styleNotYetAvailable->setDisplay(NONE);
             s_styleNotYetAvailable->font().update(m_fontSelector);
@@ -1307,12 +1305,12 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* e, RenderStyl
     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
     // and (4) normal important.
     m_lineHeightValue = 0;
-    applyDeclarations(true, false, 0, m_matchedDecls.size() - 1);
+    applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
     if (!resolveForRootDefault) {
-        applyDeclarations(true, true, firstAuthorRule, lastAuthorRule);
-        applyDeclarations(true, true, firstUserRule, lastUserRule);
+        applyDeclarations<true>(true, firstAuthorRule, lastAuthorRule);
+        applyDeclarations<true>(true, firstUserRule, lastUserRule);
     }
-    applyDeclarations(true, true, firstUARule, lastUARule);
+    applyDeclarations<true>(true, firstUARule, lastUARule);
     
     // If our font got dirtied, go ahead and update it now.
     if (m_fontDirty)
@@ -1323,18 +1321,18 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* e, RenderStyl
         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
 
     // Now do the normal priority UA properties.
-    applyDeclarations(false, false, firstUARule, lastUARule);
+    applyDeclarations<false>(false, firstUARule, lastUARule);
     
     // Cache our border and background so that we can examine them later.
     cacheBorderAndBackground();
     
     // Now do the author and user normal priority properties and all the !important properties.
     if (!resolveForRootDefault) {
-        applyDeclarations(false, false, lastUARule + 1, m_matchedDecls.size() - 1);
-        applyDeclarations(false, true, firstAuthorRule, lastAuthorRule);
-        applyDeclarations(false, true, firstUserRule, lastUserRule);
+        applyDeclarations<false>(false, lastUARule + 1, m_matchedDecls.size() - 1);
+        applyDeclarations<false>(true, firstAuthorRule, lastAuthorRule);
+        applyDeclarations<false>(true, firstUserRule, lastUserRule);
     }
-    applyDeclarations(false, true, firstUARule, lastUARule);
+    applyDeclarations<false>(true, firstUARule, lastUARule);
     
     // If our font got dirtied by one of the non-essential font props, 
     // go ahead and update it a second time.
@@ -1398,7 +1396,7 @@ void CSSStyleSelector::keyframeStylesForAnimation(Element* e, const RenderStyle*
         
         // We don't need to bother with !important. Since there is only ever one
         // decl, there's nothing to override. So just add the first properties.
-        applyDeclarations(true, false, 0, m_matchedDecls.size() - 1);
+        applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
         
         // If our font got dirtied, go ahead and update it now.
         if (m_fontDirty)
@@ -1409,7 +1407,7 @@ void CSSStyleSelector::keyframeStylesForAnimation(Element* e, const RenderStyle*
             applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
         
         // Now do rest of the properties.
-        applyDeclarations(false, false, 0, m_matchedDecls.size() - 1);
+        applyDeclarations<false>(false, 0, m_matchedDecls.size() - 1);
         
         // If our font got dirtied by one of the non-essential font props, 
         // go ahead and update it a second time.
@@ -1496,10 +1494,10 @@ PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo,
     m_checker.m_matchVisitedPseudoClass = helperCallForVisitedStyle;
 
     // High-priority properties.
-    applyDeclarations(true, false, 0, m_matchedDecls.size() - 1);
-    applyDeclarations(true, true, firstAuthorRule, lastAuthorRule);
-    applyDeclarations(true, true, firstUserRule, lastUserRule);
-    applyDeclarations(true, true, firstUARule, lastUARule);
+    applyDeclarations<true>(false, 0, m_matchedDecls.size() - 1);
+    applyDeclarations<true>(true, firstAuthorRule, lastAuthorRule);
+    applyDeclarations<true>(true, firstUserRule, lastUserRule);
+    applyDeclarations<true>(true, firstUARule, lastUARule);
     
     // If our font got dirtied, go ahead and update it now.
     if (m_fontDirty)
@@ -1510,15 +1508,15 @@ PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo,
         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
     
     // Now do the normal priority properties.
-    applyDeclarations(false, false, firstUARule, lastUARule);
+    applyDeclarations<false>(false, firstUARule, lastUARule);
     
     // Cache our border and background so that we can examine them later.
     cacheBorderAndBackground();
     
-    applyDeclarations(false, false, lastUARule + 1, m_matchedDecls.size() - 1);
-    applyDeclarations(false, true, firstAuthorRule, lastAuthorRule);
-    applyDeclarations(false, true, firstUserRule, lastUserRule);
-    applyDeclarations(false, true, firstUARule, lastUARule);
+    applyDeclarations<false>(false, lastUARule + 1, m_matchedDecls.size() - 1);
+    applyDeclarations<false>(true, firstAuthorRule, lastAuthorRule);
+    applyDeclarations<false>(true, firstUserRule, lastUserRule);
+    applyDeclarations<false>(true, firstUARule, lastUARule);
     
     // If our font got dirtied by one of the non-essential font props, 
     // go ahead and update it a second time.
@@ -2843,8 +2841,8 @@ static Length convertToLength(CSSPrimitiveValue* primitiveValue, RenderStyle* st
     return l;
 }
 
-void CSSStyleSelector::applyDeclarations(bool applyFirst, bool isImportant,
-                                         int startIndex, int endIndex)
+template <bool applyFirst>
+void CSSStyleSelector::applyDeclarations(bool isImportant, int startIndex, int endIndex)
 {
     if (startIndex == -1)
         return;
@@ -2854,35 +2852,26 @@ void CSSStyleSelector::applyDeclarations(bool applyFirst, bool isImportant,
         CSSMutableStyleDeclaration::const_iterator end = decl->end();
         for (CSSMutableStyleDeclaration::const_iterator it = decl->begin(); it != end; ++it) {
             const CSSProperty& current = *it;
-            // give special priority to font-xxx, color properties
             if (isImportant == current.isImportant()) {
-                bool first;
-                switch (current.id()) {
-                    case CSSPropertyLineHeight:
-                        m_lineHeightValue = current.value();
-                        first = !applyFirst; // we apply line-height later
-                        break;
-                    case CSSPropertyColor:
-                    case CSSPropertyDirection:
-                    case CSSPropertyDisplay:
-                    case CSSPropertyFont:
-                    case CSSPropertyFontSize:
-                    case CSSPropertyFontStyle:
-                    case CSSPropertyFontFamily:
-                    case CSSPropertyFontWeight:
-                    case CSSPropertyWebkitTextSizeAdjust:
-                    case CSSPropertyFontVariant:
-                    case CSSPropertyZoom:
-                        // these have to be applied first, because other properties use the computed
-                        // values of these properties.
-                        first = true;
-                        break;
-                    default:
-                        first = false;
-                        break;
+                int property = current.id();
+
+                if (applyFirst) {
+                    COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
+                    COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 10, CSS_zoom_is_end_of_first_prop_range);
+                    COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
+
+                    // give special priority to font-xxx, color properties, etc
+                    if (property <= CSSPropertyLineHeight) {
+                        // we apply line-height later
+                        if (property == CSSPropertyLineHeight)
+                            m_lineHeightValue = current.value(); 
+                        else 
+                            applyProperty(current.id(), current.value());
+                    }
+                } else {
+                    if (property > CSSPropertyLineHeight)
+                        applyProperty(current.id(), current.value());
                 }
-                if (first == applyFirst)
-                    applyProperty(current.id(), current.value());
             }
         }
     }
index b17178265f3596f30f19c0ff2a6bdd9d4ab148c0..50896864aaf6de4eb9781510fe12bfae92cde0d5 100644 (file)
@@ -179,7 +179,8 @@ public:
         void matchRulesForList(CSSRuleDataList*, int& firstRuleIndex, int& lastRuleIndex);
         void sortMatchedRules(unsigned start, unsigned end);
 
-        void applyDeclarations(bool firstPass, bool important, int startIndex, int endIndex);
+        template <bool firstPass>
+        void applyDeclarations(bool important, int startIndex, int endIndex);
         
         CSSRuleSet* m_authorStyle;
         CSSRuleSet* m_userStyle;
index f5adb6c43f88c7f2234d8d6834c966ea00690f15..9670988a57aeeaf4137f81ab62ebebcf439c2d49 100644 (file)
 
 namespace WebCore {
 
-CharacterData::CharacterData(Document* document, const String& text, ConstructionType type)
-    : Node(document, type)
-    , m_data(text.impl() ? text.impl() : StringImpl::empty())
-{
-    ASSERT(type == CreateOther || type == CreateText);
-}
-
 void CharacterData::setData(const String& data, ExceptionCode&)
 {
     StringImpl* dataImpl = data.impl() ? data.impl() : StringImpl::empty();
index 6c31933868954522056df2e00ddc7ae41f64347b..94951408ca01249dfbf90fc2a81830e1a5fe7449 100644 (file)
@@ -43,7 +43,12 @@ public:
     StringImpl* dataImpl() { return m_data.get(); }
 
 protected:
-    CharacterData(Document*, const String&, ConstructionType);
+    CharacterData(Document* document, const String& text, ConstructionType type)
+        : Node(document, type)
+        , m_data(text.impl() ? text.impl() : StringImpl::empty())
+    {
+        ASSERT(type == CreateOther || type == CreateText);
+    }
 
     virtual bool rendererIsNeeded(RenderStyle*);
 
index 3dcde381481c4bc5e2b3f60071cddf5e05d2ec24..00f1724b415b04abcac834b50814257eb939456a 100644 (file)
 #include "config.h"
 #include "Comment.h"
 
+#include "Document.h"
+
 namespace WebCore {
 
 inline Comment::Comment(Document* document, const String& text)
-    : CharacterData(document, text, CreateOther)
+    : CharacterData(document, text, CreateComment)
 {
 }
 
index 680ffae968fe316ee31d4c74c6b99b5e6ca1200f..a0210c4bebdeacdf39691bb1407fd93aa06ace96 100644 (file)
@@ -37,7 +37,6 @@ private:
     virtual String nodeName() const;
     virtual NodeType nodeType() const;
     virtual PassRefPtr<Node> cloneNode(bool deep);
-    virtual bool isCommentNode() const { return true; }
     virtual bool childTypeAllowed(NodeType);
 };
 
index f42b9cfe1ab52f48467249739fc528f8149962ce..b063998349b0712ffc72904e533a76177053e65a 100644 (file)
@@ -616,7 +616,7 @@ void ContainerNode::detach()
 {
     for (Node* child = m_firstChild; child; child = child->nextSibling())
         child->detach();
-    setChildNeedsStyleRecalc(false);
+    clearChildNeedsStyleRecalc();
     Node::detach();
 }
 
@@ -633,7 +633,7 @@ void ContainerNode::removedFromDocument()
     Node::removedFromDocument();
     if (document()->cssTarget() == this) 
         document()->setCSSTarget(0); 
-    setInDocument(false);
+    clearInDocument();
     removedFromTree(false);
     for (Node* child = m_firstChild; child; child = child->nextSibling())
         child->removedFromDocument();
index 56b47282aa81121285c0b183a34a1fdd293c6672..01b8cbb222e44017ca361079874dc44cf30b7a83 100644 (file)
@@ -422,7 +422,7 @@ Document::Document(Frame* frame, bool isXHTML, bool isHTML)
 
     m_textColor = Color::black;
     m_listenerTypes = 0;
-    m_inDocument = true;
+    setInDocument();
     m_inStyleRecalc = false;
     m_closeAfterStyleRecalc = false;
 
@@ -1386,7 +1386,7 @@ void Document::recalcStyle(StyleChange change)
 
 bail_out:
     setNeedsStyleRecalc(NoStyleChange);
-    setChildNeedsStyleRecalc(false);
+    clearChildNeedsStyleRecalc();
     unscheduleStyleRecalc();
 
     if (view())
@@ -2835,7 +2835,7 @@ bool Document::setFocusedNode(PassRefPtr<Node> newFocusedNode)
     m_focusedNode = 0;
 
     // Remove focus from the existing focus node (if any)
-    if (oldFocusedNode && !oldFocusedNode->m_inDetach) { 
+    if (oldFocusedNode && !oldFocusedNode->inDetach()) { 
         if (oldFocusedNode->active())
             oldFocusedNode->setActive(false);
 
index ff5d43592751967ad7a9bbe905ae2586e04d4862..bd28f5dbb1e39c725f0abd88eb1ac09e24927d29 100644 (file)
@@ -1254,6 +1254,22 @@ inline bool Node::isDocumentNode() const
     return this == m_document;
 }
 
+// here because it uses a Document method but we really want to inline it
+inline Node::Node(Document* document, ConstructionType type)
+    : TreeShared<Node>(initialRefCount(type))
+    , m_document(document)
+    , m_previous(0)
+    , m_next(0)
+    , m_renderer(0)
+    , m_nodeFlags(type)
+{
+    if (m_document)
+        m_document->selfOnlyRef();
+#if !defined(NDEBUG) || (defined(DUMP_NODE_STATISTICS) && DUMP_NODE_STATISTICS)
+    trackForDebugging();
+#endif
+}
+
 } // namespace WebCore
 
 #endif // Document_h
index 3663e996a6ee01ffcf11e67ed6cc0e45ddb30e10..f7df8f6fd9972f38af3fdf629a685bffce5bb4c5 100644 (file)
@@ -23,6 +23,8 @@
 #include "config.h"
 #include "DocumentFragment.h"
 
+#include "Document.h"
+
 namespace WebCore {
 
 inline DocumentFragment::DocumentFragment(Document* document)
index b36931ab7c871ed1842f774c701263ae3a0c4143..e412ad69b31413137a6484460b5056ad72025810 100644 (file)
@@ -20,6 +20,8 @@
 #include "config.h"
 #include "EditingText.h"
 
+#include "Document.h"
+
 // FIXME: Does this really require a class? Perhaps instead any text node
 // inside an editable element could have the "always create a renderer" behavior.
 
index 6518a0fc8e10e4a4957a169f6b4e109a0b6c99c2..171a869a46590c36af285f9913c08f29855ef3cb 100644 (file)
@@ -64,12 +64,6 @@ namespace WebCore {
 using namespace HTMLNames;
 using namespace XMLNames;
     
-Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
-    : ContainerNode(document, type)
-    , m_tagName(tagName)
-{
-}
-
 PassRefPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return adoptRef(new Element(tagName, document, CreateElement));
@@ -225,11 +219,11 @@ bool Element::hasAttribute(const QualifiedName& name) const
 
 const AtomicString& Element::getAttribute(const QualifiedName& name) const
 {
-    if (name == styleAttr && !m_isStyleAttributeValid)
+    if (name == styleAttr && !isStyleAttributeValid())
         updateStyleAttribute();
 
 #if ENABLE(SVG)
-    if (!m_areSVGAttributesValid)
+    if (!areSVGAttributesValid())
         updateAnimatedSVGAttribute(name);
 #endif
 
@@ -532,11 +526,11 @@ const AtomicString& Element::getAttribute(const String& name) const
     bool ignoreCase = shouldIgnoreAttributeCase(this);
     
     // Update the 'style' attribute if it's invalid and being requested:
-    if (!m_isStyleAttributeValid && equalPossiblyIgnoringCase(name, styleAttr.localName(), ignoreCase))
+    if (!isStyleAttributeValid() && equalPossiblyIgnoringCase(name, styleAttr.localName(), ignoreCase))
         updateStyleAttribute();
 
 #if ENABLE(SVG)
-    if (!m_areSVGAttributesValid) {
+    if (!areSVGAttributesValid()) {
         // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
         updateAnimatedSVGAttribute(QualifiedName(nullAtom, name, nullAtom));
     }
@@ -583,7 +577,7 @@ void Element::setAttribute(const AtomicString& name, const AtomicString& value,
 #if ENABLE(INSPECTOR)
     if (Page* page = document()->page()) {
         if (InspectorController* inspectorController = page->inspectorController()) {
-            if (!m_synchronizingStyleAttribute)
+            if (!isSynchronizingStyleAttribute())
                 inspectorController->didModifyDOMAttr(this);
         }
     }
@@ -612,7 +606,7 @@ void Element::setAttribute(const QualifiedName& name, const AtomicString& value,
 #if ENABLE(INSPECTOR)
     if (Page* page = document()->page()) {
         if (InspectorController* inspectorController = page->inspectorController()) {
-            if (!m_synchronizingStyleAttribute)
+            if (!isSynchronizingStyleAttribute())
                 inspectorController->didModifyDOMAttr(this);
         }
     }
@@ -718,11 +712,11 @@ void Element::setAttributeMap(PassRefPtr<NamedNodeMap> list, FragmentScriptingPe
 
 bool Element::hasAttributes() const
 {
-    if (!m_isStyleAttributeValid)
+    if (!isStyleAttributeValid())
         updateStyleAttribute();
 
 #if ENABLE(SVG)
-    if (!m_areSVGAttributesValid)
+    if (!areSVGAttributesValid())
         updateAnimatedSVGAttribute(anyQName());
 #endif
 
@@ -916,7 +910,7 @@ void Element::recalcStyle(StyleChange change)
             attach(); // FIXME: The style gets computed twice by calling attach. We could do better if we passed the style along.
             // attach recalulates the style for all children. No need to do it twice.
             setNeedsStyleRecalc(NoStyleChange);
-            setChildNeedsStyleRecalc(false);
+            clearChildNeedsStyleRecalc();
             return;
         }
 
@@ -982,7 +976,7 @@ void Element::recalcStyle(StyleChange change)
     }
 
     setNeedsStyleRecalc(NoStyleChange);
-    setChildNeedsStyleRecalc(false);
+    clearChildNeedsStyleRecalc();
 }
 
 bool Element::childTypeAllowed(NodeType type)
@@ -1091,7 +1085,7 @@ void Element::childrenChanged(bool changedByParser, Node* beforeChange, Node* af
 void Element::finishParsingChildren()
 {
     ContainerNode::finishParsingChildren();
-    m_parsingChildrenFinished = true;
+    setIsParsingChildrenFinished();
     checkForSiblingStyleChanges(this, renderStyle(), true, lastChild(), 0, 0);
 }
 
index 847128cb0a7b81110ed68be99390ecabecfbae7e..3d02f1bdf30bc6a47fc3e6bb206524c713e4decb 100644 (file)
@@ -29,6 +29,7 @@
 #include "Document.h"
 #include "HTMLNames.h"
 #include "MappedAttributeEntry.h"
+#include "NamedNodeMap.h"
 #include "QualifiedName.h"
 #include "ScrollTypes.h"
 
@@ -236,9 +237,9 @@ public:
     // Use Document::registerForMediaVolumeCallbacks() to subscribe to this
     virtual void mediaVolumeDidChange() { }
 
-    bool isFinishedParsingChildren() const { return m_parsingChildrenFinished; }
+    bool isFinishedParsingChildren() const { return isParsingChildrenFinished(); }
     virtual void finishParsingChildren();
-    virtual void beginParsingChildren() { m_parsingChildrenFinished = false; }
+    virtual void beginParsingChildren() { clearIsParsingChildrenFinished(); }
 
     // ElementTraversal API
     Element* firstElementChild() const;
@@ -273,7 +274,11 @@ public:
     virtual void dispatchFormControlChangeEvent() { }
 
 protected:
-    Element(const QualifiedName&, Document*, ConstructionType);
+    Element(const QualifiedName& tagName, Document* document, ConstructionType type)
+        : ContainerNode(document, type)
+        , m_tagName(tagName)
+    {
+    }
 
     virtual void insertedIntoDocument();
     virtual void removedFromDocument();
@@ -357,11 +362,11 @@ inline const QualifiedName& Element::idAttributeName() const
 
 inline NamedNodeMap* Element::attributes(bool readonly) const
 {
-    if (!m_isStyleAttributeValid)
+    if (!isStyleAttributeValid())
         updateStyleAttribute();
 
 #if ENABLE(SVG)
-    if (!m_areSVGAttributesValid)
+    if (!areSVGAttributesValid())
         updateAnimatedSVGAttribute(anyQName());
 #endif
 
index c4c292a9e510fee25804501e8730f8304a7b21f4..72944ec5210720fcd7c64f771bccf67710003cd3 100644 (file)
@@ -21,6 +21,8 @@
 #include "config.h"
 #include "EntityReference.h"
 
+#include "Document.h"
+
 namespace WebCore {
 
 inline EntityReference::EntityReference(Document* document, const String& entityName)
index 83e9b002256a26644623465898325820ebf7253f..40cd29c6fae7ca210312ab99568eb58cd5f5efbf 100644 (file)
@@ -334,99 +334,8 @@ Node::StyleChange Node::diff(const RenderStyle* s1, const RenderStyle* s2)
     return ch;
 }
 
-inline bool Node::initialRefCount(ConstructionType type)
+void Node::trackForDebugging()
 {
-    switch (type) {
-        case CreateContainer:
-        case CreateElement:
-        case CreateOther:
-        case CreateText:
-            return 1;
-        case CreateElementZeroRefCount:
-            return 0;
-    }
-    ASSERT_NOT_REACHED();
-    return 1;
-}
-
-inline bool Node::isContainer(ConstructionType type)
-{
-    switch (type) {
-        case CreateContainer:
-        case CreateElement:
-        case CreateElementZeroRefCount:
-            return true;
-        case CreateOther:
-        case CreateText:
-            return false;
-    }
-    ASSERT_NOT_REACHED();
-    return false;
-}
-
-inline bool Node::isElement(ConstructionType type)
-{
-    switch (type) {
-        case CreateContainer:
-        case CreateOther:
-        case CreateText:
-            return false;
-        case CreateElement:
-        case CreateElementZeroRefCount:
-            return true;
-    }
-    ASSERT_NOT_REACHED();
-    return false;
-}
-
-inline bool Node::isText(ConstructionType type)
-{
-    switch (type) {
-        case CreateContainer:
-        case CreateElement:
-        case CreateElementZeroRefCount:
-        case CreateOther:
-            return false;
-        case CreateText:
-            return true;
-    }
-    ASSERT_NOT_REACHED();
-    return false;
-}
-
-Node::Node(Document* document, ConstructionType type)
-    : TreeShared<Node>(initialRefCount(type))
-    , m_document(document)
-    , m_previous(0)
-    , m_next(0)
-    , m_renderer(0)
-    , m_styleChange(NoStyleChange)
-    , m_hasId(false)
-    , m_hasClass(false)
-    , m_attached(false)
-    , m_childNeedsStyleRecalc(false)
-    , m_inDocument(false)
-    , m_isLink(false)
-    , m_active(false)
-    , m_hovered(false)
-    , m_inActiveChain(false)
-    , m_inDetach(false)
-    , m_hasRareData(false)
-    , m_isElement(isElement(type))
-    , m_isContainer(isContainer(type))
-    , m_isText(isText(type))
-    , m_parsingChildrenFinished(true)
-    , m_isStyleAttributeValid(true)
-    , m_synchronizingStyleAttribute(false)
-#if ENABLE(SVG)
-    , m_areSVGAttributesValid(true)
-    , m_synchronizingSVGAttributes(false)
-    , m_hasRareSVGData(false)
-#endif
-{
-    if (m_document)
-        m_document->selfOnlyRef();
-
 #ifndef NDEBUG
     if (shouldIgnoreLeaks)
         ignoreSet.add(this);
@@ -550,7 +459,7 @@ NodeRareData* Node::ensureRareData()
     ASSERT(!NodeRareData::rareDataMap().contains(this));
     NodeRareData* data = createRareData();
     NodeRareData::rareDataMap().set(this, data);
-    m_hasRareData = true;
+    setFlag(HasRareDataFlag);
     return data;
 }
     
@@ -787,17 +696,22 @@ bool Node::hasNonEmptyBoundingBox() const
     return false;
 }
 
+inline void Node::setStyleChange(StyleChangeType changeType)
+{
+    m_nodeFlags = (m_nodeFlags & ~StyleChangeMask) | changeType;
+}
+
 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
 {
     if ((changeType != NoStyleChange) && !attached()) // changed compared to what?
         return;
 
-    if (!(changeType == InlineStyleChange && (m_styleChange == FullStyleChange || m_styleChange == SyntheticStyleChange)))
-        m_styleChange = changeType;
+    if (!(changeType == InlineStyleChange && (styleChangeType() == FullStyleChange || styleChangeType() == SyntheticStyleChange)))
+        setStyleChange(changeType);
 
-    if (m_styleChange != NoStyleChange) {
+    if (styleChangeType() != NoStyleChange) {
         for (Node* p = parentNode(); p && !p->childNeedsStyleRecalc(); p = p->parentNode())
-            p->setChildNeedsStyleRecalc(true);
+            p->setChildNeedsStyleRecalc();
         if (document()->childNeedsStyleRecalc())
             document()->scheduleStyleRecalc();
     }
@@ -821,9 +735,9 @@ void Node::lazyAttach()
         }
 
         if (n->firstChild())
-            n->setChildNeedsStyleRecalc(true);
-        n->m_styleChange = FullStyleChange;
-        n->m_attached = true;
+            n->setChildNeedsStyleRecalc();
+        n->setStyleChange(FullStyleChange);
+        n->setAttached();
     }
 
     if (mustDoFullAttach) {
@@ -833,7 +747,7 @@ void Node::lazyAttach()
         lazyAttachedAncestor->attach();
     } else {
         for (Node* p = parentNode(); p && !p->childNeedsStyleRecalc(); p = p->parentNode())
-            p->setChildNeedsStyleRecalc(true);
+            p->setChildNeedsStyleRecalc();
         if (document()->childNeedsStyleRecalc())
             document()->scheduleStyleRecalc();
     }
@@ -1296,7 +1210,7 @@ void Node::attach()
         }
     }
 
-    m_attached = true;
+    setAttached();
 }
 
 void Node::willRemove()
@@ -1305,23 +1219,24 @@ void Node::willRemove()
 
 void Node::detach()
 {
-    m_inDetach = true;
+    setFlag(InDetachFlag);
 
     if (renderer())
         renderer()->destroy();
     setRenderer(0);
 
     Document* doc = document();
-    if (m_hovered)
+    if (hovered())
         doc->hoveredNodeDetached(this);
-    if (m_inActiveChain)
+    if (inActiveChain())
         doc->activeChainNodeDetached(this);
 
-    m_active = false;
-    m_hovered = false;
-    m_inActiveChain = false;
-    m_attached = false;
-    m_inDetach = false;
+    clearFlag(IsActiveFlag);
+    clearFlag(IsHoveredFlag);
+    clearFlag(InActiveChainFlag);
+    clearFlag(IsAttachedFlag);
+
+    clearFlag(InDetachFlag);
 }
 
 Node *Node::previousEditable() const
@@ -2370,12 +2285,12 @@ ScriptExecutionContext* Node::scriptExecutionContext() const
 
 void Node::insertedIntoDocument()
 {
-    setInDocument(true);
+    setInDocument();
 }
 
 void Node::removedFromDocument()
 {
-    setInDocument(false);
+    clearInDocument();
 }
 
 void Node::willMoveToNewOwnerDocument()
index bbb9cc68299c8a8f887409ecb21200da63ecd110..b79596c43ff8e2a7839fadf8af52eae8a3d948ac 100644 (file)
@@ -76,10 +76,17 @@ class TagNodeList;
 
 typedef int ExceptionCode;
 
+const int nodeStyleChangeShift = 24;
+
 // SyntheticStyleChange means that we need to go through the entire style change logic even though
 // no style property has actually changed. It is used to restructure the tree when, for instance,
 // RenderLayers are created or destroyed due to animation changes.
-enum StyleChangeType { NoStyleChange, InlineStyleChange, FullStyleChange, SyntheticStyleChange };
+enum StyleChangeType { 
+    NoStyleChange = 0, 
+    InlineStyleChange = 1 << nodeStyleChangeShift, 
+    FullStyleChange = 2 << nodeStyleChangeShift, 
+    SyntheticStyleChange = 3 << nodeStyleChangeShift
+};
 
 const unsigned short DOCUMENT_POSITION_EQUIVALENT = 0x00;
 const unsigned short DOCUMENT_POSITION_DISCONNECTED = 0x01;
@@ -174,17 +181,13 @@ public:
     
     // Other methods (not part of DOM)
 
-    bool isElementNode() const { return m_isElement; }
-    bool isContainerNode() const { return m_isContainer; }
-    bool isTextNode() const { return m_isText; }
+    bool isElementNode() const { return getFlag(IsElementFlag); }
+    bool isContainerNode() const { return getFlag(IsContainerFlag); }
+    bool isTextNode() const { return getFlag(IsTextFlag); }
 
-    virtual bool isHTMLElement() const { return false; }
+    bool isHTMLElement() const { return getFlag(IsHTMLFlag); }
 
-#if ENABLE(SVG)
-    virtual bool isSVGElement() const { return false; }
-#else
-    static bool isSVGElement() { return false; }
-#endif
+    bool isSVGElement() const { return getFlag(IsSVGFlag); }
 
 #if ENABLE(WML)
     virtual bool isWMLElement() const { return false; }
@@ -200,10 +203,10 @@ public:
 
 
     virtual bool isMediaControlElement() const { return false; }
-    virtual bool isStyledElement() const { return false; }
+    bool isStyledElement() const { return getFlag(IsStyledElementFlag); }
     virtual bool isFrameOwnerElement() const { return false; }
     virtual bool isAttributeNode() const { return false; }
-    virtual bool isCommentNode() const { return false; }
+    bool isCommentNode() const { return getFlag(IsCommentFlag); }
     virtual bool isCharacterDataNode() const { return false; }
     bool isDocumentNode() const;
     virtual bool isShadowNode() const { return false; }
@@ -280,33 +283,40 @@ public:
     // For <link> and <style> elements.
     virtual bool sheetLoaded() { return true; }
 
-    bool hasID() const { return m_hasId; }
-    bool hasClass() const { return m_hasClass; }
-    bool active() const { return m_active; }
-    bool inActiveChain() const { return m_inActiveChain; }
-    bool inDetach() const { return m_inDetach; }
-    bool hovered() const { return m_hovered; }
+    bool hasID() const { return getFlag(HasIDFlag); }
+    bool hasClass() const { return getFlag(HasClassFlag); }
+    bool active() const { return getFlag(IsActiveFlag); }
+    bool inActiveChain() const { return getFlag(InActiveChainFlag); }
+    bool inDetach() const { return getFlag(InDetachFlag); }
+    bool hovered() const { return getFlag(IsHoveredFlag); }
     bool focused() const { return hasRareData() ? rareDataFocused() : false; }
-    bool attached() const { return m_attached; }
-    void setAttached(bool b = true) { m_attached = b; }
-    bool needsStyleRecalc() const { return m_styleChange != NoStyleChange; }
-    StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_styleChange); }
-    bool childNeedsStyleRecalc() const { return m_childNeedsStyleRecalc; }
-    bool isLink() const { return m_isLink; }
-    void setHasID(bool b = true) { m_hasId = b; }
-    void setHasClass(bool b = true) { m_hasClass = b; }
-    void setChildNeedsStyleRecalc(bool b = true) { m_childNeedsStyleRecalc = b; }
-    void setInDocument(bool b = true) { m_inDocument = b; }
-    void setInActiveChain(bool b = true) { m_inActiveChain = b; }
+    bool attached() const { return getFlag(IsAttachedFlag); }
+    void setAttached() { setFlag(IsAttachedFlag); }
+    bool needsStyleRecalc() const { return styleChangeType() != NoStyleChange; }
+    StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_nodeFlags & StyleChangeMask); }
+    bool childNeedsStyleRecalc() const { return getFlag(ChildNeedsStyleRecalcFlag); }
+    bool isLink() const { return getFlag(IsLinkFlag); }
+
+    void setHasID(bool f) { setFlag(f, HasIDFlag); }
+    void setHasClass(bool f) { setFlag(f, HasClassFlag); }
+    void setChildNeedsStyleRecalc() { setFlag(ChildNeedsStyleRecalcFlag); }
+    void clearChildNeedsStyleRecalc() { clearFlag(ChildNeedsStyleRecalcFlag); }
+    void setInDocument() { setFlag(InDocumentFlag); }
+    void clearInDocument() { clearFlag(InDocumentFlag); }
+
+    void setInActiveChain() { setFlag(InActiveChainFlag); }
+    void clearInActiveChain() { clearFlag(InActiveChainFlag); }
     void setNeedsStyleRecalc(StyleChangeType changeType = FullStyleChange);
-    void setIsLink(bool b = true) { m_isLink = b; }
+    void setIsLink(bool f) { setFlag(f, IsLinkFlag); }
+    void setIsLink() { setFlag(IsLinkFlag); }
+    void clearIsLink() { clearFlag(IsLinkFlag); }
 
     void lazyAttach();
     virtual bool canLazyAttach();
 
     virtual void setFocus(bool b = true);
-    virtual void setActive(bool b = true, bool /*pause*/ = false) { m_active = b; }
-    virtual void setHovered(bool b = true) { m_hovered = b; }
+    virtual void setActive(bool f = true, bool /*pause*/ = false) { setFlag(f, IsActiveFlag); }
+    virtual void setHovered(bool f = true) { setFlag(f, IsHoveredFlag); }
 
     virtual short tabIndex() const;
 
@@ -351,7 +361,7 @@ public:
     bool inDocument() const 
     { 
         ASSERT(m_document || !m_inDocument);
-        return m_inDocument; 
+        return getFlag(InDocumentFlag);
     }
 
     bool isReadOnlyNode() const { return nodeType() == ENTITY_REFERENCE_NODE; }
@@ -590,10 +600,71 @@ public:
     }
 #endif
 
+private:
+    enum NodeFlags {
+        IsTextFlag = 1,
+        IsCommentFlag = 1 << 1,
+        IsContainerFlag = 1 << 2,
+        IsElementFlag = 1 << 3,
+        IsStyledElementFlag = 1 << 4,
+        IsHTMLFlag = 1 << 5,
+        IsSVGFlag = 1 << 6,
+        HasIDFlag = 1 << 7,
+        HasClassFlag = 1 << 8,
+        IsAttachedFlag = 1 << 9,
+        ChildNeedsStyleRecalcFlag = 1 << 10,
+        InDocumentFlag = 1 << 11,
+        IsLinkFlag = 1 << 12,
+        IsActiveFlag = 1 << 13,
+        IsHoveredFlag = 1 << 14,
+        InActiveChainFlag = 1 << 15,
+        InDetachFlag = 1 << 16,
+        HasRareDataFlag = 1 << 17,
+
+        // These bits are used by derived classes, pulled up here so they can
+        // be stored in the same memory word as the Node bits above.
+        IsParsingChildrenFinishedFlag = 1 << 18, // Element
+        IsStyleAttributeValidFlag = 1 << 19, // StyledElement
+        IsSynchronizingStyleAttributeFlag = 1 << 20, // StyledElement
+#if ENABLE(SVG)
+        AreSVGAttributesValidFlag = 1 << 21, // Element
+        IsSynchronizingSVGAttributesFlag = 1 << 22, // SVGElement
+        HasSVGRareDataFlag = 1 << 23, // SVGElement
+#endif
+        StyleChangeMask = 1 << nodeStyleChangeShift | 1 << (nodeStyleChangeShift + 1),
+        CreateWithZeroRefCountFlag = 1 << 26,
+
+#if ENABLE(SVG)
+        DefaultNodeFlags = IsParsingChildrenFinishedFlag | IsStyleAttributeValidFlag | AreSVGAttributesValidFlag
+#else
+        DefaultNodeFlags = IsParsingChildrenFinishedFlag | IsStyleAttributeValidFlag
+#endif
+    };
+
+    // 5 bits remaining
+
+    bool getFlag(NodeFlags mask) const { return m_nodeFlags & mask; }
+    void setFlag(bool f, NodeFlags mask) const { m_nodeFlags = (m_nodeFlags & ~mask) | (-f & mask); } 
+    void setFlag(NodeFlags mask) const { m_nodeFlags |= mask; } 
+    void clearFlag(NodeFlags mask) const { m_nodeFlags &= ~mask; } 
+
 protected:
     // CreateElementZeroRefCount is deprecated and can be removed once we convert all element
     // classes to start with a reference count of 1.
-    enum ConstructionType { CreateContainer, CreateElement, CreateOther, CreateText, CreateElementZeroRefCount };
+    enum ConstructionType { 
+        CreateOther = DefaultNodeFlags,
+        CreateText = DefaultNodeFlags | IsTextFlag,
+        CreateComment = DefaultNodeFlags | IsCommentFlag,
+        CreateContainer = DefaultNodeFlags | IsContainerFlag, 
+        CreateElement = CreateContainer | IsElementFlag, 
+        CreateElementZeroRefCount = IsElementFlag | CreateWithZeroRefCountFlag, 
+        CreateStyledElement = CreateElement | IsStyledElementFlag, 
+        CreateStyledElementZeroRefCount =  CreateStyledElement | CreateWithZeroRefCountFlag, 
+        CreateHTMLElement = CreateStyledElement | IsHTMLFlag, 
+        CreateHTMLElementZeroRefCount = CreateHTMLElement | CreateWithZeroRefCountFlag,
+        CreateSVGElement = CreateStyledElement | IsSVGFlag, 
+        CreateSVGElementZeroRefCount = CreateSVGElement | CreateWithZeroRefCountFlag,
+    };
     Node(Document*, ConstructionType);
 
     virtual void willMoveToNewOwnerDocument();
@@ -602,10 +673,7 @@ protected:
     virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }
     void setTabIndexExplicitly(short);
     
-    bool hasRareData() const { return m_hasRareData; }
-#if ENABLE(SVG)
-    bool hasRareSVGData() const { return m_hasRareSVGData; }
-#endif
+    bool hasRareData() const { return getFlag(HasRareDataFlag); }
 
     NodeRareData* rareData() const;
     NodeRareData* ensureRareData();
@@ -616,9 +684,7 @@ private:
 #endif
 
     static bool initialRefCount(ConstructionType);
-    static bool isContainer(ConstructionType);
-    static bool isElement(ConstructionType);
-    static bool isText(ConstructionType);
+    void setStyleChange(StyleChangeType);
 
     virtual void refEventTarget() { ref(); }
     virtual void derefEventTarget() { deref(); }
@@ -640,45 +706,45 @@ private:
     Element* ancestorElement() const;
 
     void appendTextContent(bool convertBRsToNewlines, StringBuilder&) const;
+    void trackForDebugging();
 
     Document* m_document;
     Node* m_previous;
     Node* m_next;
     RenderObject* m_renderer;
-
-    unsigned m_styleChange : 2;
-    bool m_hasId : 1;
-    bool m_hasClass : 1;
-    bool m_attached : 1;
-    bool m_childNeedsStyleRecalc : 1;
-    bool m_inDocument : 1;
-    bool m_isLink : 1;
-    bool m_active : 1;
-    bool m_hovered : 1;
-    bool m_inActiveChain : 1;
-    bool m_inDetach : 1;
-    bool m_hasRareData : 1;
-    const bool m_isElement : 1;
-    const bool m_isContainer : 1;
-    const bool m_isText : 1;
-
-protected:
-    // These bits are used by derived classes, pulled up here so they can
-    // be stored in the same memory word as the Node bits above.
-
-    bool m_parsingChildrenFinished : 1; // Element
-    mutable bool m_isStyleAttributeValid : 1; // StyledElement
-    mutable bool m_synchronizingStyleAttribute : 1; // StyledElement
+    mutable uint32_t m_nodeFlags;
+
+ protected:
+    bool isParsingChildrenFinished() const { return getFlag(IsParsingChildrenFinishedFlag); }
+    void setIsParsingChildrenFinished() { setFlag(IsParsingChildrenFinishedFlag); }
+    void clearIsParsingChildrenFinished() { clearFlag(IsParsingChildrenFinishedFlag); }
+    bool isStyleAttributeValid() const { return getFlag(IsStyleAttributeValidFlag); }
+    void setIsStyleAttributeValid(bool f) { setFlag(f, IsStyleAttributeValidFlag); }
+    void setIsStyleAttributeValid() const { setFlag(IsStyleAttributeValidFlag); }
+    void clearIsStyleAttributeValid() { clearFlag(IsStyleAttributeValidFlag); }
+    bool isSynchronizingStyleAttribute() const { return getFlag(IsSynchronizingStyleAttributeFlag); }
+    void setIsSynchronizingStyleAttribute(bool f) { setFlag(f, IsSynchronizingStyleAttributeFlag); }
+    void setIsSynchronizingStyleAttribute() const { setFlag(IsSynchronizingStyleAttributeFlag); }
+    void clearIsSynchronizingStyleAttribute() const { clearFlag(IsSynchronizingStyleAttributeFlag); }
 
 #if ENABLE(SVG)
-    mutable bool m_areSVGAttributesValid : 1; // Element
-    mutable bool m_synchronizingSVGAttributes : 1; // SVGElement
-    bool m_hasRareSVGData : 1; // SVGElement
+    bool areSVGAttributesValid() const { return getFlag(AreSVGAttributesValidFlag); }
+    void setAreSVGAttributesValid() const { setFlag(AreSVGAttributesValidFlag); }
+    void clearAreSVGAttributesValid() { clearFlag(AreSVGAttributesValidFlag); }
+    bool isSynchronizingSVGAttributes() const { return getFlag(IsSynchronizingSVGAttributesFlag); }
+    void setIsSynchronizingSVGAttributes() const { setFlag(IsSynchronizingSVGAttributesFlag); }
+    void clearIsSynchronizingSVGAttributes() const { clearFlag(IsSynchronizingSVGAttributesFlag); }
+    bool hasRareSVGData() const { return getFlag(HasSVGRareDataFlag); }
+    void setHasRareSVGData() { setFlag(HasSVGRareDataFlag); }
+    void clearHasRareSVGData() { clearFlag(HasSVGRareDataFlag); }
 #endif
-
-    // 10 bits remaining
 };
 
+inline bool Node::initialRefCount(ConstructionType type)
+{
+    return !(type & CreateWithZeroRefCountFlag);
+}
+
 // Used in Node::addSubresourceAttributeURLs() and in addSubresourceStyleURLs()
 inline void addSubresourceURL(ListHashSet<KURL>& urls, const KURL& url)
 {
index 3607963a7046af7b706c79ff805d253ffbb3fcd3..cd5f86370a78e764a316170b5b954e60841f8df9 100644 (file)
@@ -103,17 +103,12 @@ void StyledElement::removeMappedAttributeDecl(MappedAttributeEntry entryType, co
 
 void StyledElement::updateStyleAttribute() const
 {
-    ASSERT(!m_isStyleAttributeValid);
-    m_isStyleAttributeValid = true;
-    m_synchronizingStyleAttribute = true;
+    ASSERT(!isStyleAttributeValid());
+    setIsStyleAttributeValid();
+    setIsSynchronizingStyleAttribute();
     if (m_inlineStyleDecl)
         const_cast<StyledElement*>(this)->setAttribute(styleAttr, m_inlineStyleDecl->cssText());
-    m_synchronizingStyleAttribute = false;
-}
-
-StyledElement::StyledElement(const QualifiedName& name, Document* document, ConstructionType type)
-    : Element(name, document, type)
-{
+    clearIsSynchronizingStyleAttribute();
 }
 
 StyledElement::~StyledElement()
@@ -208,7 +203,7 @@ bool StyledElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEnt
 {
     result = eNone;
     if (attrName == styleAttr)
-        return !m_synchronizingStyleAttribute;
+        return !isSynchronizingStyleAttribute();
     return true;
 }
 
@@ -253,7 +248,7 @@ void StyledElement::parseMappedAttribute(MappedAttribute *attr)
             destroyInlineStyleDecl();
         else
             getInlineStyleDecl()->parseDeclaration(attr->value());
-        m_isStyleAttributeValid = true;
+        setIsStyleAttributeValid();
         setNeedsStyleRecalc();
     }
 }
@@ -476,8 +471,8 @@ void StyledElement::copyNonAttributeProperties(const Element *sourceElement)
         return;
 
     *getInlineStyleDecl() = *source->m_inlineStyleDecl;
-    m_isStyleAttributeValid = source->m_isStyleAttributeValid;
-    m_synchronizingStyleAttribute = source->m_synchronizingStyleAttribute;
+    setIsStyleAttributeValid(source->isStyleAttributeValid());
+    setIsSynchronizingStyleAttribute(source->isSynchronizingStyleAttribute());
     
     Element::copyNonAttributeProperties(sourceElement);
 }
index 52bffd31e343da896a03e82b28f6baeddccaefea..279282cb8e7663ed77383459d1b3bf5ae3578661 100644 (file)
@@ -25,6 +25,7 @@
 #ifndef StyledElement_h
 #define StyledElement_h
 
+#include "CSSMutableStyleDeclaration.h"
 #include "CSSPrimitiveValue.h"
 #include "Element.h"
 #include "MappedAttributeEntry.h"
@@ -33,7 +34,6 @@
 namespace WebCore {
 
 class CSSMappedAttributeDeclaration;
-class CSSMutableStyleDeclaration;
 class MappedAttribute;
 
 class StyledElement : public Element {
@@ -73,7 +73,10 @@ public:
     virtual PassRefPtr<Attribute> createAttribute(const QualifiedName&, const AtomicString& value);
 
 protected:
-    StyledElement(const QualifiedName&, Document*, ConstructionType);
+    StyledElement(const QualifiedName& name, Document* document, ConstructionType type)
+        : Element(name, document, type)
+    {
+    }
 
     virtual void attributeChanged(Attribute*, bool preserveDecls = false);
     virtual void parseMappedAttribute(MappedAttribute*);
@@ -89,8 +92,6 @@ protected:
     virtual void didMoveToNewOwnerDocument();
 
 private:
-    virtual bool isStyledElement() const { return true; }
-
     void createMappedDecl(MappedAttribute*);
 
     void createInlineStyleDecl();
@@ -104,7 +105,7 @@ private:
 
 inline void StyledElement::invalidateStyleAttribute()
 {
-    m_isStyleAttributeValid = false;
+    clearIsStyleAttributeValid();
 }
 
 } //namespace
index cf98817535db646b9238fc882cf3f9c63fd19bc2..14da1a4ec557db4df5ba575767c05aa6a2659ebe 100644 (file)
@@ -41,11 +41,6 @@ using namespace std;
 
 namespace WebCore {
 
-Text::Text(Document* document, const String& data)
-    : CharacterData(document, data, CreateText)
-{
-}
-
 PassRefPtr<Text> Text::create(Document* document, const String& data)
 {
     return adoptRef(new Text(document, data));
index 4722736f995c382735e6ee2ca2d2eb1c5a4b88e5..45678ef8d8ebd8f725028e72b01842de8aeca51d 100644 (file)
@@ -44,7 +44,10 @@ public:
     virtual void attach();
 
 protected:
-    Text(Document*, const String&);
+    Text(Document* document, const String& data)
+        : CharacterData(document, data, CreateText)
+    {
+    }
 
 private:
     virtual String nodeName() const;
index 223f731f6269ffea50a34733c3b7e1f98ba9004f..e3752c37d3a4c95e713e9e7a42af99651baaa37d 100644 (file)
@@ -42,7 +42,7 @@ namespace WebCore {
 using namespace HTMLNames;
 
 HTMLAnchorElement::HTMLAnchorElement(const QualifiedName& tagName, Document* document)
-    : HTMLElement(tagName, document, CreateElement)
+    : HTMLElement(tagName, document, CreateHTMLElement)
     , m_wasShiftKeyDownOnMouseDown(false)
     , m_linkRelations(0)
 {
@@ -265,7 +265,7 @@ void HTMLAnchorElement::parseMappedAttribute(MappedAttribute *attr)
                     ResourceHandle::prepareForURL(document()->completeURL(parsedURL));
             }
             if (document()->page() && !document()->page()->javaScriptURLsAreAllowed() && protocolIsJavaScript(parsedURL)) {
-                setIsLink(false);
+                clearIsLink();
                 attr->setValue(nullAtom);
             }
         }
index 816bb60ec4bcc20c0b2eefe5813e8a17ab41398b..f2ffc1636bb91ef75501d424220f9b3ff16e9ed1 100644 (file)
@@ -58,7 +58,7 @@ using std::max;
 
 PassRefPtr<HTMLElement> HTMLElement::create(const QualifiedName& tagName, Document* document)
 {
-    return adoptRef(new HTMLElement(tagName, document, CreateElement));
+    return adoptRef(new HTMLElement(tagName, document, CreateHTMLElement));
 }
 
 String HTMLElement::nodeName() const
index ccc9aa3de606b8278c663e59e87063f9eb16b58d..b51dba4cb78df1c92fe199b3034d1f66163977aa 100644 (file)
@@ -82,7 +82,7 @@ public:
     static void addHTMLAlignmentToStyledElement(StyledElement*, MappedAttribute*);
 
 protected:
-    HTMLElement(const QualifiedName& tagName, Document*, ConstructionType = CreateElementZeroRefCount);
+    HTMLElement(const QualifiedName& tagName, Document*, ConstructionType = CreateHTMLElementZeroRefCount);
 
     void addHTMLAlignment(MappedAttribute*);
 
@@ -102,8 +102,6 @@ protected:
     HTMLFormElement* findFormAncestor() const;
 
 private:
-    virtual bool isHTMLElement() const { return true; }
-
     virtual String nodeName() const;
 
     void setContentEditable(MappedAttribute*);
index 05a4ccd8914e1f0a063dc64a5663a850a6903be1..5b3a49052bfa863fedf0f1d3fcbf79687a3fc9ba 100644 (file)
@@ -36,7 +36,7 @@ class VisibleSelection;
 
 class HTMLFormControlElement : public HTMLElement {
 public:
-    HTMLFormControlElement(const QualifiedName& tagName, Document*, HTMLFormElement*, ConstructionType = CreateElementZeroRefCount);
+    HTMLFormControlElement(const QualifiedName& tagName, Document*, HTMLFormElement*, ConstructionType = CreateHTMLElementZeroRefCount);
     virtual ~HTMLFormControlElement();
 
     virtual HTMLTagStatus endTagRequirement() const { return TagStatusRequired; }
index c3ae7859260d57f3b4f91bfe5d205fbf8aa0d42e..a9538fd30b6fae81c8410ade4c167025831d7608 100644 (file)
@@ -33,7 +33,7 @@
 namespace WebCore {
 
 HTMLFrameOwnerElement::HTMLFrameOwnerElement(const QualifiedName& tagName, Document* document)
-    : HTMLElement(tagName, document, CreateElement)
+    : HTMLElement(tagName, document, CreateHTMLElement)
     , m_contentFrame(0)
     , m_sandboxFlags(SandboxNone)
 {
index e11ec1859e373429870e14dfc0b53bcbb9765472..84a9794d54186d3034635fea3cc0995690f68ef6 100644 (file)
@@ -36,7 +36,7 @@ namespace WebCore {
 using namespace HTMLNames;
 
 HTMLProgressElement::HTMLProgressElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
-    : HTMLFormControlElement(tagName, document, form, CreateElement)
+    : HTMLFormControlElement(tagName, document, form, CreateHTMLElement)
 {
     ASSERT(hasTagName(progressTag));
 }
index b47f4a96234f65d84af11b7835ad6e9bdcd60710..b84616f2a2dc30c7ab28686dea6d01b2cb3a6878 100644 (file)
@@ -37,7 +37,7 @@ namespace WebCore {
 using namespace MathMLNames;
     
 MathMLElement::MathMLElement(const QualifiedName& tagName, Document* document)
-    : StyledElement(tagName, document, CreateElementZeroRefCount)
+    : StyledElement(tagName, document, CreateStyledElementZeroRefCount)
 {
 }
     
index 569f21484512b86c1f81e1a2b72723ec5d2c4be1..16827f54c2792cd2cd7ad8235472e62856ca3199 100644 (file)
@@ -74,7 +74,7 @@ MediaControlShadowRootElement::MediaControlShadowRootElement(Document* document,
     renderer->setStyle(rootStyle.release());
     setRenderer(renderer);
     setAttached();
-    setInDocument(true);
+    setInDocument();
 }
 
 void MediaControlShadowRootElement::updateStyle()
@@ -92,7 +92,7 @@ MediaControlElement::MediaControlElement(Document* document, PseudoId pseudo, HT
     , m_mediaElement(mediaElement)
     , m_pseudoStyleId(pseudo)
 {
-    setInDocument(true);
+    setInDocument();
     switch (pseudo) {
     case MEDIA_CONTROLS_CURRENT_TIME_DISPLAY:
         m_displayType = MediaCurrentTimeDisplay;
@@ -318,7 +318,7 @@ MediaControlInputElement::MediaControlInputElement(Document* document, PseudoId
     , m_pseudoStyleId(pseudo)
 {
     setInputType(type);
-    setInDocument(true);
+    setInDocument();
 
     switch (pseudo) {
     case MEDIA_CONTROLS_MUTE_BUTTON:
index b10e2d753011a94a61d6e0f9799ceb013fe75b01..fa2a99844c64f204c0051c2e6e7cc860ed8d7f17 100644 (file)
@@ -152,7 +152,7 @@ void RenderFileUploadControl::updateFromElement()
         renderer->setStyle(buttonStyle.release());
         renderer->updateFromElement();
         m_button->setAttached();
-        m_button->setInDocument(true);
+        m_button->setInDocument();
 
         addChild(renderer);
     }
index a645c1b55c8c782cfc0738189ac7f8d70fedcde6..6e9290eef7971fc84dad3902f324fa65f440542e 100644 (file)
@@ -3183,7 +3183,7 @@ void RenderLayer::updateHoverActiveState(const HitTestRequest& request, HitTestR
         // We are clearing the :active chain because the mouse has been released.
         for (RenderObject* curr = activeNode->renderer(); curr; curr = curr->parent()) {
             if (curr->node() && !curr->isText())
-                curr->node()->setInActiveChain(false);
+                curr->node()->clearInActiveChain();
         }
         doc->setActiveNode(0);
     } else {
@@ -3193,7 +3193,7 @@ void RenderLayer::updateHoverActiveState(const HitTestRequest& request, HitTestR
             // will need to reference this chain.
             for (RenderObject* curr = newActiveNode->renderer(); curr; curr = curr->parent()) {
                 if (curr->node() && !curr->isText()) {
-                    curr->node()->setInActiveChain(true);
+                    curr->node()->setInActiveChain();
                 }
             }
             doc->setActiveNode(newActiveNode);
index cfbc4934c05858f8e22dd03c1b3d0ead2c1d4cf8..b42cc8bb13e0cbd2c867ae1a1d1fb33385c2bde8 100644 (file)
@@ -141,7 +141,7 @@ void RenderProgress::updateValuePartState()
         m_valuePart->setRenderer(m_valuePart->createRenderer(renderArena(), styleForValuePart.get()));
         m_valuePart->renderer()->setStyle(styleForValuePart.release());
         m_valuePart->setAttached();
-        m_valuePart->setInDocument(true);
+        m_valuePart->setInDocument();
         addChild(m_valuePart->renderer());
     } else if (style()->hasAppearance() && m_valuePart) {
         m_valuePart->detach();
index 3105709479d9743a64e3f40bbf0300bcf811386d..1ca571ee3abbcc7aca2c0273f22e03f3b1af4c80 100644 (file)
@@ -310,7 +310,7 @@ void RenderSlider::updateFromElement()
         m_thumb->setRenderer(m_thumb->createRenderer(renderArena(), thumbStyle.get()));
         m_thumb->renderer()->setStyle(thumbStyle.release());
         m_thumb->setAttached();
-        m_thumb->setInDocument(true);
+        m_thumb->setInDocument();
         addChild(m_thumb->renderer());
     }
     setNeedsLayout(true);
index d9ce6400289a60034d1ca5fde181fbf1cac6647a..f26f87e289336539a0ae2ad316799d00d237e22a 100644 (file)
@@ -49,7 +49,7 @@ SVGShadowTreeRootElement::SVGShadowTreeRootElement(Document* document, Node* sha
     : SVGShadowTreeContainerElement(document)
     , m_shadowParent(shadowParent)
 {
-    setInDocument(true);
+    setInDocument();
 }
 
 SVGShadowTreeRootElement::~SVGShadowTreeRootElement()
index 3f3fec46ee91e222c0252fc1ac95d553b9c8e620..84f7c0fb24b688a63ccb1a866b54076d79d3d384 100644 (file)
@@ -96,7 +96,7 @@ void TextControlInnerElement::attachInnerElement(Node* parent, PassRefPtr<Render
     
     // Set these explicitly since this normally happens during an attach()
     setAttached();
-    setInDocument(true);
+    setInDocument();
     
     // For elements without a shadow parent, add the node to the DOM normally.
     if (!m_shadowParent)
index f1cf0bc3cc70397a2d3854b5d4ed0b68bec7e322..f3b3f0c319980a8f3220811fc80bd214660a13dc 100644 (file)
@@ -58,7 +58,7 @@ PassRefPtr<RenderStyle> RenderStyle::clone(const RenderStyle* other)
     return adoptRef(new RenderStyle(*other));
 }
 
-RenderStyle::RenderStyle()
+ALWAYS_INLINE RenderStyle::RenderStyle()
     : m_affectedByAttributeSelectors(false)
     , m_unique(false)
     , m_affectedByEmpty(false)
@@ -85,7 +85,7 @@ RenderStyle::RenderStyle()
     setBitDefaults(); // Would it be faster to copy this from the default style?
 }
 
-RenderStyle::RenderStyle(bool)
+ALWAYS_INLINE RenderStyle::RenderStyle(bool)
     : m_affectedByAttributeSelectors(false)
     , m_unique(false)
     , m_affectedByEmpty(false)
@@ -118,7 +118,7 @@ RenderStyle::RenderStyle(bool)
 #endif
 }
 
-RenderStyle::RenderStyle(const RenderStyle& o)
+ALWAYS_INLINE RenderStyle::RenderStyle(const RenderStyle& o)
     : RefCounted<RenderStyle>()
     , m_affectedByAttributeSelectors(false)
     , m_unique(false)
index a31949a8840a92920dc955cb3149c6bdd696501f..192a5e5564efea9f058fe18fbd247f9db006d5f6 100644 (file)
@@ -302,7 +302,7 @@ protected:
         noninherited_flags._isLink = false;
     }
 
-protected:
+private:
     RenderStyle();
     // used to create the default style.
     RenderStyle(bool);
index 0e3ceda5e6daeef0154e5a01de69ca1d4c1f6965..b963265eddf09f7d633b4ea651f540510ad1c3cb 100644 (file)
@@ -48,13 +48,13 @@ public:
     virtual void setBaseVal(PassType type)
     {
         m_creator.setBaseValue(type);
-        m_contextElement->setSynchronizedSVGAttributes(false);
+        m_contextElement->invalidateSVGAttributes();
     }
 
     virtual void setAnimVal(PassType type)
     {
         m_creator.setValue(type);
-        m_contextElement->setSynchronizedSVGAttributes(false);
+        m_contextElement->invalidateSVGAttributes();
     }
 
     virtual ReturnType baseVal() const { return m_creator.baseValue(); }
@@ -181,14 +181,14 @@ public: \
     { \
         m_##LowerProperty.setValue(type); \
         SVGElement* contextElement = GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value>::ownerElement(this); \
-        contextElement->setSynchronizedSVGAttributes(false); \
+        contextElement->invalidateSVGAttributes(); \
     } \
     \
     void set##UpperProperty##BaseValue(SVGAnimatedPropertyTraits<AnimatedType>::PassType type) \
     { \
         m_##LowerProperty.setBaseValue(type); \
         SVGElement* contextElement = GetOwnerElementForType<OwnerType, IsDerivedFromSVGElement<OwnerType>::value>::ownerElement(this); \
-        contextElement->setSynchronizedSVGAttributes(false); \
+        contextElement->invalidateSVGAttributes(); \
     } \
     \
     void synchronize##UpperProperty() \
index e81064078590c3fe1fe8793764d9405e6e384b61..ab146bb8a0f738a2da4c76bc02c5adf38a175422 100644 (file)
@@ -52,7 +52,7 @@ namespace WebCore {
 using namespace HTMLNames;
 
 SVGElement::SVGElement(const QualifiedName& tagName, Document* document)
-    : StyledElement(tagName, document, CreateElementZeroRefCount)
+    : StyledElement(tagName, document, CreateSVGElementZeroRefCount)
 {
 }
 
@@ -95,7 +95,7 @@ SVGElementRareData* SVGElement::ensureRareSVGData()
     ASSERT(!SVGElementRareData::rareDataMap().contains(this));
     SVGElementRareData* data = new SVGElementRareData;
     SVGElementRareData::rareDataMap().set(this, data);
-    m_hasRareSVGData = true;
+    setHasRareSVGData();
     return data;
 }
 
@@ -306,16 +306,16 @@ void SVGElement::attributeChanged(Attribute* attr, bool preserveDecls)
 
 void SVGElement::updateAnimatedSVGAttribute(const QualifiedName& name) const
 {
-    if (m_synchronizingSVGAttributes || m_areSVGAttributesValid)
+    if (isSynchronizingSVGAttributes() || areSVGAttributesValid())
         return;
 
-    m_synchronizingSVGAttributes = true;
+    setIsSynchronizingSVGAttributes();
 
     const_cast<SVGElement*>(this)->synchronizeProperty(name);
     if (name == anyQName())
-        m_areSVGAttributesValid = true;
+        setAreSVGAttributesValid();
 
-    m_synchronizingSVGAttributes = false;
+    clearIsSynchronizingSVGAttributes();
 }
 
 ContainerNode* SVGElement::eventParentNode()
index 99e24795fb8a070bcd7fc8cba63d04b9072c29c8..9467250ff711a385df85398f4e8b0672da85b929 100644 (file)
@@ -72,7 +72,7 @@ namespace WebCore {
         
         virtual AffineTransform* supplementalTransform() { return 0; }
 
-        void setSynchronizedSVGAttributes(bool value) { m_areSVGAttributesValid = value; }
+        void invalidateSVGAttributes() { clearAreSVGAttributesValid(); }
 
         const HashSet<SVGElementInstance*>& instancesForElement() const;
 
@@ -94,7 +94,6 @@ namespace WebCore {
     private:
         friend class SVGElementInstance;
 
-        virtual bool isSVGElement() const { return true; }
         virtual bool isSupported(StringImpl* feature, StringImpl* version) const;
 
         virtual ContainerNode* eventParentNode();
index 371c6799bb94258bd65800f0db4a67018289a32c..73940dceade8d1de24ce8fc875aa344a33e51fcb 100644 (file)
@@ -88,7 +88,7 @@ void SVGPolyElement::svgAttributeChanged(const QualifiedName& attrName)
 
     // The points property is not a regular SVGAnimatedProperty, still we use the same SVG<->XML DOM synchronization framework.
     if (attrName == SVGNames::pointsAttr)
-        setSynchronizedSVGAttributes(false);
+        invalidateSVGAttributes();
 
     RenderPath* renderer = static_cast<RenderPath*>(this->renderer());
     if (!renderer)
index b9b3f533bf6c1732469088e58571e3e0b3b8f8d5..ac9c8f2fc00cbb15e7392c61bda6342329dbabd5 100644 (file)
@@ -34,10 +34,10 @@ WMLAnchorElement::WMLAnchorElement(const QualifiedName& tagName, Document* doc)
     : WMLAElement(tagName, doc)
     , m_task(0)
 {
-    // Calling setIsLink(true), and returning a non-null value on CSSStyleSelectors' linkAttribute
+    // Calling setIsLink(), and returning a non-null value on CSSStyleSelectors' linkAttribute
     // method, makes it possible to 'appear as link' (just like <a href="..">) without the need to
     // actually set the href value to an empty value in the DOM tree.
-    setIsLink(true);
+    setIsLink();
 }
 
 WMLAnchorElement::~WMLAnchorElement()
index 3004aba1d45d688ae3e4d0e8c63f2487bda9ed92..89fd07af087f6310dac56a944b668bb6de530ec4 100644 (file)
@@ -39,7 +39,7 @@ namespace WebCore {
 using namespace WMLNames;
 
 WMLElement::WMLElement(const QualifiedName& tagName, Document* document)
-    : StyledElement(tagName, document, CreateElementZeroRefCount)
+    : StyledElement(tagName, document, CreateStyledElementZeroRefCount)
 {
 }