Changeset 207458 in webkit


Ignore:
Timestamp:
Oct 18, 2016, 5:28:55 AM (8 years ago)
Author:
Antti Koivisto
Message:

Rename setNeedsStyleRecalc to invalidateStyle
​https://bugs.webkit.org/show_bug.cgi?id=163542

Reviewed by Darin Adler.

Source/WebCore:

Also rename StyleChangeType enum and some related functions for clarity. For example

element.setNeedsStyleRecalc(SyntheticStyleChange);

becomes

element.invalidateStyleAndLayerComposition();

  • WebCore.xcodeproj/project.pbxproj:
  • css/StyleInvalidationAnalysis.cpp:

(WebCore::StyleInvalidationAnalysis::invalidateIfNeeded):

  • dom/Document.cpp:

(WebCore::Document::recalcStyle):
(WebCore::Document::updateViewportUnitsOnResize):
(WebCore::Document::setCSSTarget):
(WebCore::unwrapFullScreenRenderer):
(WebCore::Document::setAnimatingFullScreen):

  • dom/Element.cpp:

(WebCore::Element::setActive):
(WebCore::Element::setFocus):
(WebCore::Element::setHovered):
(WebCore::Element::attributeChanged):
(WebCore::Element::invalidateStyle):
(WebCore::Element::invalidateStyleAndLayerComposition):
(WebCore::Element::invalidateStyleForSubtree):
(WebCore::Element::invalidateStyleAndRenderersForSubtree):

Move public invalidation functions to Element tightening typing.
Use separate functions instead of enum values.
This way the call sites look nicer and only useful combinations are exposed.

(WebCore::Element::addShadowRoot):
(WebCore::checkForEmptyStyleChange):
(WebCore::checkForSiblingStyleChanges):
(WebCore::Element::needsStyleInvalidation):
(WebCore::Element::setContainsFullScreenElement):

  • dom/Element.h:

(WebCore::Element::setHasFocusWithin):

  • dom/Node.cpp:

(WebCore::computeEditabilityFromComputedStyle):
(WebCore::Node::adjustStyleValidity):

Update validity and mode separately. There was a potential bug here where
SyntheticStyleChange could overwrite FullStyleChange (no known repro).

(WebCore::Node::updateAncestorsForStyleRecalc):
(WebCore::Node::invalidateStyle):
(WebCore::Node::insertedInto):
(WebCore::Node::setNeedsStyleRecalc): Deleted.

  • dom/Node.h:

(WebCore::Node::needsStyleRecalc):
(WebCore::Node::styleValidity):
(WebCore::Node::styleResolutionShouldRecompositeLayer):
(WebCore::Node::setHasValidStyle):
(WebCore::Node::styleChangeType): Deleted.
(WebCore::Node::clearNeedsStyleRecalc): Deleted.
(WebCore::Node::setStyleChange): Deleted.

  • dom/RadioButtonGroups.cpp:

(WebCore::RadioButtonGroup::remove):
(WebCore::RadioButtonGroup::setNeedsStyleRecalcForAllButtons):

  • dom/ShadowRoot.cpp:

(WebCore::ShadowRoot::setResetStyleInheritance):

  • dom/SlotAssignment.cpp:

(WebCore::SlotAssignment::addSlotElementByName):
(WebCore::SlotAssignment::removeSlotElementByName):
(WebCore::SlotAssignment::didChangeSlot):

  • dom/StyledElement.cpp:

(WebCore::StyledElement::attributeChanged):
(WebCore::StyledElement::styleAttributeChanged):
(WebCore::StyledElement::invalidateStyleAttribute):

  • dom/Text.cpp:

(WebCore::Text::updateRendererAfterContentChange):

  • dom/VisitedLinkState.cpp:

(WebCore::VisitedLinkState::invalidateStyleForAllLinks):
(WebCore::VisitedLinkState::invalidateStyleForLink):

  • editing/FrameSelection.cpp:

(WebCore::FrameSelection::focusedOrActiveStateChanged):

  • html/BaseDateAndTimeInputType.cpp:

(WebCore::BaseDateAndTimeInputType::minOrMaxAttributeChanged):

  • html/FileInputType.cpp:

(WebCore::FileInputType::setValue):

  • html/HTMLAnchorElement.cpp:

(WebCore::HTMLAnchorElement::parseAttribute):

  • html/HTMLBodyElement.cpp:

(WebCore::HTMLBodyElement::parseAttribute):

  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::getContext):
(WebCore::HTMLCanvasElement::createImageBuffer):

  • html/HTMLElement.cpp:

(WebCore::HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged):
(WebCore::HTMLElement::calculateAndAdjustDirectionality):

  • html/HTMLFieldSetElement.cpp:

(WebCore::HTMLFieldSetElement::addInvalidDescendant):
(WebCore::HTMLFieldSetElement::removeInvalidDescendant):

  • html/HTMLFormControlElement.cpp:

(WebCore::HTMLFormControlElement::disabledStateChanged):
(WebCore::HTMLFormControlElement::readOnlyAttributeChanged):
(WebCore::HTMLFormControlElement::requiredAttributeChanged):
(WebCore::HTMLFormControlElement::setNeedsWillValidateCheck):
(WebCore::HTMLFormControlElement::updateValidity):

  • html/HTMLFormElement.cpp:

(WebCore::HTMLFormElement::registerFormElement):
(WebCore::HTMLFormElement::registerInvalidAssociatedFormControl):
(WebCore::HTMLFormElement::removeInvalidAssociatedFormControlIfNeeded):
(WebCore::HTMLFormElement::resetDefaultButton):

  • html/HTMLFrameElementBase.cpp:

(WebCore::HTMLFrameElementBase::finishedInsertingSubtree):

  • html/HTMLFrameOwnerElement.cpp:

(WebCore::HTMLFrameOwnerElement::scheduleinvalidateStyleAndLayerComposition):
(WebCore::HTMLFrameOwnerElement::scheduleSetNeedsStyleRecalc): Deleted.

  • html/HTMLFrameOwnerElement.h:
  • html/HTMLFrameSetElement.cpp:

(WebCore::HTMLFrameSetElement::parseAttribute):
(WebCore::HTMLFrameSetElement::willRecalcStyle):

  • html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::runPostTypeUpdateTasks):
(WebCore::HTMLInputElement::parseAttribute):
(WebCore::HTMLInputElement::setChecked):
(WebCore::HTMLInputElement::setIndeterminate):
(WebCore::HTMLInputElement::setAutoFilled):
(WebCore::HTMLInputElement::maxLengthAttributeChanged):
(WebCore::HTMLInputElement::minLengthAttributeChanged):

  • html/HTMLLinkElement.cpp:

(WebCore::HTMLLinkElement::parseAttribute):

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::mediaPlayerRenderingModeChanged):
(WebCore::HTMLMediaElement::setVideoFullscreenLayer):

  • html/HTMLObjectElement.cpp:

(WebCore::HTMLObjectElement::parseAttribute):
(WebCore::HTMLObjectElement::childrenChanged):
(WebCore::HTMLObjectElement::renderFallbackContent):

  • html/HTMLOptGroupElement.cpp:

(WebCore::HTMLOptGroupElement::parseAttribute):

  • html/HTMLOptionElement.cpp:

(WebCore::HTMLOptionElement::parseAttribute):
(WebCore::HTMLOptionElement::setSelectedState):

  • html/HTMLPlugInElement.cpp:

(WebCore::HTMLPlugInElement::didAddUserAgentShadowRoot):

  • html/HTMLPlugInImageElement.cpp:

(WebCore::HTMLPlugInImageElement::setDisplayState):
(WebCore::HTMLPlugInImageElement::willRecalcStyle):
(WebCore::HTMLPlugInImageElement::finishParsingChildren):
(WebCore::HTMLPlugInImageElement::resumeFromDocumentSuspension):
(WebCore::HTMLPlugInImageElement::removeSnapshotTimerFired):
(WebCore::HTMLPlugInImageElement::restartSnapshottedPlugIn):

  • html/HTMLProgressElement.cpp:

(WebCore::HTMLProgressElement::didElementStateChange):

  • html/HTMLSelectElement.cpp:

(WebCore::HTMLSelectElement::parseAttribute):
(WebCore::HTMLSelectElement::setRecalcListItems):
(WebCore::HTMLSelectElement::parseMultipleAttribute):
(WebCore::HTMLSelectElement::reset):

  • html/HTMLTableElement.cpp:

(WebCore::isTableCellAncestor):
(WebCore::setTableCellsChanged):
(WebCore::HTMLTableElement::parseAttribute):

  • html/HTMLTextAreaElement.cpp:

(WebCore::HTMLTextAreaElement::setValueCommon):

  • html/HTMLTextFormControlElement.cpp:

(WebCore::HTMLTextFormControlElement::updatePlaceholderVisibility):

  • html/InputType.cpp:

(WebCore::InputType::setValue):

  • html/NumberInputType.cpp:

(WebCore::NumberInputType::minOrMaxAttributeChanged):

  • html/TextFieldInputType.cpp:

(WebCore::TextFieldInputType::subtreeHasChanged):

  • mathml/MathMLElement.cpp:

(WebCore::MathMLElement::parseAttribute):

  • mathml/MathMLSelectElement.cpp:

(WebCore::MathMLSelectElement::updateSelectedChild):

  • page/animation/AnimationBase.cpp:

(WebCore::AnimationBase::setNeedsStyleRecalc):

  • page/animation/AnimationController.cpp:

(WebCore::AnimationControllerPrivate::clear):
(WebCore::AnimationControllerPrivate::updateAnimations):
(WebCore::AnimationControllerPrivate::fireEventsAndUpdateStyle):
(WebCore::AnimationControllerPrivate::pauseAnimationAtTime):
(WebCore::AnimationControllerPrivate::pauseTransitionAtTime):
(WebCore::AnimationController::cancelAnimations):

  • rendering/RenderImage.cpp:

(WebCore::RenderImage::imageChanged):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::calculateClipRects):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::attachRootLayer):
(WebCore::RenderLayerCompositor::detachRootLayer):
(WebCore::RenderLayerCompositor::notifyIFramesOfCompositingChange):

  • rendering/RenderObject.cpp:

(WebCore::RenderObject::updateDragState):

  • rendering/svg/SVGResourcesCache.cpp:

(WebCore::SVGResourcesCache::clientStyleChanged):

  • style/AttributeChangeInvalidation.cpp:

(WebCore::Style::AttributeChangeInvalidation::invalidateStyle):

  • style/ClassChangeInvalidation.cpp:

(WebCore::Style::ClassChangeInvalidation::invalidateStyle):

  • style/IdChangeInvalidation.cpp:

(WebCore::Style::IdChangeInvalidation::invalidateStyle):

  • style/RenderTreeUpdater.cpp:

(WebCore::RenderTreeUpdater::updateElementRenderer):

  • style/StyleScope.cpp:

(WebCore::Style::Scope::updateActiveStyleSheets):

  • style/StyleTreeResolver.cpp:

(WebCore::Style::resetStyleForNonRenderedDescendants):
(WebCore::Style::TreeResolver::resolveElement):
(WebCore::Style::TreeResolver::createAnimatedElementUpdate):
(WebCore::Style::TreeResolver::popParent):
(WebCore::Style::clearNeedsStyleResolution):
(WebCore::Style::TreeResolver::resolveComposedTree):

  • style/StyleUpdate.h:
  • style/StyleValidity.h: Added.

StyleChangeType enum splits into Style::Validity and Style::InvalidationMode.
Move to a file of its own.

  • svg/SVGAElement.cpp:

(WebCore::SVGAElement::svgAttributeChanged):

  • svg/SVGAnimateElementBase.cpp:

(WebCore::applyCSSPropertyToTarget):
(WebCore::removeCSSPropertyFromTarget):

  • svg/SVGElement.cpp:

(WebCore::SVGElement::willRecalcStyle):

  • svg/SVGElement.h:

(WebCore::SVGElement::invalidateSVGPresentationAttributeStyle):

  • svg/SVGTests.cpp:

(WebCore::SVGTests::handleAttributeChange):

  • svg/SVGUseElement.cpp:

(WebCore::SVGUseElement::invalidateShadowTree):

  • testing/Internals.cpp:

(WebCore::styleValidityToToString):
(WebCore::Internals::styleChangeType):
(WebCore::styleChangeTypeToString): Deleted.

Source/WebKit/mac:

  • Plugins/Hosted/WebHostedNetscapePluginView.mm:

(-[WebHostedNetscapePluginView createPluginLayer]):

  • Plugins/WebNetscapePluginView.mm:

(-[WebNetscapePluginView createPlugin]):

Source/WebKit2:

  • WebProcess/Plugins/PluginView.cpp:

(WebKit::PluginView::didInitializePlugin):
(WebKit::PluginView::pluginProcessCrashed):

Location:
trunk/Source
Files:
1 added
72 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r207457 r207458  
     12016-10-18  Antti Koivisto  <antti@apple.com>
     2
     3        Rename setNeedsStyleRecalc to invalidateStyle
     4        https://bugs.webkit.org/show_bug.cgi?id=163542
     5
     6        Reviewed by Darin Adler.
     7
     8        Also rename StyleChangeType enum and some related functions for clarity. For example
     9
     10            element.setNeedsStyleRecalc(SyntheticStyleChange);
     11
     12        becomes
     13
     14            element.invalidateStyleAndLayerComposition();
     15
     16        * WebCore.xcodeproj/project.pbxproj:
     17        * css/StyleInvalidationAnalysis.cpp:
     18        (WebCore::StyleInvalidationAnalysis::invalidateIfNeeded):
     19        * dom/Document.cpp:
     20        (WebCore::Document::recalcStyle):
     21        (WebCore::Document::updateViewportUnitsOnResize):
     22        (WebCore::Document::setCSSTarget):
     23        (WebCore::unwrapFullScreenRenderer):
     24        (WebCore::Document::setAnimatingFullScreen):
     25        * dom/Element.cpp:
     26        (WebCore::Element::setActive):
     27        (WebCore::Element::setFocus):
     28        (WebCore::Element::setHovered):
     29        (WebCore::Element::attributeChanged):
     30        (WebCore::Element::invalidateStyle):
     31        (WebCore::Element::invalidateStyleAndLayerComposition):
     32        (WebCore::Element::invalidateStyleForSubtree):
     33        (WebCore::Element::invalidateStyleAndRenderersForSubtree):
     34
     35            Move public invalidation functions to Element tightening typing.
     36            Use separate functions instead of enum values.
     37            This way the call sites look nicer and only useful combinations are exposed.
     38
     39        (WebCore::Element::addShadowRoot):
     40        (WebCore::checkForEmptyStyleChange):
     41        (WebCore::checkForSiblingStyleChanges):
     42        (WebCore::Element::needsStyleInvalidation):
     43        (WebCore::Element::setContainsFullScreenElement):
     44        * dom/Element.h:
     45        (WebCore::Element::setHasFocusWithin):
     46        * dom/Node.cpp:
     47        (WebCore::computeEditabilityFromComputedStyle):
     48        (WebCore::Node::adjustStyleValidity):
     49
     50            Update validity and mode separately. There was a potential bug here where
     51            SyntheticStyleChange could overwrite FullStyleChange (no known repro).
     52
     53        (WebCore::Node::updateAncestorsForStyleRecalc):
     54        (WebCore::Node::invalidateStyle):
     55        (WebCore::Node::insertedInto):
     56        (WebCore::Node::setNeedsStyleRecalc): Deleted.
     57        * dom/Node.h:
     58        (WebCore::Node::needsStyleRecalc):
     59        (WebCore::Node::styleValidity):
     60        (WebCore::Node::styleResolutionShouldRecompositeLayer):
     61        (WebCore::Node::setHasValidStyle):
     62        (WebCore::Node::styleChangeType): Deleted.
     63        (WebCore::Node::clearNeedsStyleRecalc): Deleted.
     64        (WebCore::Node::setStyleChange): Deleted.
     65        * dom/RadioButtonGroups.cpp:
     66        (WebCore::RadioButtonGroup::remove):
     67        (WebCore::RadioButtonGroup::setNeedsStyleRecalcForAllButtons):
     68        * dom/ShadowRoot.cpp:
     69        (WebCore::ShadowRoot::setResetStyleInheritance):
     70        * dom/SlotAssignment.cpp:
     71        (WebCore::SlotAssignment::addSlotElementByName):
     72        (WebCore::SlotAssignment::removeSlotElementByName):
     73        (WebCore::SlotAssignment::didChangeSlot):
     74        * dom/StyledElement.cpp:
     75        (WebCore::StyledElement::attributeChanged):
     76        (WebCore::StyledElement::styleAttributeChanged):
     77        (WebCore::StyledElement::invalidateStyleAttribute):
     78        * dom/Text.cpp:
     79        (WebCore::Text::updateRendererAfterContentChange):
     80        * dom/VisitedLinkState.cpp:
     81        (WebCore::VisitedLinkState::invalidateStyleForAllLinks):
     82        (WebCore::VisitedLinkState::invalidateStyleForLink):
     83        * editing/FrameSelection.cpp:
     84        (WebCore::FrameSelection::focusedOrActiveStateChanged):
     85        * html/BaseDateAndTimeInputType.cpp:
     86        (WebCore::BaseDateAndTimeInputType::minOrMaxAttributeChanged):
     87        * html/FileInputType.cpp:
     88        (WebCore::FileInputType::setValue):
     89        * html/HTMLAnchorElement.cpp:
     90        (WebCore::HTMLAnchorElement::parseAttribute):
     91        * html/HTMLBodyElement.cpp:
     92        (WebCore::HTMLBodyElement::parseAttribute):
     93        * html/HTMLCanvasElement.cpp:
     94        (WebCore::HTMLCanvasElement::getContext):
     95        (WebCore::HTMLCanvasElement::createImageBuffer):
     96        * html/HTMLElement.cpp:
     97        (WebCore::HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged):
     98        (WebCore::HTMLElement::calculateAndAdjustDirectionality):
     99        * html/HTMLFieldSetElement.cpp:
     100        (WebCore::HTMLFieldSetElement::addInvalidDescendant):
     101        (WebCore::HTMLFieldSetElement::removeInvalidDescendant):
     102        * html/HTMLFormControlElement.cpp:
     103        (WebCore::HTMLFormControlElement::disabledStateChanged):
     104        (WebCore::HTMLFormControlElement::readOnlyAttributeChanged):
     105        (WebCore::HTMLFormControlElement::requiredAttributeChanged):
     106        (WebCore::HTMLFormControlElement::setNeedsWillValidateCheck):
     107        (WebCore::HTMLFormControlElement::updateValidity):
     108        * html/HTMLFormElement.cpp:
     109        (WebCore::HTMLFormElement::registerFormElement):
     110        (WebCore::HTMLFormElement::registerInvalidAssociatedFormControl):
     111        (WebCore::HTMLFormElement::removeInvalidAssociatedFormControlIfNeeded):
     112        (WebCore::HTMLFormElement::resetDefaultButton):
     113        * html/HTMLFrameElementBase.cpp:
     114        (WebCore::HTMLFrameElementBase::finishedInsertingSubtree):
     115        * html/HTMLFrameOwnerElement.cpp:
     116        (WebCore::HTMLFrameOwnerElement::scheduleinvalidateStyleAndLayerComposition):
     117        (WebCore::HTMLFrameOwnerElement::scheduleSetNeedsStyleRecalc): Deleted.
     118        * html/HTMLFrameOwnerElement.h:
     119        * html/HTMLFrameSetElement.cpp:
     120        (WebCore::HTMLFrameSetElement::parseAttribute):
     121        (WebCore::HTMLFrameSetElement::willRecalcStyle):
     122        * html/HTMLInputElement.cpp:
     123        (WebCore::HTMLInputElement::runPostTypeUpdateTasks):
     124        (WebCore::HTMLInputElement::parseAttribute):
     125        (WebCore::HTMLInputElement::setChecked):
     126        (WebCore::HTMLInputElement::setIndeterminate):
     127        (WebCore::HTMLInputElement::setAutoFilled):
     128        (WebCore::HTMLInputElement::maxLengthAttributeChanged):
     129        (WebCore::HTMLInputElement::minLengthAttributeChanged):
     130        * html/HTMLLinkElement.cpp:
     131        (WebCore::HTMLLinkElement::parseAttribute):
     132        * html/HTMLMediaElement.cpp:
     133        (WebCore::HTMLMediaElement::mediaPlayerRenderingModeChanged):
     134        (WebCore::HTMLMediaElement::setVideoFullscreenLayer):
     135        * html/HTMLObjectElement.cpp:
     136        (WebCore::HTMLObjectElement::parseAttribute):
     137        (WebCore::HTMLObjectElement::childrenChanged):
     138        (WebCore::HTMLObjectElement::renderFallbackContent):
     139        * html/HTMLOptGroupElement.cpp:
     140        (WebCore::HTMLOptGroupElement::parseAttribute):
     141        * html/HTMLOptionElement.cpp:
     142        (WebCore::HTMLOptionElement::parseAttribute):
     143        (WebCore::HTMLOptionElement::setSelectedState):
     144        * html/HTMLPlugInElement.cpp:
     145        (WebCore::HTMLPlugInElement::didAddUserAgentShadowRoot):
     146        * html/HTMLPlugInImageElement.cpp:
     147        (WebCore::HTMLPlugInImageElement::setDisplayState):
     148        (WebCore::HTMLPlugInImageElement::willRecalcStyle):
     149        (WebCore::HTMLPlugInImageElement::finishParsingChildren):
     150        (WebCore::HTMLPlugInImageElement::resumeFromDocumentSuspension):
     151        (WebCore::HTMLPlugInImageElement::removeSnapshotTimerFired):
     152        (WebCore::HTMLPlugInImageElement::restartSnapshottedPlugIn):
     153        * html/HTMLProgressElement.cpp:
     154        (WebCore::HTMLProgressElement::didElementStateChange):
     155        * html/HTMLSelectElement.cpp:
     156        (WebCore::HTMLSelectElement::parseAttribute):
     157        (WebCore::HTMLSelectElement::setRecalcListItems):
     158        (WebCore::HTMLSelectElement::parseMultipleAttribute):
     159        (WebCore::HTMLSelectElement::reset):
     160        * html/HTMLTableElement.cpp:
     161        (WebCore::isTableCellAncestor):
     162        (WebCore::setTableCellsChanged):
     163        (WebCore::HTMLTableElement::parseAttribute):
     164        * html/HTMLTextAreaElement.cpp:
     165        (WebCore::HTMLTextAreaElement::setValueCommon):
     166        * html/HTMLTextFormControlElement.cpp:
     167        (WebCore::HTMLTextFormControlElement::updatePlaceholderVisibility):
     168        * html/InputType.cpp:
     169        (WebCore::InputType::setValue):
     170        * html/NumberInputType.cpp:
     171        (WebCore::NumberInputType::minOrMaxAttributeChanged):
     172        * html/TextFieldInputType.cpp:
     173        (WebCore::TextFieldInputType::subtreeHasChanged):
     174        * mathml/MathMLElement.cpp:
     175        (WebCore::MathMLElement::parseAttribute):
     176        * mathml/MathMLSelectElement.cpp:
     177        (WebCore::MathMLSelectElement::updateSelectedChild):
     178        * page/animation/AnimationBase.cpp:
     179        (WebCore::AnimationBase::setNeedsStyleRecalc):
     180        * page/animation/AnimationController.cpp:
     181        (WebCore::AnimationControllerPrivate::clear):
     182        (WebCore::AnimationControllerPrivate::updateAnimations):
     183        (WebCore::AnimationControllerPrivate::fireEventsAndUpdateStyle):
     184        (WebCore::AnimationControllerPrivate::pauseAnimationAtTime):
     185        (WebCore::AnimationControllerPrivate::pauseTransitionAtTime):
     186        (WebCore::AnimationController::cancelAnimations):
     187        * rendering/RenderImage.cpp:
     188        (WebCore::RenderImage::imageChanged):
     189        * rendering/RenderLayer.cpp:
     190        (WebCore::RenderLayer::calculateClipRects):
     191        * rendering/RenderLayerCompositor.cpp:
     192        (WebCore::RenderLayerCompositor::attachRootLayer):
     193        (WebCore::RenderLayerCompositor::detachRootLayer):
     194        (WebCore::RenderLayerCompositor::notifyIFramesOfCompositingChange):
     195        * rendering/RenderObject.cpp:
     196        (WebCore::RenderObject::updateDragState):
     197        * rendering/svg/SVGResourcesCache.cpp:
     198        (WebCore::SVGResourcesCache::clientStyleChanged):
     199        * style/AttributeChangeInvalidation.cpp:
     200        (WebCore::Style::AttributeChangeInvalidation::invalidateStyle):
     201        * style/ClassChangeInvalidation.cpp:
     202        (WebCore::Style::ClassChangeInvalidation::invalidateStyle):
     203        * style/IdChangeInvalidation.cpp:
     204        (WebCore::Style::IdChangeInvalidation::invalidateStyle):
     205        * style/RenderTreeUpdater.cpp:
     206        (WebCore::RenderTreeUpdater::updateElementRenderer):
     207        * style/StyleScope.cpp:
     208        (WebCore::Style::Scope::updateActiveStyleSheets):
     209        * style/StyleTreeResolver.cpp:
     210        (WebCore::Style::resetStyleForNonRenderedDescendants):
     211        (WebCore::Style::TreeResolver::resolveElement):
     212        (WebCore::Style::TreeResolver::createAnimatedElementUpdate):
     213        (WebCore::Style::TreeResolver::popParent):
     214        (WebCore::Style::clearNeedsStyleResolution):
     215        (WebCore::Style::TreeResolver::resolveComposedTree):
     216        * style/StyleUpdate.h:
     217        * style/StyleValidity.h: Added.
     218
     219            StyleChangeType enum splits into Style::Validity and Style::InvalidationMode.
     220            Move to a file of its own.
     221
     222        * svg/SVGAElement.cpp:
     223        (WebCore::SVGAElement::svgAttributeChanged):
     224        * svg/SVGAnimateElementBase.cpp:
     225        (WebCore::applyCSSPropertyToTarget):
     226        (WebCore::removeCSSPropertyFromTarget):
     227        * svg/SVGElement.cpp:
     228        (WebCore::SVGElement::willRecalcStyle):
     229        * svg/SVGElement.h:
     230        (WebCore::SVGElement::invalidateSVGPresentationAttributeStyle):
     231        * svg/SVGTests.cpp:
     232        (WebCore::SVGTests::handleAttributeChange):
     233        * svg/SVGUseElement.cpp:
     234        (WebCore::SVGUseElement::invalidateShadowTree):
     235        * testing/Internals.cpp:
     236        (WebCore::styleValidityToToString):
     237        (WebCore::Internals::styleChangeType):
     238        (WebCore::styleChangeTypeToString): Deleted.
     239
    12402016-10-17  Sergio Villar Senin  <svillar@igalia.com>
    2241

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

    r207438 r207458  
    62536253                E47E276516036ED200EE2AFB /* ExtensionStyleSheets.h in Headers */ = {isa = PBXBuildFile; fileRef = E47E276416036ED200EE2AFB /* ExtensionStyleSheets.h */; settings = {ATTRIBUTES = (Private, ); }; };
    62546254                E47E276816036EDC00EE2AFB /* ExtensionStyleSheets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E47E276716036EDC00EE2AFB /* ExtensionStyleSheets.cpp */; };
     6255                E48137B91DB3B526005C59BF /* StyleValidity.h in Headers */ = {isa = PBXBuildFile; fileRef = E48137B81DB3B526005C59BF /* StyleValidity.h */; settings = {ATTRIBUTES = (Private, ); }; };
    62556256                E48944A2180B57D800F165D8 /* SimpleLineLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E48944A0180B57D800F165D8 /* SimpleLineLayout.cpp */; };
    62566257                E48944A3180B57D800F165D8 /* SimpleLineLayout.h in Headers */ = {isa = PBXBuildFile; fileRef = E48944A1180B57D800F165D8 /* SimpleLineLayout.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    1401614017                E47E276416036ED200EE2AFB /* ExtensionStyleSheets.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ExtensionStyleSheets.h; sourceTree = "<group>"; };
    1401714018                E47E276716036EDC00EE2AFB /* ExtensionStyleSheets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExtensionStyleSheets.cpp; sourceTree = "<group>"; };
     14019                E48137B81DB3B526005C59BF /* StyleValidity.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleValidity.h; sourceTree = "<group>"; };
    1401814020                E48944A0180B57D800F165D8 /* SimpleLineLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleLineLayout.cpp; sourceTree = "<group>"; };
    1401914021                E48944A1180B57D800F165D8 /* SimpleLineLayout.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SimpleLineLayout.h; sourceTree = "<group>"; };
    … …  
    2269722699                                E42E76D91C7AF76C00E3614D /* StyleUpdate.cpp */,
    2269822700                                E42E76DB1C7AF77600E3614D /* StyleUpdate.h */,
     22701                                E48137B81DB3B526005C59BF /* StyleValidity.h */,
    2269922702                        );
    2270022703                        path = style;
    … …  
    2556625569                                A80E7B150A19D606007FB8C5 /* JSHTMLHeadElement.h in Headers */,
    2556725570                                1AE2AA2F0A1CDAB400B42B25 /* JSHTMLHeadingElement.h in Headers */,
     25571                                E48137B91DB3B526005C59BF /* StyleValidity.h in Headers */,
     25572                                1A299FE81D7F5FA600A60093 /* RenderThemeCocoa.h in Headers */,
    2556825573                                1AE2AA310A1CDAB400B42B25 /* JSHTMLHRElement.h in Headers */,
    2556925574                                1A85B1900A1B18A200D8C87C /* JSHTMLHtmlElement.h in Headers */,

  • trunk/Source/WebCore/css/StyleInvalidationAnalysis.cpp

    r206990 r207458  
    101101        // FIXME: This could do actual rule matching too.
    102102        if (element.shadowRoot())
    103             element.setNeedsStyleRecalc();
     103            element.invalidateStyleForSubtree();
    104104    }
    105105
    106     switch (element.styleChangeType()) {
    107     case NoStyleChange: {
     106    switch (element.styleValidity()) {
     107    case Style::Validity::Valid: {
    108108        ElementRuleCollector ruleCollector(element, m_ruleSet, filter);
    109109        ruleCollector.setMode(SelectorChecker::Mode::CollectingRulesIgnoringVirtualPseudoElements);
    … …  
    111111
    112112        if (ruleCollector.hasMatchedRules())
    113             element.setNeedsStyleRecalc(InlineStyleChange);
     113            element.invalidateStyle();
    114114        return CheckDescendants::Yes;
    115115    }
    116     case InlineStyleChange:
     116    case Style::Validity::ElementInvalid:
    117117        return CheckDescendants::Yes;
    118     case FullStyleChange:
    119     case SyntheticStyleChange:
    120     case ReconstructRenderTree:
     118    case Style::Validity::SubtreeInvalid:
     119    case Style::Validity::SubtreeAndRenderersInvalid:
    121120        return CheckDescendants::No;
    122121    }

  • trunk/Source/WebCore/dom/Document.cpp

    r207442 r207458  
    18541854        m_lastStyleUpdateSizeForTesting = styleUpdate ? styleUpdate->size() : 0;
    18551855
    1856         clearNeedsStyleRecalc();
     1856        setHasValidStyle();
    18571857        clearChildNeedsStyleRecalc();
    18581858        unscheduleStyleRecalc();
    … …  
    35013501        auto* renderer = element->renderer();
    35023502        if (renderer && renderer->style().hasViewportUnits())
    3503             element->setNeedsStyleRecalc(InlineStyleChange);
     3503            element->invalidateStyle();
    35043504    }
    35053505}
    … …  
    38193819{
    38203820    if (m_cssTarget)
    3821         m_cssTarget->setNeedsStyleRecalc();
     3821        m_cssTarget->invalidateStyleForSubtree();
    38223822    m_cssTarget = n;
    38233823    if (n)
    3824         n->setNeedsStyleRecalc();
     3824        n->invalidateStyleForSubtree();
    38253825}
    38263826
    … …  
    58365836    fullScreenRenderer->unwrapRenderer(requiresRenderTreeRebuild);
    58375837
    5838     if (requiresRenderTreeRebuild && fullScreenElement && fullScreenElement->parentNode())
    5839         fullScreenElement->parentNode()->setNeedsStyleRecalc(ReconstructRenderTree);
     5838    if (requiresRenderTreeRebuild && fullScreenElement && fullScreenElement->parentElement())
     5839        fullScreenElement->parentElement()->invalidateStyleAndRenderersForSubtree();
    58405840}
    58415841
    … …  
    60286028
    60296029    if (m_fullScreenElement && m_fullScreenElement->isDescendantOf(this)) {
    6030         m_fullScreenElement->setNeedsStyleRecalc();
     6030        m_fullScreenElement->invalidateStyleForSubtree();
    60316031        scheduleForcedStyleRecalc();
    60326032    }

  • trunk/Source/WebCore/dom/Element.cpp

    r206951 r207458  
    568568    bool reactsToPress = (renderStyle && renderStyle->affectedByActive()) || styleAffectedByActive();
    569569    if (reactsToPress)
    570         setNeedsStyleRecalc();
     570        invalidateStyleForSubtree();
    571571
    572572    if (!renderer())
    … …  
    613613
    614614    document().userActionElements().setFocused(this, flag);
    615     setNeedsStyleRecalc();
     615    invalidateStyleForSubtree();
    616616
    617617    for (Element* element = this; element; element = element->parentOrShadowHostElement())
    … …  
    633633        // stuck in its hovered style).
    634634        if (!flag)
    635             setNeedsStyleRecalc();
     635            invalidateStyleForSubtree();
    636636
    637637        return;
    … …  
    639639
    640640    if (renderer()->style().affectedByHover() || childrenAffectedByHover())
    641         setNeedsStyleRecalc();
     641        invalidateStyleForSubtree();
    642642
    643643    if (renderer()->style().hasAppearance())
    … …  
    13231323        else if (name == HTMLNames::pseudoAttr) {
    13241324            if (needsStyleInvalidation() && isInShadowTree())
    1325                 setNeedsStyleRecalc(FullStyleChange);
     1325                invalidateStyleForSubtree();
    13261326        }
    13271327        else if (name == HTMLNames::slotAttr) {
    … …  
    14391439{
    14401440    return styleResolver().styleForElement(*this, parentStyle);
     1441}
     1442
     1443void Element::invalidateStyle()
     1444{
     1445    Node::invalidateStyle(Style::Validity::ElementInvalid);
     1446}
     1447
     1448void Element::invalidateStyleAndLayerComposition()
     1449{
     1450    Node::invalidateStyle(Style::Validity::ElementInvalid, Style::InvalidationMode::RecompositeLayer);
     1451}
     1452
     1453void Element::invalidateStyleForSubtree()
     1454{
     1455    Node::invalidateStyle(Style::Validity::SubtreeInvalid);
     1456}
     1457
     1458void Element::invalidateStyleAndRenderersForSubtree()
     1459{
     1460    Node::invalidateStyle(Style::Validity::SubtreeAndRenderersInvalid);
    14411461}
    14421462
    … …  
    17551775        target->finishedInsertingSubtree();
    17561776
    1757     setNeedsStyleRecalc(ReconstructRenderTree);
     1777    invalidateStyleAndRenderersForSubtree();
    17581778
    17591779    InspectorInstrumentation::didPushShadowRoot(*this, shadowRoot);
    … …  
    19371957        auto* style = element.renderStyle();
    19381958        if (!style || (!style->emptyState() || element.hasChildNodes()))
    1939             element.setNeedsStyleRecalc();
     1959            element.invalidateStyleForSubtree();
    19401960    }
    19411961}
    … …  
    19481968    checkForEmptyStyleChange(parent);
    19491969
    1950     if (parent.styleChangeType() >= FullStyleChange)
     1970    if (parent.styleValidity() >= Style::Validity::SubtreeInvalid)
    19511971        return;
    19521972
    … …  
    19631983            auto* style = elementAfterChange->renderStyle();
    19641984            if (!style || style->firstChildState())
    1965                 elementAfterChange->setNeedsStyleRecalc();
     1985                elementAfterChange->invalidateStyleForSubtree();
    19661986        }
    19671987
    … …  
    19701990            auto* style = newFirstElement->renderStyle();
    19711991            if (!style || !style->firstChildState())
    1972                 newFirstElement->setNeedsStyleRecalc();
     1992                newFirstElement->invalidateStyleForSubtree();
    19731993        }
    19741994    }
    … …  
    19832003            auto* style = elementBeforeChange->renderStyle();
    19842004            if (!style || style->lastChildState())
    1985                 elementBeforeChange->setNeedsStyleRecalc();
     2005                elementBeforeChange->invalidateStyleForSubtree();
    19862006        }
    19872007
    … …  
    19912011            auto* style = newLastElement->renderStyle();
    19922012            if (!style || !style->lastChildState())
    1993                 newLastElement->setNeedsStyleRecalc();
     2013                newLastElement->invalidateStyleForSubtree();
    19942014        }
    19952015    }
    … …  
    19972017    if (elementAfterChange) {
    19982018        if (elementAfterChange->styleIsAffectedByPreviousSibling())
    1999             elementAfterChange->setNeedsStyleRecalc();
     2019            elementAfterChange->invalidateStyleForSubtree();
    20002020        else if (elementAfterChange->affectsNextSiblingElementStyle()) {
    20012021            Element* elementToInvalidate = elementAfterChange;
    … …  
    20052025
    20062026            if (elementToInvalidate)
    2007                 elementToInvalidate->setNeedsStyleRecalc();
     2027                elementToInvalidate->invalidateStyleForSubtree();
    20082028        }
    20092029    }
    … …  
    20162036    // here.  recalcStyle will then force a walk of the children when it sees that this has happened.
    20172037    if (parent.childrenAffectedByBackwardPositionalRules() && elementBeforeChange)
    2018         parent.setNeedsStyleRecalc();
     2038        parent.invalidateStyleForSubtree();
    20192039}
    20202040
    … …  
    27052725    if (!inRenderedDocument())
    27062726        return false;
    2707     if (styleChangeType() >= FullStyleChange)
     2727    if (styleValidity() >= Style::Validity::SubtreeInvalid)
    27082728        return false;
    27092729    if (document().hasPendingForcedStyleRecalc())
    … …  
    30723092{
    30733093    ensureElementRareData().setContainsFullScreenElement(flag);
    3074     setNeedsStyleRecalc(SyntheticStyleChange);
     3094    invalidateStyleAndLayerComposition();
    30753095}
    30763096

  • trunk/Source/WebCore/dom/Element.h

    r206877 r207458  
    544544    ElementStyle resolveStyle(const RenderStyle* parentStyle);
    545545
     546    // Invalidates the style of a single element. Style is resolved lazily.
     547    // Descendant elements are resolved as needed, for example if an inherited property changes.
     548    // This should be called whenever an element changes in a manner that can affect its style.
     549    void invalidateStyle();
     550
     551    // As above but also call RenderElement::setStyle with StyleDifferenceRecompositeLayer flag for
     552    // the element even when the style doesn't change. This is mostly needed by the animation code.
     553    WEBCORE_EXPORT void invalidateStyleAndLayerComposition();
     554
     555    // Invalidate the element and all its descendants. This is used when there is some sort of change
     556    // in the tree that may affect the style of any of the descendants and we don't know how to optimize
     557    // the case to limit the scope. This is expensive and should be avoided.
     558    void invalidateStyleForSubtree();
     559
     560    // Invalidates renderers for the element and all its descendants causing them to be torn down
     561    // and rebuild during style resolution. Style is also recomputed. This is used in code dealing with
     562    // custom (not style based) renderers. This is expensive and should be avoided.
     563    // Elements newly added to the tree are also in this state.
     564    void invalidateStyleAndRenderersForSubtree();
     565
    546566    bool hasDisplayContents() const;
    547567    void setHasDisplayContents(bool);
    … …  
    809829    setFlag(flag, HasFocusWithin);
    810830    if (styleAffectedByFocusWithin())
    811         setNeedsStyleRecalc();
     831        invalidateStyleForSubtree();
    812832}
    813833

  • trunk/Source/WebCore/dom/Node.cpp

    r207381 r207458  
    667667{
    668668    // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but
    669     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
     669    // ContainerNode::setFocus() calls invalidateStyleForSubtree(), so the assertion
    670670    // would fire in the middle of Document::setFocusedElement().
    671671
    … …  
    751751}
    752752
     753void Node::adjustStyleValidity(Style::Validity validity, Style::InvalidationMode mode)
     754{
     755    if (validity > styleValidity()) {
     756        m_nodeFlags &= ~StyleValidityMask;
     757        m_nodeFlags |= static_cast<unsigned>(validity) << StyleValidityShift;
     758    }
     759    if (mode == Style::InvalidationMode::RecompositeLayer)
     760        setFlag(StyleResolutionShouldRecompositeLayerFlag);
     761}
     762
    753763inline void Node::updateAncestorsForStyleRecalc()
    754764{
    … …  
    759769        it->setDirectChildNeedsStyleRecalc();
    760770
    761         if (it->childrenAffectedByPropertyBasedBackwardPositionalRules()) {
    762             if (it->styleChangeType() < FullStyleChange)
    763                 it->setStyleChange(FullStyleChange);
    764         }
     771        if (it->childrenAffectedByPropertyBasedBackwardPositionalRules())
     772            it->adjustStyleValidity(Style::Validity::SubtreeInvalid, Style::InvalidationMode::Normal);
    765773
    766774        for (; it != end; ++it) {
    … …  
    783791}
    784792
    785 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
    786 {
    787     ASSERT(changeType != NoStyleChange);
     793void Node::invalidateStyle(Style::Validity validity, Style::InvalidationMode mode)
     794{
     795    ASSERT(validity != Style::Validity::Valid);
    788796    if (!inRenderedDocument())
    789797        return;
    … …  
    793801        return;
    794802
    795     StyleChangeType existingChangeType = styleChangeType();
    796     if (changeType > existingChangeType)
    797         setStyleChange(changeType);
    798 
    799     if (existingChangeType == NoStyleChange || changeType == ReconstructRenderTree)
     803    // FIXME: Why the second condition?
     804    bool markAncestors = styleValidity() == Style::Validity::Valid || validity == Style::Validity::SubtreeAndRenderersInvalid;
     805
     806    adjustStyleValidity(validity, mode);
     807
     808    if (markAncestors)
    800809        updateAncestorsForStyleRecalc();
    801810}
    … …  
    11971206        setFlag(IsInShadowTreeFlag);
    11981207
    1199     setNeedsStyleRecalc(ReconstructRenderTree);
     1208    invalidateStyle(Style::Validity::SubtreeAndRenderersInvalid);
    12001209
    12011210    return InsertionDone;

  • trunk/Source/WebCore/dom/Node.h

    r207381 r207458  
    3030#include "MutationObserver.h"
    3131#include "RenderStyleConstants.h"
     32#include "StyleValidity.h"
    3233#include "TreeScope.h"
    3334#include <wtf/Forward.h>
    … …  
    6263class UIRequestEvent;
    6364
    64 const int nodeStyleChangeShift = 14;
    65 
    6665using NodeOrString = std::experimental::variant<RefPtr<Node>, String>;
    67 
    68 // SyntheticStyleChange means that we need to go through the entire style change logic even though
    69 // no style property has actually changed. It is used to restructure the tree when, for instance,
    70 // RenderLayers are created or destroyed due to animation changes.
    71 enum StyleChangeType {
    72     NoStyleChange = 0,
    73     InlineStyleChange = 1 << nodeStyleChangeShift,
    74     FullStyleChange = 2 << nodeStyleChangeShift,
    75     SyntheticStyleChange = 3 << nodeStyleChangeShift,
    76     ReconstructRenderTree = 4 << nodeStyleChangeShift,
    77 };
    7866
    7967class NodeRareDataBase {
    … …  
    322310
    323311    bool inRenderedDocument() const;
    324     bool needsStyleRecalc() const { return styleChangeType() != NoStyleChange; }
    325     StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_nodeFlags & StyleChangeMask); }
     312    bool needsStyleRecalc() const { return styleValidity() != Style::Validity::Valid; }
     313    Style::Validity styleValidity() const;
     314    bool styleResolutionShouldRecompositeLayer() const;
    326315    bool childNeedsStyleRecalc() const { return getFlag(ChildNeedsStyleRecalcFlag); }
    327316    bool styleIsAffectedByPreviousSibling() const { return getFlag(StyleIsAffectedByPreviousSibling); }
    … …  
    331320    void clearChildNeedsStyleRecalc() { m_nodeFlags &= ~(ChildNeedsStyleRecalcFlag | DirectChildNeedsStyleRecalcFlag); }
    332321
    333     WEBCORE_EXPORT void setNeedsStyleRecalc(StyleChangeType = FullStyleChange);
    334     void clearNeedsStyleRecalc() { m_nodeFlags &= ~StyleChangeMask; }
     322    void setHasValidStyle();
    335323
    336324    bool isLink() const { return getFlag(IsLinkFlag); }
    … …  
    598586        // be stored in the same memory word as the Node bits above.
    599587        IsParsingChildrenFinishedFlag = 1 << 13, // Element
    600 
    601         StyleChangeMask = 1 << nodeStyleChangeShift | 1 << (nodeStyleChangeShift + 1) | 1 << (nodeStyleChangeShift + 2),
     588        StyleValidityShift = 14,
     589        StyleValidityMask = 3 << StyleValidityShift,
     590        StyleResolutionShouldRecompositeLayerFlag = 1 << 16,
    602591        IsEditingTextOrUndefinedCustomElementFlag = 1 << 17,
    603592        HasFocusWithin = 1 << 18,
    … …  
    660649    void setTreeScope(TreeScope& scope) { m_treeScope = &scope; }
    661650
    662     void setStyleChange(StyleChangeType changeType) { m_nodeFlags = (m_nodeFlags & ~StyleChangeMask) | changeType; }
     651    void invalidateStyle(Style::Validity, Style::InvalidationMode = Style::InvalidationMode::Normal);
    663652    void updateAncestorsForStyleRecalc();
    664653
    … …  
    682671    Vector<std::unique_ptr<MutationObserverRegistration>>* mutationObserverRegistry();
    683672    HashSet<MutationObserverRegistration*>* transientMutationObserverRegistry();
     673
     674    void adjustStyleValidity(Style::Validity, Style::InvalidationMode);
    684675
    685676    int m_refCount;
    … …  
    774765}
    775766
     767inline Style::Validity Node::styleValidity() const
     768{
     769    return static_cast<Style::Validity>((m_nodeFlags & StyleValidityMask) >> StyleValidityShift);
     770}
     771
     772inline bool Node::styleResolutionShouldRecompositeLayer() const
     773{
     774    return getFlag(StyleResolutionShouldRecompositeLayerFlag);
     775}
     776
     777inline void Node::setHasValidStyle()
     778{
     779    m_nodeFlags &= ~StyleValidityMask;
     780    clearFlag(StyleResolutionShouldRecompositeLayerFlag);
     781}
     782
    776783} // namespace WebCore
    777784

  • trunk/Source/WebCore/dom/RadioButtonGroups.cpp

    r204203 r207458  
    154154    }
    155155    if (m_checkedButton) {
    156         button->setNeedsStyleRecalc();
     156        button->invalidateStyleForSubtree();
    157157        if (m_checkedButton == button) {
    158158            m_checkedButton = nullptr;
    … …  
    177177    for (auto& button : m_members) {
    178178        ASSERT(button->isRadioButton());
    179         button->setNeedsStyleRecalc();
     179        button->invalidateStyleForSubtree();
    180180    }
    181181}

  • trunk/Source/WebCore/dom/ShadowRoot.cpp

    r206951 r207458  
    119119void ShadowRoot::setResetStyleInheritance(bool value)
    120120{
    121     if (isOrphan())
    122         return;
    123 
    124     if (value != m_resetStyleInheritance) {
    125         m_resetStyleInheritance = value;
    126         if (host())
    127             setNeedsStyleRecalc();
    128     }
     121    // If this was ever changed after initialization, child styles would need to be invalidated here.
     122    m_resetStyleInheritance = value;
    129123}
    130124

  • trunk/Source/WebCore/dom/SlotAssignment.cpp

    r204543 r207458  
    7878
    7979    // FIXME: We should be able to do a targeted reconstruction.
    80     shadowRoot.host()->setNeedsStyleRecalc(ReconstructRenderTree);
     80    shadowRoot.host()->invalidateStyleAndRenderersForSubtree();
    8181
    8282    const AtomicString& slotName = slotNameFromAttributeValue(name);
    … …  
    110110
    111111    if (auto* host = shadowRoot.host()) // FIXME: We should be able to do a targeted reconstruction.
    112         host->setNeedsStyleRecalc(ReconstructRenderTree);
     112        host->invalidateStyleAndRenderersForSubtree();
    113113
    114114    auto it = m_slots.find(slotNameFromAttributeValue(name));
    … …  
    155155
    156156    if (changeType == ChangeType::DirectChild) {
    157         shadowRoot.host()->setNeedsStyleRecalc(ReconstructRenderTree);
     157        shadowRoot.host()->invalidateStyleAndRenderersForSubtree();
    158158        m_slotAssignmentsIsValid = false;
    159159    }

  • trunk/Source/WebCore/dom/StyledElement.cpp

    r206753 r207458  
    160160    else if (isPresentationAttribute(name)) {
    161161        elementData()->setPresentationAttributeStyleIsDirty(true);
    162         setNeedsStyleRecalc(InlineStyleChange);
     162        invalidateStyle();
    163163    }
    164164
    … …  
    217217    elementData()->setStyleAttributeIsDirty(false);
    218218
    219     setNeedsStyleRecalc(InlineStyleChange);
     219    invalidateStyle();
    220220    InspectorInstrumentation::didInvalidateStyleAttr(document(), *this);
    221221}
    … …  
    227227
    228228    elementData()->setStyleAttributeIsDirty(true);
    229     setNeedsStyleRecalc(InlineStyleChange);
     229    invalidateStyle();
    230230}
    231231

  • trunk/Source/WebCore/dom/Text.cpp

    r204311 r207458  
    222222{
    223223    ASSERT(parentNode());
    224     if (styleChangeType() == ReconstructRenderTree)
     224    if (styleValidity() >= Style::Validity::SubtreeAndRenderersInvalid)
    225225        return;
    226226
    … …  
    234234        renderer->setTextWithOffset(data(), offsetOfReplacedData, lengthOfReplacedData);
    235235}
    236 
    237236
    238237#if ENABLE(TREE_DEBUGGING)

  • trunk/Source/WebCore/dom/VisitedLinkState.cpp

    r203324 r207458  
    6464    for (auto& element : descendantsOfType<Element>(m_document)) {
    6565        if (element.isLink())
    66             element.setNeedsStyleRecalc();
     66            element.invalidateStyleForSubtree();
    6767    }
    6868}
    … …  
    8383    for (auto& element : descendantsOfType<Element>(m_document)) {
    8484        if (linkHashForElement(m_document, element) == linkHash)
    85             element.setNeedsStyleRecalc();
     85            element.invalidateStyleForSubtree();
    8686    }
    8787}

  • trunk/Source/WebCore/editing/FrameSelection.cpp

    r206538 r207458  
    19841984    // update style and theme state that depended on those.
    19851985    if (Element* element = document->focusedElement()) {
    1986         element->setNeedsStyleRecalc();
     1986        element->invalidateStyleForSubtree();
    19871987        if (RenderObject* renderer = element->renderer())
    19881988            if (renderer && renderer->style().hasAppearance())

  • trunk/Source/WebCore/html/BaseDateAndTimeInputType.cpp

    r205249 r207458  
    9696void BaseDateAndTimeInputType::minOrMaxAttributeChanged()
    9797{
    98     element().setNeedsStyleRecalc();
     98    element().invalidateStyleForSubtree();
    9999}
    100100

  • trunk/Source/WebCore/html/FileInputType.cpp

    r205912 r207458  
    242242    m_fileList->clear();
    243243    m_icon = nullptr;
    244     element().setNeedsStyleRecalc();
     244    element().invalidateStyleForSubtree();
    245245}
    246246

  • trunk/Source/WebCore/html/HTMLAnchorElement.cpp

    r206659 r207458  
    238238        setIsLink(!value.isNull() && !shouldProhibitLinks(this));
    239239        if (wasLink != isLink())
    240             setNeedsStyleRecalc();
     240            invalidateStyleForSubtree();
    241241        if (isLink()) {
    242242            String parsedURL = stripLeadingAndTrailingHTMLSpaces(value);

  • trunk/Source/WebCore/html/HTMLBodyElement.cpp

    r207361 r207458  
    170170        }
    171171
    172         setNeedsStyleRecalc();
     172        invalidateStyleForSubtree();
    173173        return;
    174174    }

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r205554 r207458  
    236236#if USE(IOSURFACE_CANVAS_BACKING_STORE) || ENABLE(ACCELERATED_2D_CANVAS)
    237237            // Need to make sure a RenderLayer and compositing layer get created for the Canvas
    238             setNeedsStyleRecalc(SyntheticStyleChange);
     238            invalidateStyleAndLayerComposition();
    239239#endif
    240240        }
    … …  
    251251                if (m_context) {
    252252                    // Need to make sure a RenderLayer and compositing layer get created for the Canvas
    253                     setNeedsStyleRecalc(SyntheticStyleChange);
     253                    invalidateStyleAndLayerComposition();
    254254                }
    255255            }
    … …  
    663663    if (m_context && m_context->is2d())
    664664        // Recalculate compositing requirements if acceleration state changed.
    665         const_cast<HTMLCanvasElement*>(this)->setNeedsStyleRecalc(SyntheticStyleChange);
     665        const_cast<HTMLCanvasElement*>(this)->invalidateStyleAndLayerComposition();
    666666#endif
    667667}

  • trunk/Source/WebCore/html/HTMLElement.cpp

    r207442 r207458  
    898898    for (auto& elementToAdjust : elementLineage(this)) {
    899899        if (elementAffectsDirectionality(elementToAdjust)) {
    900             elementToAdjust.setNeedsStyleRecalc();
     900            elementToAdjust.invalidateStyleForSubtree();
    901901            return;
    902902        }
    … …  
    910910    setHasDirAutoFlagRecursively(this, true, strongDirectionalityTextNode);
    911911    if (renderer() && renderer()->style().direction() != textDirection)
    912         setNeedsStyleRecalc();
     912        invalidateStyleForSubtree();
    913913}
    914914

  • trunk/Source/WebCore/html/HTMLFieldSetElement.cpp

    r203337 r207458  
    215215
    216216    if (m_invalidDescendants.isEmpty())
    217         setNeedsStyleRecalc();
     217        invalidateStyleForSubtree();
    218218    m_invalidDescendants.add(&invalidFormControlElement);
    219219}
    … …  
    226226    m_invalidDescendants.remove(&formControlElement);
    227227    if (m_invalidDescendants.isEmpty())
    228         setNeedsStyleRecalc();
     228        invalidateStyleForSubtree();
    229229}
    230230

  • trunk/Source/WebCore/html/HTMLFormControlElement.cpp

    r207380 r207458  
    175175{
    176176    setNeedsWillValidateCheck();
    177     setNeedsStyleRecalc();
     177    invalidateStyleForSubtree();
    178178    if (renderer() && renderer()->style().hasAppearance())
    179179        renderer()->theme().stateChanged(*renderer(), ControlStates::EnabledState);
    … …  
    183183{
    184184    setNeedsWillValidateCheck();
    185     setNeedsStyleRecalc();
     185    invalidateStyleForSubtree();
    186186}
    187187
    … …  
    191191    // Style recalculation is needed because style selectors may include
    192192    // :required and :optional pseudo-classes.
    193     setNeedsStyleRecalc();
     193    invalidateStyleForSubtree();
    194194}
    195195
    … …  
    446446
    447447    updateValidity();
    448     setNeedsStyleRecalc();
     448    invalidateStyleForSubtree();
    449449
    450450    if (!m_willValidate && !wasValid) {
    … …  
    556556    if (willValidate && m_isValid != wasValid) {
    557557        // Update style for pseudo classes such as :valid :invalid.
    558         setNeedsStyleRecalc();
     558        invalidateStyleForSubtree();
    559559
    560560        if (!m_isValid) {

  • trunk/Source/WebCore/html/HTMLFormElement.cpp

    r207380 r207458  
    592592        if (control.isSuccessfulSubmitButton()) {
    593593            if (!m_defaultButton)
    594                 control.setNeedsStyleRecalc();
     594                control.invalidateStyleForSubtree();
    595595            else
    596596                resetDefaultButton();
    … …  
    620620
    621621    if (m_invalidAssociatedFormControls.isEmpty())
    622         setNeedsStyleRecalc();
     622        invalidateStyleForSubtree();
    623623    m_invalidAssociatedFormControls.add(&formControlElement);
    624624}
    … …  
    628628    if (m_invalidAssociatedFormControls.remove(&formControlElement)) {
    629629        if (m_invalidAssociatedFormControls.isEmpty())
    630             setNeedsStyleRecalc();
     630            invalidateStyleForSubtree();
    631631    }
    632632}
    … …  
    738738    if (m_defaultButton != oldDefault) {
    739739        if (oldDefault)
    740             oldDefault->setNeedsStyleRecalc();
     740            oldDefault->invalidateStyleForSubtree();
    741741        if (m_defaultButton)
    742             m_defaultButton->setNeedsStyleRecalc();
     742            m_defaultButton->invalidateStyleForSubtree();
    743743    }
    744744}

  • trunk/Source/WebCore/html/HTMLFrameElementBase.cpp

    r205685 r207458  
    154154
    155155    if (!renderer())
    156         setNeedsStyleRecalc(ReconstructRenderTree);
     156        invalidateStyleAndRenderersForSubtree();
    157157    setNameAndOpenURL();
    158158}

  • trunk/Source/WebCore/html/HTMLFrameOwnerElement.cpp

    r205249 r207458  
    123123}
    124124
    125 void HTMLFrameOwnerElement::scheduleSetNeedsStyleRecalc(StyleChangeType changeType)
     125void HTMLFrameOwnerElement::scheduleinvalidateStyleAndLayerComposition()
    126126{
    127127    if (Style::postResolutionCallbacksAreSuspended()) {
    128128        RefPtr<HTMLFrameOwnerElement> element = this;
    129         Style::queuePostResolutionCallback([element, changeType]{
    130             element->setNeedsStyleRecalc(changeType);
     129        Style::queuePostResolutionCallback([element] {
     130            element->invalidateStyleAndLayerComposition();
    131131        });
    132132    } else
    133         setNeedsStyleRecalc(changeType);
     133        invalidateStyleAndLayerComposition();
    134134}
    135135

  • trunk/Source/WebCore/html/HTMLFrameOwnerElement.h

    r205249 r207458  
    5656    SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
    5757
    58     void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange);
     58    void scheduleinvalidateStyleAndLayerComposition();
    5959
    6060protected:

  • trunk/Source/WebCore/html/HTMLFrameSetElement.cpp

    r205249 r207458  
    8787            m_rowLengths = newLengthArray(value.string(), m_totalRows);
    8888            // FIXME: Would be nice to optimize the case where m_rowLengths did not change.
    89             setNeedsStyleRecalc();
     89            invalidateStyleForSubtree();
    9090        }
    9191        return;
    … …  
    9898            m_colLengths = newLengthArray(value.string(), m_totalCols);
    9999            // FIXME: Would be nice to optimize the case where m_colLengths did not change.
    100             setNeedsStyleRecalc();
     100            invalidateStyleForSubtree();
    101101        }
    102102        return;
    … …  
    203203bool HTMLFrameSetElement::willRecalcStyle(Style::Change)
    204204{
    205     if (needsStyleRecalc() && renderer()) {
     205    if (needsStyleRecalc() && renderer())
    206206        renderer()->setNeedsLayout();
    207         clearNeedsStyleRecalc();
    208     }
    209207    return true;
    210208}

  • trunk/Source/WebCore/html/HTMLInputElement.cpp

    r207010 r207458  
    550550
    551551    if (renderer())
    552         setNeedsStyleRecalc(ReconstructRenderTree);
     552        invalidateStyleAndRenderersForSubtree();
    553553
    554554    if (document().focusedElement() == this)
    … …  
    696696        if (!hasDirtyValue()) {
    697697            updatePlaceholderVisibility();
    698             setNeedsStyleRecalc();
     698            invalidateStyleForSubtree();
    699699        }
    700700        setFormControlValueMatchesRenderer(false);
    … …  
    703703    } else if (name == checkedAttr) {
    704704        if (m_inputType->isCheckable())
    705             setNeedsStyleRecalc();
     705            invalidateStyleForSubtree();
    706706
    707707        // Another radio button in the same group might be checked by state
    … …  
    732732        m_inputType->maxResultsAttributeChanged();
    733733    } else if (name == autosaveAttr) {
    734         setNeedsStyleRecalc();
     734        invalidateStyleForSubtree();
    735735    } else if (name == incrementalAttr) {
    736         setNeedsStyleRecalc();
     736        invalidateStyleForSubtree();
    737737    } else if (name == minAttr) {
    738738        m_inputType->minOrMaxAttributeChanged();
    … …  
    896896    m_reflectsCheckedAttribute = false;
    897897    m_isChecked = nowChecked;
    898     setNeedsStyleRecalc();
     898    invalidateStyleForSubtree();
    899899
    900900    if (RadioButtonGroups* buttons = radioButtonGroups())
    … …  
    922922    }
    923923
    924     setNeedsStyleRecalc();
     924    invalidateStyleForSubtree();
    925925}
    926926
    … …  
    932932    m_isIndeterminate = newValue;
    933933
    934     setNeedsStyleRecalc();
     934    invalidateStyleForSubtree();
    935935
    936936    if (renderer() && renderer()->style().hasAppearance())
    … …  
    13311331
    13321332    m_isAutoFilled = autoFilled;
    1333     setNeedsStyleRecalc();
     1333    invalidateStyleForSubtree();
    13341334}
    13351335
    … …  
    17871787
    17881788    // FIXME: Do we really need to do this if the effective maxLength has not changed?
    1789     setNeedsStyleRecalc();
     1789    invalidateStyleForSubtree();
    17901790    updateValidity();
    17911791}
    … …  
    18031803
    18041804    // FIXME: Do we really need to do this if the effective minLength has not changed?
    1805     setNeedsStyleRecalc();
     1805    invalidateStyleForSubtree();
    18061806    updateValidity();
    18071807}

  • trunk/Source/WebCore/html/HTMLLinkElement.cpp

    r207053 r207458  
    158158        setIsLink(!value.isNull() && !shouldProhibitLinks(this));
    159159        if (wasLink != isLink())
    160             setNeedsStyleRecalc();
     160            invalidateStyleForSubtree();
    161161        process();
    162162        return;

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r207368 r207458  
    45774577
    45784578    // Kick off a fake recalcStyle that will update the compositing tree.
    4579     setNeedsStyleRecalc(SyntheticStyleChange);
     4579    invalidateStyleAndLayerComposition();
    45804580}
    45814581
    … …  
    55915591   
    55925592    m_player->setVideoFullscreenLayer(platformLayer, completionHandler);
    5593     setNeedsStyleRecalc(SyntheticStyleChange);
     5593    invalidateStyleAndLayerComposition();
    55945594#if ENABLE(VIDEO_TRACK)
    55955595    updateTextTrackDisplay();

  • trunk/Source/WebCore/html/HTMLObjectElement.cpp

    r205690 r207458  
    136136
    137137    clearUseFallbackContent();
    138     setNeedsStyleRecalc(ReconstructRenderTree);
     138    invalidateStyleAndRenderersForSubtree();
    139139}
    140140
    … …  
    356356    if (inDocument() && !useFallbackContent()) {
    357357        setNeedsWidgetUpdate(true);
    358         setNeedsStyleRecalc();
     358        invalidateStyleForSubtree();
    359359    }
    360360    HTMLPlugInImageElement::childrenChanged(change);
    … …  
    379379        return;
    380380
    381     setNeedsStyleRecalc(ReconstructRenderTree);
     381    invalidateStyleAndRenderersForSubtree();
    382382
    383383    // Before we give up and use fallback content, check to see if this is a MIME type issue.

  • trunk/Source/WebCore/html/HTMLOptGroupElement.cpp

    r204186 r207458  
    8282
    8383    if (name == disabledAttr)
    84         setNeedsStyleRecalc();
     84        invalidateStyleForSubtree();
    8585}
    8686

  • trunk/Source/WebCore/html/HTMLOptionElement.cpp

    r205104 r207458  
    175175        m_disabled = !value.isNull();
    176176        if (oldDisabled != m_disabled) {
    177             setNeedsStyleRecalc();
     177            invalidateStyleForSubtree();
    178178            if (renderer() && renderer()->style().hasAppearance())
    179179                renderer()->theme().stateChanged(*renderer(), ControlStates::EnabledState);
    180180        }
    181181    } else if (name == selectedAttr) {
    182         setNeedsStyleRecalc();
     182        invalidateStyleForSubtree();
    183183
    184184        // FIXME: This doesn't match what the HTML specification says.
    … …  
    230230
    231231    m_isSelected = selected;
    232     setNeedsStyleRecalc();
     232    invalidateStyleForSubtree();
    233233
    234234    if (HTMLSelectElement* select = ownerSelectElement())

  • trunk/Source/WebCore/html/HTMLPlugInElement.cpp

    r205271 r207458  
    301301    if (m_pluginReplacement->installReplacement(*root)) {
    302302        setDisplayState(DisplayingPluginReplacement);
    303         setNeedsStyleRecalc(ReconstructRenderTree);
     303        invalidateStyleAndRenderersForSubtree();
    304304    }
    305305}

  • trunk/Source/WebCore/html/HTMLPlugInImageElement.cpp

    r206254 r207458  
    140140        m_isRestartedPlugin = true;
    141141        m_snapshotDecision = NeverSnapshot;
    142         setNeedsStyleRecalc(SyntheticStyleChange);
     142        invalidateStyleAndLayerComposition();
    143143        if (displayState() == DisplayingSnapshot)
    144144            m_removeSnapshotTimer.startOneShot(removeSnapshotTimerDelay);
    … …  
    240240{
    241241    // Make sure style recalcs scheduled by a child shadow tree don't trigger reconstruction and cause flicker.
    242     if (change == Style::NoChange && styleChangeType() == NoStyleChange)
     242    if (change == Style::NoChange && styleValidity() == Style::Validity::Valid)
    243243        return true;
    244244
    … …  
    246246    // It is only done because loading and load event dispatching is tied to render tree construction.
    247247    if (!useFallbackContent() && needsWidgetUpdate() && renderer() && !isImageType() && (displayState() != DisplayingSnapshot))
    248         setNeedsStyleRecalc(ReconstructRenderTree);
     248        invalidateStyleAndRenderersForSubtree();
    249249    return true;
    250250}
    … …  
    307307    setNeedsWidgetUpdate(true);
    308308    if (inDocument())
    309         setNeedsStyleRecalc();
     309        invalidateStyleForSubtree();
    310310}
    311311
    … …  
    333333void HTMLPlugInImageElement::resumeFromDocumentSuspension()
    334334{
    335     setNeedsStyleRecalc(ReconstructRenderTree);
     335    invalidateStyleAndRenderersForSubtree();
    336336
    337337    HTMLPlugInElement::resumeFromDocumentSuspension();
    … …  
    438438    m_snapshotImage = nullptr;
    439439    m_isRestartedPlugin = false;
    440     setNeedsStyleRecalc(SyntheticStyleChange);
     440    invalidateStyleAndLayerComposition();
    441441    if (renderer())
    442442        renderer()->repaint();
    … …  
    516516
    517517    setDisplayState(Restarting);
    518     setNeedsStyleRecalc(ReconstructRenderTree);
     518    invalidateStyleAndRenderersForSubtree();
    519519}
    520520

  • trunk/Source/WebCore/html/HTMLProgressElement.cpp

    r203337 r207458  
    142142        render->updateFromElement();
    143143        if (wasDeterminate != isDeterminate())
    144             setNeedsStyleRecalc();
     144            invalidateStyleForSubtree();
    145145    }
    146146}

  • trunk/Source/WebCore/html/HTMLSelectElement.cpp

    r207276 r207458  
    304304        updateValidity();
    305305        if (m_size != oldSize) {
    306             setNeedsStyleRecalc(ReconstructRenderTree);
     306            invalidateStyleAndRenderersForSubtree();
    307307            setRecalcListItems();
    308308            updateValidity();
    … …  
    745745    m_activeSelectionAnchorIndex = -1;
    746746    setOptionsChangedOnRenderer();
    747     setNeedsStyleRecalc();
     747    invalidateStyleForSubtree();
    748748    if (!inDocument()) {
    749749        if (HTMLCollection* collection = cachedHTMLCollection(SelectOptions))
    … …  
    10231023    updateValidity();
    10241024    if (oldUsesMenuList != usesMenuList())
    1025         setNeedsStyleRecalc(ReconstructRenderTree);
     1025        invalidateStyleAndRenderersForSubtree();
    10261026}
    10271027
    … …  
    10721072
    10731073    setOptionsChangedOnRenderer();
    1074     setNeedsStyleRecalc();
     1074    invalidateStyleForSubtree();
    10751075    updateValidity();
    10761076}

  • trunk/Source/WebCore/html/HTMLTableElement.cpp

    r206744 r207458  
    3030#include "CSSValueKeywords.h"
    3131#include "CSSValuePool.h"
     32#include "ElementChildIterator.h"
    3233#include "ExceptionCode.h"
    3334#include "ExceptionCodePlaceholder.h"
    … …  
    266267}
    267268
    268 static inline bool isTableCellAncestor(Node* n)
    269 {
    270     return n->hasTagName(theadTag) || n->hasTagName(tbodyTag) ||
    271            n->hasTagName(tfootTag) || n->hasTagName(trTag) ||
    272            n->hasTagName(thTag);
    273 }
    274 
    275 static bool setTableCellsChanged(Node* n)
    276 {
    277     ASSERT(n);
     269static inline bool isTableCellAncestor(const Element& element)
     270{
     271    return element.hasTagName(theadTag)
     272        || element.hasTagName(tbodyTag)
     273        || element.hasTagName(tfootTag)
     274        || element.hasTagName(trTag)
     275        || element.hasTagName(thTag);
     276}
     277
     278static bool setTableCellsChanged(Element& element)
     279{
    278280    bool cellChanged = false;
    279281
    280     if (n->hasTagName(tdTag))
     282    if (element.hasTagName(tdTag))
    281283        cellChanged = true;
    282     else if (isTableCellAncestor(n)) {
    283         for (Node* child = n->firstChild(); child; child = child->nextSibling())
     284    else if (isTableCellAncestor(element)) {
     285        for (auto& child : childrenOfType<Element>(element))
    284286            cellChanged |= setTableCellsChanged(child);
    285287    }
    286288
    287289    if (cellChanged)
    288        n->setNeedsStyleRecalc();
     290        element.invalidateStyleForSubtree();
    289291
    290292    return cellChanged;
    … …  
    423425        m_sharedCellStyle = nullptr;
    424426        bool cellChanged = false;
    425         for (Node* child = firstChild(); child; child = child->nextSibling())
     427        for (auto& child : childrenOfType<Element>(*this))
    426428            cellChanged |= setTableCellsChanged(child);
    427429        if (cellChanged)
    428             setNeedsStyleRecalc();
     430            invalidateStyleForSubtree();
    429431    }
    430432}

  • trunk/Source/WebCore/html/HTMLTextAreaElement.cpp

    r206026 r207458  
    398398    setLastChangeWasNotUserEdit();
    399399    updatePlaceholderVisibility();
    400     setNeedsStyleRecalc();
     400    invalidateStyleForSubtree();
    401401    setFormControlValueMatchesRenderer(true);
    402402

  • trunk/Source/WebCore/html/HTMLTextFormControlElement.cpp

    r205524 r207458  
    167167        return;
    168168
    169     setNeedsStyleRecalc();
     169    invalidateStyleForSubtree();
    170170}
    171171

  • trunk/Source/WebCore/html/InputType.cpp

    r205912 r207458  
    684684{
    685685    element().setValueInternal(sanitizedValue, eventBehavior);
    686     element().setNeedsStyleRecalc();
     686    element().invalidateStyleForSubtree();
    687687    if (!valueChanged)
    688688        return;

  • trunk/Source/WebCore/html/NumberInputType.cpp

    r205249 r207458  
    301301    InputType::minOrMaxAttributeChanged();
    302302    HTMLInputElement& element = this->element();
    303     element.setNeedsStyleRecalc();
     303    element.invalidateStyleForSubtree();
    304304    if (RenderObject* renderer = element.renderer())
    305305        renderer->setNeedsLayoutAndPrefWidthsRecalc();

  • trunk/Source/WebCore/html/TextFieldInputType.cpp

    r206357 r207458  
    551551    element().updatePlaceholderVisibility();
    552552    // Recalc for :invalid change.
    553     element().setNeedsStyleRecalc();
     553    element().invalidateStyleForSubtree();
    554554
    555555    didSetValueByUserEdit();

  • trunk/Source/WebCore/mathml/MathMLElement.cpp

    r205249 r207458  
    7676        setIsLink(!value.isNull() && !shouldProhibitLinks(this));
    7777        if (wasLink != isLink())
    78             setNeedsStyleRecalc();
     78            invalidateStyleForSubtree();
    7979    } else if (name == rowspanAttr) {
    8080        if (is<RenderTableCell>(renderer()) && hasTagName(mtdTag))

  • trunk/Source/WebCore/mathml/MathMLSelectElement.cpp

    r205249 r207458  
    207207
    208208    m_selectedChild = newSelectedChild;
    209     setNeedsStyleRecalc();
     209    invalidateStyleForSubtree();
    210210}
    211211

  • trunk/Source/WebCore/page/animation/AnimationBase.cpp

    r205818 r207458  
    9292    ASSERT(!element || element->document().pageCacheState() == Document::NotInPageCache);
    9393    if (element)
    94         element->setNeedsStyleRecalc(SyntheticStyleChange);
     94        element->invalidateStyleAndLayerComposition();
    9595}
    9696

  • trunk/Source/WebCore/page/animation/AnimationController.cpp

    r205818 r207458  
    113113   
    114114    // Return false if we didn't do anything OR we are suspended (so we don't try to
    115     // do a setNeedsStyleRecalc() when suspended).
     115    // do a invalidateStyleForSubtree() when suspended).
    116116    RefPtr<CompositeAnimation> animation = m_compositeAnimations.take(&renderer);
    117117    ASSERT(animation);
    … …  
    139139                ASSERT(element);
    140140                ASSERT(element->document().pageCacheState() == Document::NotInPageCache);
    141                 element->setNeedsStyleRecalc(SyntheticStyleChange);
     141                element->invalidateStyleAndLayerComposition();
    142142                calledSetChanged = true;
    143143            }
    … …  
    212212
    213213    for (auto& change : m_elementChangesToDispatch)
    214         change->setNeedsStyleRecalc(SyntheticStyleChange);
     214        change->invalidateStyleAndLayerComposition();
    215215
    216216    m_elementChangesToDispatch.clear();
    … …  
    359359    CompositeAnimation& compositeAnimation = ensureCompositeAnimation(*renderer);
    360360    if (compositeAnimation.pauseAnimationAtTime(name, t)) {
    361         renderer->element()->setNeedsStyleRecalc(SyntheticStyleChange);
     361        renderer->element()->invalidateStyleAndLayerComposition();
    362362        startUpdateStyleIfNeededDispatcher();
    363363        return true;
    … …  
    374374    CompositeAnimation& compositeAnimation = ensureCompositeAnimation(*renderer);
    375375    if (compositeAnimation.pauseTransitionAtTime(cssPropertyID(property), t)) {
    376         renderer->element()->setNeedsStyleRecalc(SyntheticStyleChange);
     376        renderer->element()->invalidateStyleAndLayerComposition();
    377377        startUpdateStyleIfNeededDispatcher();
    378378        return true;
    … …  
    591591    ASSERT(!element || element->document().pageCacheState() == Document::NotInPageCache);
    592592    if (element)
    593         element->setNeedsStyleRecalc(SyntheticStyleChange);
     593        element->invalidateStyleAndLayerComposition();
    594594}
    595595

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

    r206903 r207458  
    257257            if (element()) {
    258258                m_needsToSetSizeForAltText = true;
    259                 element()->setNeedsStyleRecalc(SyntheticStyleChange);
     259                element()->invalidateStyleAndLayerComposition();
    260260            }
    261261            return;

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

    r207357 r207458  
    69866986    // We use the enclosing element so that we recalculate style for the ancestor of an anonymous object.
    69876987    if (Element* element = enclosingElement())
    6988         element->setNeedsStyleRecalc(SyntheticStyleChange);
     6988        element->invalidateStyleAndLayerComposition();
    69896989    renderer().repaint();
    69906990}

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

    r205927 r207458  
    35503550            // The layer will get hooked up via RenderLayerBacking::updateConfiguration()
    35513551            // for the frame's renderer in the parent document.
    3552             m_renderView.document().ownerElement()->scheduleSetNeedsStyleRecalc(SyntheticStyleChange);
     3552            m_renderView.document().ownerElement()->scheduleinvalidateStyleAndLayerComposition();
    35533553            break;
    35543554        }
    … …  
    35793579
    35803580        if (HTMLFrameOwnerElement* ownerElement = m_renderView.document().ownerElement())
    3581             ownerElement->scheduleSetNeedsStyleRecalc(SyntheticStyleChange);
     3581            ownerElement->scheduleinvalidateStyleAndLayerComposition();
    35823582        break;
    35833583    }
    … …  
    36383638    // we need to schedule a style recalc in our parent document.
    36393639    if (HTMLFrameOwnerElement* ownerElement = m_renderView.document().ownerElement())
    3640         ownerElement->scheduleSetNeedsStyleRecalc(SyntheticStyleChange);
     3640        ownerElement->scheduleinvalidateStyleAndLayerComposition();
    36413641}
    36423642

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

    r206395 r207458  
    14891489    bool valueChanged = (dragOn != isDragging());
    14901490    setIsDragging(dragOn);
    1491     if (valueChanged && node() && (style().affectedByDrag() || (is<Element>(*node()) && downcast<Element>(*node()).childrenAffectedByDrag())))
    1492         node()->setNeedsStyleRecalc();
    14931491
    14941492    if (!is<RenderElement>(*this))
    14951493        return;
    1496 
    1497     for (auto& child : childrenOfType<RenderObject>(downcast<RenderElement>(*this)))
     1494    auto& renderElement = downcast<RenderElement>(*this);
     1495
     1496    if (valueChanged && renderElement.element() && (style().affectedByDrag() || renderElement.element()->childrenAffectedByDrag()))
     1497        renderElement.element()->invalidateStyleForSubtree();
     1498
     1499    for (auto& child : childrenOfType<RenderObject>(renderElement))
    14981500        child.updateDragState(dragOn);
    14991501}

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

    r194496 r207458  
    122122
    123123    if (renderer.element() && !renderer.element()->isSVGElement())
    124         renderer.element()->setNeedsStyleRecalc(SyntheticStyleChange);
     124        renderer.element()->invalidateStyleAndLayerComposition();
    125125}
    126126

  • trunk/Source/WebCore/style/AttributeChangeInvalidation.cpp

    r206951 r207458  
    6666
    6767    if (!isHTML) {
    68         m_element.setNeedsStyleRecalc(FullStyleChange);
     68        m_element.invalidateStyleForSubtree();
    6969        return;
    7070    }
    7171
    7272    if (m_element.shadowRoot() && ruleSets.authorStyle().hasShadowPseudoElementRules()) {
    73         m_element.setNeedsStyleRecalc(FullStyleChange);
     73        m_element.invalidateStyleForSubtree();
    7474        return;
    7575    }
    7676
    77     m_element.setNeedsStyleRecalc(InlineStyleChange);
     77    m_element.invalidateStyle();
    7878
    7979    if (!childrenOfType<Element>(m_element).first())

  • trunk/Source/WebCore/style/ClassChangeInvalidation.cpp

    r206951 r207458  
    117117
    118118    if (shadowRoot && ruleSets.authorStyle().hasShadowPseudoElementRules()) {
    119         m_element.setNeedsStyleRecalc(FullStyleChange);
     119        m_element.invalidateStyleForSubtree();
    120120        return;
    121121    }
    122122
    123     m_element.setNeedsStyleRecalc(InlineStyleChange);
     123    m_element.invalidateStyle();
    124124
    125125    if (!childrenOfType<Element>(m_element).first())

  • trunk/Source/WebCore/style/IdChangeInvalidation.cpp

    r206951 r207458  
    6262
    6363    if (m_element.shadowRoot() && ruleSets.authorStyle().hasShadowPseudoElementRules()) {
    64         m_element.setNeedsStyleRecalc(FullStyleChange);
     64        m_element.invalidateStyleForSubtree();
    6565        return;
    6666    }
    6767
    68     m_element.setNeedsStyleRecalc(InlineStyleChange);
     68    m_element.invalidateStyle();
    6969
    7070    // This could be easily optimized for fine-grained descendant invalidation similar to ClassChangeInvalidation.
    … …  
    7272    bool mayAffectDescendantStyle = ruleSets.features().idsMatchingAncestorsInRules.contains(changedId.impl());
    7373    if (mayAffectDescendantStyle)
    74         m_element.setNeedsStyleRecalc(FullStyleChange);
     74        m_element.invalidateStyleForSubtree();
    7575    else
    76         m_element.setNeedsStyleRecalc(InlineStyleChange);
     76        m_element.invalidateStyle();
    7777}
    7878

  • trunk/Source/WebCore/style/RenderTreeUpdater.cpp

    r203985 r207458  
    290290    auto& renderer = *element.renderer();
    291291
    292     if (update.isSynthetic) {
     292    if (update.recompositeLayer) {
    293293        renderer.setStyle(WTFMove(*update.style), StyleDifferenceRecompositeLayer);
    294294        return;

  • trunk/Source/WebCore/style/StyleScope.cpp

    r207280 r207458  
    393393        if (m_shadowRoot) {
    394394            for (auto& shadowChild : childrenOfType<Element>(*m_shadowRoot))
    395                 shadowChild.setNeedsStyleRecalc();
     395                shadowChild.invalidateStyleForSubtree();
    396396        } else
    397397            m_document.scheduleForcedStyleRecalc();

  • trunk/Source/WebCore/style/StyleTreeResolver.cpp

    r207372 r207458  
    169169        if (child.needsStyleRecalc() || affectedByPreviousSibling) {
    170170            child.resetComputedStyle();
    171             child.clearNeedsStyleRecalc();
     171            child.setHasValidStyle();
    172172        }
    173173
    … …  
    201201        return { };
    202202
    203     bool shouldReconstructRenderTree = element.styleChangeType() == ReconstructRenderTree || parent().change == Detach;
     203    bool shouldReconstructRenderTree = element.styleValidity() >= Validity::SubtreeAndRenderersInvalid || parent().change == Detach;
    204204    auto* rendererToUpdate = shouldReconstructRenderTree ? nullptr : element.renderer();
    205205
    206206    auto update = createAnimatedElementUpdate(WTFMove(newStyle), rendererToUpdate, m_document);
    207207
    208     if (element.styleChangeType() == SyntheticStyleChange)
    209         update.isSynthetic = true;
     208    if (element.styleResolutionShouldRecompositeLayer())
     209        update.recompositeLayer = true;
    210210
    211211    auto* existingStyle = element.renderStyle();
    … …  
    234234    }
    235235
    236     if (update.change != Detach && (parent().change == Force || element.styleChangeType() == FullStyleChange))
     236    if (update.change != Detach && (parent().change == Force || element.styleValidity() >= Validity::SubtreeInvalid))
    237237        update.change = Force;
    238238
    … …  
    246246    std::unique_ptr<RenderStyle> animatedStyle;
    247247    if (rendererToUpdate && document.frame()->animation().updateAnimations(*rendererToUpdate, *newStyle, animatedStyle))
    248         update.isSynthetic = true;
     248        update.recompositeLayer = true;
    249249
    250250    if (animatedStyle) {
    … …  
    283283    auto& parentElement = *parent().element;
    284284
    285     parentElement.clearNeedsStyleRecalc();
     285    parentElement.setHasValidStyle();
    286286    parentElement.clearChildNeedsStyleRecalc();
    287287
    … …  
    333333static void clearNeedsStyleResolution(Element& element)
    334334{
    335     element.clearNeedsStyleRecalc();
     335    element.setHasValidStyle();
    336336    if (auto* before = element.beforePseudoElement())
    337         before->clearNeedsStyleRecalc();
     337        before->setHasValidStyle();
    338338    if (auto* after = element.afterPseudoElement())
    339         after->clearNeedsStyleRecalc();
     339        after->setHasValidStyle();
    340340}
    341341
    … …  
    363363        if (is<Text>(node)) {
    364364            auto& text = downcast<Text>(node);
    365             if (text.styleChangeType() == ReconstructRenderTree && parent.change != Detach)
     365            if (text.styleValidity() >= Validity::SubtreeAndRenderersInvalid && parent.change != Detach)
    366366                m_update->addText(text, parent.element);
    367367
    368             text.clearNeedsStyleRecalc();
     368            text.setHasValidStyle();
    369369            it.traverseNextSkippingChildren();
    370370            continue;

  • trunk/Source/WebCore/style/StyleUpdate.h

    r207372 r207458  
    4949    std::unique_ptr<RenderStyle> style;
    5050    Change change { NoChange };
    51     bool isSynthetic { false };
     51    bool recompositeLayer { false };
    5252};
    5353

  • trunk/Source/WebCore/svg/SVGAElement.cpp

    r205249 r207458  
    9999        if (wasLink != isLink()) {
    100100            InstanceInvalidationGuard guard(*this);
    101             setNeedsStyleRecalc();
     101            invalidateStyleForSubtree();
    102102        }
    103103    }

  • trunk/Source/WebCore/svg/SVGAnimateElementBase.cpp

    r206753 r207458  
    240240        return;
    241241
    242     targetElement.setNeedsStyleRecalc(SyntheticStyleChange);
     242    targetElement.invalidateStyleAndLayerComposition();
    243243}
    244244
    … …  
    247247    ASSERT(!targetElement.m_deletionHasBegun);
    248248    targetElement.ensureAnimatedSMILStyleProperties().removeProperty(id);
    249     targetElement.setNeedsStyleRecalc(SyntheticStyleChange);
     249    targetElement.invalidateStyleAndLayerComposition();
    250250}
    251251

  • trunk/Source/WebCore/svg/SVGElement.cpp

    r205411 r207458  
    302302bool SVGElement::willRecalcStyle(Style::Change change)
    303303{
    304     if (!m_svgRareData || styleChangeType() == SyntheticStyleChange)
     304    if (!m_svgRareData || styleResolutionShouldRecompositeLayer())
    305305        return true;
    306306    // If the style changes because of a regular property change (not induced by SMIL animations themselves)

  • trunk/Source/WebCore/svg/SVGElement.h

    r205411 r207458  
    9191        ensureUniqueElementData().setPresentationAttributeStyleIsDirty(true);
    9292        // Trigger style recalculation for "elements as resource" (e.g. referenced by feImage).
    93         setNeedsStyleRecalc(InlineStyleChange);
     93        invalidateStyle();
    9494    }
    9595

  • trunk/Source/WebCore/svg/SVGTests.cpp

    r205468 r207458  
    194194    if (!targetElement->inDocument())
    195195        return true;
    196     targetElement->setNeedsStyleRecalc(ReconstructRenderTree);
     196    targetElement->invalidateStyleAndRenderersForSubtree();
    197197    return true;
    198198}

  • trunk/Source/WebCore/svg/SVGUseElement.cpp

    r206903 r207458  
    515515        return;
    516516    m_shadowTreeNeedsUpdate = true;
    517     setNeedsStyleRecalc(ReconstructRenderTree);
     517    invalidateStyleAndRenderersForSubtree();
    518518    invalidateDependentShadowTrees();
    519519}

  • trunk/Source/WebCore/testing/Internals.cpp

    r207372 r207458  
    487487}
    488488
    489 static String styleChangeTypeToString(StyleChangeType type)
    490 {
    491     switch (type) {
    492     case NoStyleChange:
     489static String styleValidityToToString(Style::Validity validity)
     490{
     491    switch (validity) {
     492    case Style::Validity::Valid:
    493493        return "NoStyleChange";
    494     case InlineStyleChange:
     494    case Style::Validity::ElementInvalid:
    495495        return "InlineStyleChange";
    496     case FullStyleChange:
     496    case Style::Validity::SubtreeInvalid:
    497497        return "FullStyleChange";
    498     case SyntheticStyleChange:
    499         return "SyntheticStyleChange";
    500     case ReconstructRenderTree:
     498    case Style::Validity::SubtreeAndRenderersInvalid:
    501499        return "ReconstructRenderTree";
    502500    }
    … …  
    507505String Internals::styleChangeType(Node& node)
    508506{
    509     return styleChangeTypeToString(node.styleChangeType());
     507    return styleValidityToToString(node.styleValidity());
    510508}
    511509

  • trunk/Source/WebKit/mac/ChangeLog

    r207439 r207458  
     12016-10-17  Antti Koivisto  <antti@apple.com>
     2
     3        Rename setNeedsStyleRecalc to invalidateStyle
     4        https://bugs.webkit.org/show_bug.cgi?id=163542
     5
     6        Reviewed by Darin Adler.
     7
     8        * Plugins/Hosted/WebHostedNetscapePluginView.mm:
     9        (-[WebHostedNetscapePluginView createPluginLayer]):
     10        * Plugins/WebNetscapePluginView.mm:
     11        (-[WebNetscapePluginView createPlugin]):
     12
    1132016-10-17  Jeremy Jones  <jeremyj@apple.com>
    214

  • trunk/Source/WebKit/mac/Plugins/Hosted/WebHostedNetscapePluginView.mm

    r201689 r207458  
    169169        // for iframes that contain composited plugins at bad times. https://bugs.webkit.org/show_bug.cgi?id=39033
    170170        core([self webFrame])->view()->enterCompositingMode();
    171         [self element]->setNeedsStyleRecalc(SyntheticStyleChange);
     171        [self element]->invalidateStyleAndLayerComposition();
    172172    } else
    173173        self.wantsLayer = YES;

  • trunk/Source/WebKit/mac/Plugins/WebNetscapePluginView.mm

    r204702 r207458  
    11001100                [_pluginLayer.get() addSublayer:realPluginLayer.get()];
    11011101
    1102                 // Eagerly enter compositing mode, since we know we'll need it. This avoids firing setNeedsStyleRecalc()
     1102                // Eagerly enter compositing mode, since we know we'll need it. This avoids firing invalidateStyle()
    11031103                // for iframes that contain composited plugins at bad times. https://bugs.webkit.org/show_bug.cgi?id=39033
    11041104                core([self webFrame])->view()->enterCompositingMode();
    1105                 [self element]->setNeedsStyleRecalc(SyntheticStyleChange);
     1105                [self element]->invalidateStyleAndLayerComposition();
    11061106            } else
    11071107                [self setWantsLayer:YES];

  • trunk/Source/WebKit2/ChangeLog

    r207454 r207458  
     12016-10-17  Antti Koivisto  <antti@apple.com>
     2
     3        Rename setNeedsStyleRecalc to invalidateStyle
     4        https://bugs.webkit.org/show_bug.cgi?id=163542
     5
     6        Reviewed by Darin Adler.
     7
     8        * WebProcess/Plugins/PluginView.cpp:
     9        (WebKit::PluginView::didInitializePlugin):
     10        (WebKit::PluginView::pluginProcessCrashed):
     11
    1122016-10-17  Carlos Garcia Campos  <cgarcia@igalia.com>
    213

  • trunk/Source/WebKit2/WebProcess/Plugins/PluginView.cpp

    r205682 r207458  
    664664        if (m_plugin->pluginLayer() && frame()) {
    665665            frame()->view()->enterCompositingMode();
    666             m_pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
     666            m_pluginElement->invalidateStyleAndLayerComposition();
    667667        }
    668668        if (frame() && !frame()->settings().maximumPlugInSnapshotAttempts()) {
    … …  
    674674        if (m_plugin->pluginLayer() && frame()) {
    675675            frame()->view()->enterCompositingMode();
    676             m_pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
     676            m_pluginElement->invalidateStyleAndLayerComposition();
    677677        }
    678678        if (m_pluginElement->displayState() == HTMLPlugInElement::RestartingWithPendingMouseClick)
    … …  
    15711571        return;
    15721572
    1573     m_pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
     1573    m_pluginElement->invalidateStyleAndLayerComposition();
    15741574
    15751575    downcast<RenderEmbeddedObject>(*renderer).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
Note: See TracChangeset for help on using the changeset viewer.