Attachment #275310 for bug #155298

View Details Raw Unified Return to Bug 155298

| Differences between



2016-03-31  Antti Koivisto  <antti@apple.com>

        Separate render tree updating from style resolve
        https://bugs.webkit.org/show_bug.cgi?id=155298

        Reviewed by Andreas Kling.

        This patch splits computing document style and applying the results into two distinct steps:

        Style::TreeResolver::resolve()
                |
                | Style::Update
                V
        RenderTreeUpdater::commit()

        Style::TreeResolver::resolve() returns a Style::Update object that contains all the changes to be made
        for the whole composed tree. RenderTreeUpdater then applies the changes updating, building or tearing
        down portions of the render tree as needed.

        Style::Update consists of a map that contains new style for each newly resolved element along with some
        metadata. A separate map contains text nodes that require reconstruction. It also tracks change roots so
        RenderTreeUpdater needs to traverse the changed subtrees only.

        The patch eliminates the recursive render tree build code path replacing it with iterative functions.

        This will enable future optimizations. For example we won't need to commit to immediate rendering
        changes simply because some script or internal function requires up-to-date style.

        * CMakeLists.txt:
        * WebCore.xcodeproj/project.pbxproj:
        * css/StyleResolver.cpp:
        (WebCore::StyleResolver::State::State):
        (WebCore::StyleResolver::styleForElement):
        * css/StyleResolver.h:
        (WebCore::StyleResolver::setOverrideDocumentElementStyle):
        (WebCore::StyleResolver::State::State):

            Root element style is needed for resolving other elements. Add a way to provide it without looking
            into active document style.

        * dom/Document.cpp:
        (WebCore::Document::recalcStyle):

            Resolve the document style and commit it immediately (for now).

        (WebCore::Document::styleForElementIgnoringPendingStylesheets):
        * dom/Document.h:
        (WebCore::Document::setNeedsNotifyRemoveAllPendingStylesheet):
        (WebCore::Document::inStyleRecalc):
        (WebCore::Document::inRenderTreeUpdate):
        * dom/Element.cpp:
        (WebCore::Element::setChildIndex):

            Setting the unique bit is now done by style relations update code.

        * dom/Node.cpp:
        (WebCore::Node::setNeedsStyleRecalc):

            Prevent spurious style invalidation during render tree updating.

        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::styleDidChange):

            Capturing body element color for color:-webkit-text is now done by TreeResolver.

        * rendering/RenderElement.h:
        (WebCore::RenderElement::setAnimatableStyle): Deleted.

            No longer used.

        * style/RenderTreePosition.cpp:
        (WebCore::RenderTreePosition::nextSiblingRenderer):

            Skip over non-rendered slot elements.

        * style/RenderTreeUpdater.cpp: Added.
        (WebCore::RenderTreeUpdater::Parent::Parent):
        (WebCore::RenderTreeUpdater::RenderTreeUpdater):
        (WebCore::hasDisplayContents):
        (WebCore::findRenderingRoot):
        (WebCore::RenderTreeUpdater::commit):

            Call updateRenderTree for each change root.

        (WebCore::shouldCreateRenderer):
        (WebCore::RenderTreeUpdater::updateRenderTree):

            Iteratively traverse the composed tree starting for a change root.
            Apply the changes calling updateElementRenderer and updateTextRenderer as needed.
            Enter subtrees that haves changes to apply.

        (WebCore::RenderTreeUpdater::renderTreePosition):

            We may not create renderers for all elements (<slot> or more generally display:contents) that
            have rendered descendants. Search the parent stack to find the valid position.

        (WebCore::RenderTreeUpdater::pushParent):
        (WebCore::RenderTreeUpdater::popParent):
        (WebCore::RenderTreeUpdater::popParentsToDepth):

            Maintain parent stack.

        (WebCore::pseudoStyleCacheIsInvalid):
        (WebCore::RenderTreeUpdater::updateElementRenderer):

            Create, delete or update the renderer.

        (WebCore::moveToFlowThreadIfNeeded):
        (WebCore::RenderTreeUpdater::createRenderer):
        (WebCore::textRendererIsNeeded):
        (WebCore::createTextRenderer):
        (WebCore::RenderTreeUpdater::updateTextRenderer):
        (WebCore::RenderTreeUpdater::invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded):

            This is moved from TreeResolver.

        (WebCore::needsPseudoElement):
        (WebCore::RenderTreeUpdater::updateBeforeOrAfterPseudoElement):

            Pseudo elements are handled entirely during render tree construction. Compute their style and
            create or delete them as needed.

        * style/RenderTreeUpdater.h: Added.
        (WebCore::RenderTreeUpdater::parent):
        * style/StyleRelations.cpp:
        (WebCore::Style::commitRelationsToRenderStyle):
        (WebCore::Style::commitRelations):

            Commit to Style::Update instead of the document if needed.

        (WebCore::Style::commitRelationsToDocument): Deleted.
        * style/StyleRelations.h:
        * style/StyleSharingResolver.cpp:
        (WebCore::Style::elementHasDirectionAuto):
        (WebCore::Style::SharingResolver::resolve):

            Fetch the shareable style from Style::Update instead of the active document style.

        (WebCore::Style::SharingResolver::findSibling):
        (WebCore::Style::SharingResolver::canShareStyleWithElement):
        * style/StyleSharingResolver.h:
        * style/StyleTreeResolver.cpp:
        (WebCore::Style::TreeResolver::Parent::Parent):

            No need for render tree position anymore.

        (WebCore::Style::TreeResolver::popScope):
        (WebCore::Style::TreeResolver::styleForElement):
        (WebCore::Style::invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded):
        (WebCore::Style::createTextRendererIfNeeded):
        (WebCore::Style::updateTextRendererAfterContentChange):
        (WebCore::Style::resetStyleForNonRenderedDescendants):
        (WebCore::Style::detachChildren):
        (WebCore::Style::detachSlotAssignees):
        (WebCore::Style::detachRenderTree):
        (WebCore::Style::TreeResolver::resolveElement):

            Just resolve the style and return it, no more applying or entering render tree construction code paths.

        (WebCore::Style::resolveTextNode):
        (WebCore::Style::elementImplicitVisibility):
        (WebCore::Style::TreeResolver::pushParent):
        (WebCore::Style::TreeResolver::popParent):
        (WebCore::Style::TreeResolver::popParentsToDepth):
        (WebCore::Style::shouldResolvePseudoElement):
        (WebCore::Style::TreeResolver::resolveComposedTree):

            Add style changes to Style::Update.

        (WebCore::Style::TreeResolver::resolve):

            Return Style::Update object if non-empty.

        (WebCore::Style::postResolutionCallbackQueue):
        (WebCore::Style::shouldCreateRenderer): Deleted.
        (WebCore::Style::moveToFlowThreadIfNeeded): Deleted.
        (WebCore::Style::TreeResolver::createRenderer): Deleted.
        (WebCore::Style::TreeResolver::createRenderTreeForChildren): Deleted.
        (WebCore::Style::TreeResolver::createRenderTreeForShadowRoot): Deleted.
        (WebCore::Style::beforeOrAfterPseudoElement): Deleted.
        (WebCore::Style::setBeforeOrAfterPseudoElement): Deleted.
        (WebCore::Style::clearBeforeOrAfterPseudoElement): Deleted.
        (WebCore::Style::needsPseudoElement): Deleted.
        (WebCore::Style::TreeResolver::createRenderTreeForBeforeOrAfterPseudoElement): Deleted.
        (WebCore::Style::TreeResolver::createRenderTreeForSlotAssignees): Deleted.
        (WebCore::Style::TreeResolver::createRenderTreeRecursively): Deleted.
        (WebCore::Style::pseudoStyleCacheIsInvalid): Deleted.
        (WebCore::Style::TreeResolver::resolveBeforeOrAfterPseudoElement): Deleted.

            Remove the recursive render tree building code path.

        * style/StyleTreeResolver.h:
        (WebCore::Style::TreeResolver::scope):
        * style/StyleUpdate.cpp: Added.
        (WebCore::Style::Update::Update):
        (WebCore::Style::Update::elementUpdate):
        (WebCore::Style::Update::textUpdate):
        (WebCore::Style::Update::elementStyle):
        (WebCore::Style::Update::addElement):
        (WebCore::Style::Update::addText):
        (WebCore::Style::Update::addPossibleRoot):
        * style/StyleUpdate.h: Added.
        (WebCore::Style::Update::roots):
        (WebCore::Style::Update::document):
        * svg/SVGElement.h:
        (WebCore::SVGElement::updateRelativeLengthsInformation):
        * svg/SVGUseElement.cpp:
        (WebCore::SVGUseElement::svgAttributeChanged):
        (WebCore::SVGUseElement::willRecalcStyle):
        (WebCore::SVGUseElement::willAttachRenderers): Deleted.

            Switvh willAttachRenderers to willRecalcStyle as the former is now called too late.

        * svg/SVGUseElement.h:

2016-03-31  Youenn Fablet  <youenn.fablet@crf.canon.fr>

        Remove forEach use from Fetch Headers builtin constructor



    style/IdChangeInvalidation.cpp
    style/InlineTextBoxStyle.cpp
    style/RenderTreePosition.cpp
    style/RenderTreeUpdater.cpp
    style/StyleChange.cpp
    style/StyleFontSizeFunctions.cpp
    style/StyleRelations.cpp
    style/StyleResolveForDocument.cpp
    style/StyleSharingResolver.cpp
    style/StyleTreeResolver.cpp
    style/StyleUpdate.cpp

    svg/SVGAElement.cpp
    svg/SVGAltGlyphDefElement.cpp

Lines 335-341 void StyleResolver::sweepMatchedProperti Source/WebCore/css/StyleResolver.cpp_sec1
- Source/WebCore/css/StyleResolver.cpp -3 / +6 lines
335	m_matchedPropertiesCacheAdditionsSinceLastSweep = 0;	335	m_matchedPropertiesCacheAdditionsSinceLastSweep = 0;
336	}	336	}
337		337
338	StyleResolver::State::State(Element& element, RenderStyle* parentStyle, const RenderRegion* regionForStyling, const SelectorFilter* selectorFilter)	338	StyleResolver::State::State(Element& element, RenderStyle* parentStyle, RenderStyle* documentElementStyle, const RenderRegion* regionForStyling, const SelectorFilter* selectorFilter)
339	: m_element(&element)	339	: m_element(&element)
340	, m_parentStyle(parentStyle)	340	, m_parentStyle(parentStyle)
341	, m_regionForStyling(regionForStyling)	341	, m_regionForStyling(regionForStyling)
Lines 348-354 StyleResolver::State::State(Element& ele Source/WebCore/css/StyleResolver.cpp_sec2
348		348
349	auto& document = element.document();	349	auto& document = element.document();
350	auto* documentElement = document.documentElement();	350	auto* documentElement = document.documentElement();
351	m_rootElementStyle = (!documentElement \|\| documentElement == &element) ? document.renderStyle() : documentElement->renderStyle();	351	if (!documentElement \|\| documentElement == &element)
		352	m_rootElementStyle = document.renderStyle();
		353	else
		354	m_rootElementStyle = documentElementStyle ? documentElementStyle : documentElement->renderStyle();
352		355
353	updateConversionData();	356	updateConversionData();
354	}	357	}
Lines 375-381 ElementStyle StyleResolver::styleForElem Source/WebCore/css/StyleResolver.cpp_sec3
375	{	378	{
376	RELEASE_ASSERT(!m_inLoadPendingImages);	379	RELEASE_ASSERT(!m_inLoadPendingImages);
377		380
378	m_state = State(element, parentStyle, regionForStyling, selectorFilter);	381	m_state = State(element, parentStyle, m_overrideDocumentElementStyle.get(), regionForStyling, selectorFilter);
379	State& state = m_state;	382	State& state = m_state;
380		383
381	if (state.parentStyle()) {	384	if (state.parentStyle()) {

Lines 164-169 public: Source/WebCore/css/StyleResolver.h_sec1
- Source/WebCore/css/StyleResolver.h -1 / +5 lines
164		164
165	const MediaQueryEvaluator& mediaQueryEvaluator() const { return *m_medium; }	165	const MediaQueryEvaluator& mediaQueryEvaluator() const { return *m_medium; }
166		166
		167	void setOverrideDocumentElementStyle(RenderStyle* style) { m_overrideDocumentElementStyle = style; }
		168
167	private:	169	private:
168	Ref<RenderStyle> styleForKeyframe(const RenderStyle, const StyleKeyframe, KeyframeValue&);	170	Ref<RenderStyle> styleForKeyframe(const RenderStyle, const StyleKeyframe, KeyframeValue&);
169		171
Lines 359-365 public: Source/WebCore/css/StyleResolver.h_sec2
359	class State {	361	class State {
360	public:	362	public:
361	State() { }	363	State() { }
362	State(Element&, RenderStyle* parentStyle, const RenderRegion* regionForStyling = nullptr, const SelectorFilter* = nullptr);	364	State(Element&, RenderStyle* parentStyle, RenderStyle* documentElementStyle = nullptr, const RenderRegion* regionForStyling = nullptr, const SelectorFilter* = nullptr);
363		365
364	public:	366	public:
365	void clear();	367	void clear();
Lines 524-529 private: Source/WebCore/css/StyleResolver.h_sec3
524		526
525	bool m_matchAuthorAndUserStyles;	527	bool m_matchAuthorAndUserStyles;
526		528
		529	RefPtr<RenderStyle> m_overrideDocumentElementStyle;
		530
527	Vector<std::unique_ptr<MediaQueryResult>> m_viewportDependentMediaQueryResults;	531	Vector<std::unique_ptr<MediaQueryResult>> m_viewportDependentMediaQueryResults;
528		532
529	#if ENABLE(CSS_DEVICE_ADAPTATION)	533	#if ENABLE(CSS_DEVICE_ADAPTATION)



#include "ProcessingInstruction.h"
#include "RenderChildIterator.h"
#include "RenderLayerCompositor.h"
#include "RenderTreeUpdater.h"
#include "RenderView.h"
#include "RenderWidget.h"
#include "ResourceLoadObserver.h"

        }

        Style::TreeResolver resolver(*this);
        auto styleUpdate = resolver.resolve(change);

        updatedCompositingLayers = frameView.updateCompositingLayersAfterStyleChange();

        clearNeedsStyleRecalc();
        clearChildNeedsStyleRecalc();
        unscheduleStyleRecalc();

        m_inStyleRecalc = false;

        if (styleUpdate) {
            TemporaryChange<bool> inRenderTreeUpdate(m_inRenderTreeUpdate, true);

            RenderTreeUpdater updater(*this);
            updater.commit(WTFMove(styleUpdate));
        }

        updatedCompositingLayers = frameView.updateCompositingLayersAfterStyleChange();
    }

    // If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.

    TemporaryChange<bool> change(m_ignorePendingStylesheets, true);
    auto elementStyle = element.resolveStyle(parentStyle);

    if (elementStyle.relations) {
        Style::Update emptyUpdate(*this);
        Style::commitRelations(WTFMove(elementStyle.relations), emptyUpdate);
    }

    return WTFMove(elementStyle.renderStyle);
}



    void setNeedsNotifyRemoveAllPendingStylesheet() { m_needsNotifyRemoveAllPendingStylesheet = true; }
    void clearStyleResolver();

    bool inStyleRecalc() const { return m_inStyleRecalc; }
    bool inRenderTreeUpdate() const { return m_inRenderTreeUpdate; }

    // Return a Locale for the default locale if the argument is null or empty.
    Locale& getCachedLocale(const AtomicString& locale = nullAtom);

    bool m_pendingStyleRecalcShouldForce;
    bool m_inStyleRecalc;
    bool m_closeAfterStyleRecalc;
    bool m_inRenderTreeUpdate { false };

    bool m_gotoAnchorNeededAfterStylesheetsLoad;
    bool m_isDNSPrefetchEnabled;



void Element::setChildIndex(unsigned index)
{
    ElementRareData& rareData = ensureElementRareData();
    if (RenderStyle* style = renderStyle())
        style->setUnique();
    rareData.setChildIndex(index);
}


Lines 772-777 void Node::setNeedsStyleRecalc(StyleChan Source/WebCore/dom/Node.cpp_sec1
- Source/WebCore/dom/Node.cpp +4 lines
772	if (!inRenderedDocument())	772	if (!inRenderedDocument())
773	return;	773	return;
774		774
		775	// FIXME: This should eventually be an ASSERT.
		776	if (document().inRenderTreeUpdate())
		777	return;
		778
775	StyleChangeType existingChangeType = styleChangeType();	779	StyleChangeType existingChangeType = styleChangeType();
776	if (changeType > existingChangeType)	780	if (changeType > existingChangeType)
777	setStyleChange(changeType);	781	setStyleChange(changeType);



    bool isBodyRenderer = isBody();
    bool isDocElementRenderer = isDocumentElementRenderer();

    // Set the text color if we're the body.
    if (isBodyRenderer)
        document().setTextColor(newStyle.visitedDependentColor(CSSPropertyColor));

    if (isDocElementRenderer || isBodyRenderer) {
        // Propagate the new writing mode and direction up to the RenderView.
        auto* documentElementRenderer = document().documentElement()->renderer();



    // continue even if the style isn't different from the current style.
    void setStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);

    // Called to update a style that is allowed to trigger animations.
    void setAnimatableStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference);

    // The pseudo element style can be cached or uncached.  Use the cached method if the pseudo element doesn't respect
    // any pseudo classes (and therefore has no concept of changing state).
    RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = nullptr) const;

    static bool s_noLongerAffectsParentBlock;
};

inline void RenderElement::setAnimatableStyle(Ref<RenderStyle>&& style, StyleDifference minimalStyleDifference)
{
    Ref<RenderStyle> animatedStyle = WTFMove(style);
    if (animation().updateAnimations(*this, animatedStyle, animatedStyle))
        minimalStyleDifference = std::max(minimalStyleDifference, StyleDifferenceRecompositeLayer);
    
    setStyle(WTFMove(animatedStyle), minimalStyleDifference);
}

inline void RenderElement::setAncestorLineBoxDirty(bool f)
{
    m_ancestorLineBoxDirty = f;

Lines 27-32 Source/WebCore/style/RenderTreePosition.cpp_sec1
- Source/WebCore/style/RenderTreePosition.cpp -5 / +15 lines
27	#include "RenderTreePosition.h"	27	#include "RenderTreePosition.h"
28		28
29	#include "ComposedTreeIterator.h"	29	#include "ComposedTreeIterator.h"
		30	#include "HTMLSlotElement.h"
30	#include "PseudoElement.h"	31	#include "PseudoElement.h"
31	#include "RenderObject.h"	32	#include "RenderObject.h"
32	#include "ShadowRoot.h"	33	#include "ShadowRoot.h"
Lines 82-94 RenderObject* RenderTreePosition::nextSi Source/WebCore/style/RenderTreePosition.cpp_sec2
82	if (node.isAfterPseudoElement())	83	if (node.isAfterPseudoElement())
83	return nullptr;	84	return nullptr;
84		85
85	auto composedChildren = composedTreeChildren(*parentElement);	86	auto composedDescendants = composedTreeDescendants(*parentElement);
86		87	auto it = node.isBeforePseudoElement() ? composedDescendants.begin() : composedDescendants.at(node);
87	auto it = node.isBeforePseudoElement() ? composedChildren.begin() : composedChildren.at(node);	88	auto end = composedDescendants.end();
88	for (auto end = composedChildren.end(); it != end; ++it) {	89
89	RenderObject* renderer = it->renderer();	90	while (it != end) {
		91	auto& node = *it;
		92	bool hasDisplayContents = is<HTMLSlotElement>(node);
		93	if (hasDisplayContents) {
		94	it.traverseNext();
		95	continue;
		96	}
		97	RenderObject* renderer = node.renderer();
90	if (renderer && !isRendererReparented(*renderer))	98	if (renderer && !isRendererReparented(*renderer))
91	return renderer;	99	return renderer;
		100
		101	it.traverseNextSkippingChildren();
92	}	102	}
93	if (PseudoElement* after = parentElement->afterPseudoElement())	103	if (PseudoElement* after = parentElement->afterPseudoElement())
94	return after->renderer();	104	return after->renderer();



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "RenderTreeUpdater.h"

#include "AXObjectCache.h"
#include "ComposedTreeAncestorIterator.h"
#include "ComposedTreeIterator.h"
#include "Document.h"
#include "Element.h"
#include "FlowThreadController.h"
#include "HTMLSlotElement.h"
#include "InspectorInstrumentation.h"
#include "PseudoElement.h"
#include "RenderFullScreen.h"
#include "RenderNamedFlowThread.h"
#include "StyleResolver.h"
#include "StyleTreeResolver.h"

namespace WebCore {

RenderTreeUpdater::Parent::Parent(ContainerNode& root)
    : element(is<Document>(root) ? nullptr : downcast<Element>(&root))
    , renderTreePosition(RenderTreePosition(*root.renderer()))
{
}

RenderTreeUpdater::Parent::Parent(Element& element, Style::Change styleChange)
    : element(&element)
    , styleChange(styleChange)
    , renderTreePosition(element.renderer() ? makeOptional(RenderTreePosition(*element.renderer())) : Nullopt)
{
}


RenderTreeUpdater::RenderTreeUpdater(Document& document)
    : m_document(document)
{
}

// Slots have implicit display:contents until it is supported for reals.
static bool hasDisplayContents(const Node& node)
{
    return is<HTMLSlotElement>(node);
}

static ContainerNode& findRenderingRoot(ContainerNode& node)
{
    auto& document = node.document();
    for (ComposedTreeAncestorIterator it(document, node), end(document); it != end; ++it) {
        if (it->renderer())
            return *it;
        ASSERT(hasDisplayContents(*it));
    }
    ASSERT_NOT_REACHED();
    return document;
}

void RenderTreeUpdater::commit(std::unique_ptr<const Style::Update> styleUpdate)
{
    ASSERT(&m_document == &styleUpdate->document());

    if (!m_document.shouldCreateRenderers())
        return;

    m_styleUpdate = WTFMove(styleUpdate);

    for (auto* root : m_styleUpdate->roots())
        updateRenderTree(findRenderingRoot(*root));

    m_styleUpdate = nullptr;
}

static bool shouldCreateRenderer(const Element& element, const RenderElement& parentRenderer)
{
    if (!parentRenderer.canHaveChildren() && !(element.isPseudoElement() && parentRenderer.canHaveGeneratedChildren()))
        return false;
    if (parentRenderer.element() && !parentRenderer.element()->childShouldCreateRenderer(element))
        return false;
    return true;
}

void RenderTreeUpdater::updateRenderTree(ContainerNode& root)
{
    ASSERT(root.renderer());
    ASSERT(m_parentStack.isEmpty());

    m_parentStack.append(Parent(root));

    auto descendants = composedTreeDescendants(root);
    auto it = descendants.begin();
    auto end = descendants.end();

    // FIXME: SVG <use> element may cause tree mutations during style recalc.
    it.dropAssertions();

    while (it != end) {
        popParentsToDepth(it.depth());

        auto& node = *it;

        if (auto* renderer = node.renderer())
            renderTreePosition().invalidateNextSibling(*renderer);

        if (is<Text>(node)) {
            auto& text = downcast<Text>(node);
            if (parent().styleChange == Style::Detach || m_styleUpdate->textUpdate(text) || m_invalidatedWhitespaceOnlyTextSiblings.contains(&text))
                updateTextRenderer(text);

            it.traverseNextSkippingChildren();
            continue;
        }

        auto& element = downcast<Element>(node);

        auto* elementUpdate = m_styleUpdate->elementUpdate(element);

        auto changeType = Style::NoChange;
        if (elementUpdate) {
            if (hasDisplayContents(element)) {
                if (!shouldCreateRenderer(element, renderTreePosition().parent())) {
                    it.traverseNextSkippingChildren();
                    continue;
                }
                pushParent(element, parent().styleChange);
                it.traverseNext();
                continue;
            }

            updateElementRenderer(element, *elementUpdate);
            changeType = elementUpdate->change;
        }

        if (!element.renderer() || !elementUpdate) {
            it.traverseNextSkippingChildren();
            continue;
        }

        pushParent(element, changeType);

        it.traverseNext();
    }

    popParentsToDepth(0);

    m_invalidatedWhitespaceOnlyTextSiblings.clear();
}

RenderTreePosition& RenderTreeUpdater::renderTreePosition()
{
    for (unsigned i = m_parentStack.size(); i; --i) {
        if (auto& position = m_parentStack[i - 1].renderTreePosition)
            return *position;
    }
    ASSERT_NOT_REACHED();
    return *m_parentStack.last().renderTreePosition;
}

void RenderTreeUpdater::pushParent(Element& element, Style::Change changeType)
{
    m_parentStack.append(Parent(element, changeType));

    updateBeforeOrAfterPseudoElement(element, BEFORE);
}

void RenderTreeUpdater::popParent()
{
    auto& parent = m_parentStack.last();

    if (parent.element) {
        updateBeforeOrAfterPseudoElement(*parent.element, AFTER);

        if (parent.element->hasCustomStyleResolveCallbacks() && parent.styleChange == Style::Detach && parent.element->renderer())
            parent.element->didAttachRenderers();
    }
    m_parentStack.removeLast();
}

void RenderTreeUpdater::popParentsToDepth(unsigned depth)
{
    ASSERT(m_parentStack.size() >= depth);

    while (m_parentStack.size() > depth)
        popParent();
}

static bool pseudoStyleCacheIsInvalid(RenderElement* renderer, RenderStyle* newStyle)
{
    const RenderStyle& currentStyle = renderer->style();

    const PseudoStyleCache* pseudoStyleCache = currentStyle.cachedPseudoStyles();
    if (!pseudoStyleCache)
        return false;

    for (auto& cache : *pseudoStyleCache) {
        RefPtr<RenderStyle> newPseudoStyle;
        PseudoId pseudoId = cache->styleType();
        if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
            newPseudoStyle = renderer->uncachedFirstLineStyle(newStyle);
        else
            newPseudoStyle = renderer->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
        if (!newPseudoStyle)
            return true;
        if (*newPseudoStyle != *cache) {
            if (pseudoId < FIRST_INTERNAL_PSEUDOID)
                newStyle->setHasPseudoStyle(pseudoId);
            newStyle->addCachedPseudoStyle(newPseudoStyle);
            if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
                // FIXME: We should do an actual diff to determine whether a repaint vs. layout
                // is needed, but for now just assume a layout will be required. The diff code
                // in RenderObject::setStyle would need to be factored out so that it could be reused.
                renderer->setNeedsLayoutAndPrefWidthsRecalc();
            }
            return true;
        }
    }
    return false;
}

void RenderTreeUpdater::updateElementRenderer(Element& element, const Style::ElementUpdate& update)
{
    bool shouldTearDownRenderers = update.change == Style::Detach && (element.renderer() || element.isNamedFlowContentNode());
    if (shouldTearDownRenderers)
        detachRenderTree(element, Style::ReattachDetach);

    bool shouldCreateNewRenderer = !element.renderer() && update.style;
    if (shouldCreateNewRenderer) {
        if (element.hasCustomStyleResolveCallbacks())
            element.willAttachRenderers();
        createRenderer(element, *update.style);
        invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(element);
        return;
    }

    if (!element.renderer())
        return;
    auto& renderer = *element.renderer();

    if (update.isSynthetic) {
        renderer.setStyle(*update.style, StyleDifferenceRecompositeLayer);
        return;
    }

    if (update.change == Style::NoChange) {
        if (pseudoStyleCacheIsInvalid(&renderer, update.style.get()) || (parent().styleChange == Style::Force && renderer.requiresForcedStyleRecalcPropagation())) {
            renderer.setStyle(*update.style, StyleDifferenceEqual);
            return;
        }
        return;
    }

    renderer.setStyle(*update.style, StyleDifferenceEqual);
}

#if ENABLE(CSS_REGIONS)
static RenderNamedFlowThread* moveToFlowThreadIfNeeded(Element& element, const RenderStyle& style)
{
    if (!element.shouldMoveToFlowThread(style))
        return nullptr;

    FlowThreadController& flowThreadController = element.document().renderView()->flowThreadController();
    RenderNamedFlowThread& parentFlowRenderer = flowThreadController.ensureRenderFlowThreadWithName(style.flowThread());
    flowThreadController.registerNamedFlowContentElement(element, parentFlowRenderer);
    return &parentFlowRenderer;
}
#endif

void RenderTreeUpdater::createRenderer(Element& element, RenderStyle& style)
{
    if (!shouldCreateRenderer(element, renderTreePosition().parent()))
        return;

    RenderNamedFlowThread* parentFlowRenderer = nullptr;
#if ENABLE(CSS_REGIONS)
    parentFlowRenderer = moveToFlowThreadIfNeeded(element, style);
#endif

    if (!element.rendererIsNeeded(style))
        return;

    renderTreePosition().computeNextSibling(element);

    RenderTreePosition insertionPosition = parentFlowRenderer
        ? RenderTreePosition(*parentFlowRenderer, parentFlowRenderer->nextRendererForElement(element))
        : renderTreePosition();

    RenderElement* newRenderer = element.createElementRenderer(style, insertionPosition).leakPtr();
    if (!newRenderer)
        return;
    if (!insertionPosition.canInsert(*newRenderer)) {
        newRenderer->destroy();
        return;
    }

    // Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
    // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
    newRenderer->setFlowThreadState(insertionPosition.parent().flowThreadState());

    element.setRenderer(newRenderer);

    Ref<RenderStyle> animatedStyle = newRenderer->style();
    newRenderer->animation().updateAnimations(*newRenderer, animatedStyle, animatedStyle);
    newRenderer->setStyleInternal(WTFMove(animatedStyle));

    newRenderer->initializeStyle();

#if ENABLE(FULLSCREEN_API)
    if (m_document.webkitIsFullScreen() && m_document.webkitCurrentFullScreenElement() == &element) {
        newRenderer = RenderFullScreen::wrapRenderer(newRenderer, &insertionPosition.parent(), m_document);
        if (!newRenderer)
            return;
    }
#endif
    // Note: Adding newRenderer instead of renderer(). renderer() may be a child of newRenderer.
    insertionPosition.insert(*newRenderer);

    if (AXObjectCache* cache = m_document.axObjectCache())
        cache->updateCacheAfterNodeIsAttached(&element);
}

static bool textRendererIsNeeded(const Text& textNode, const RenderTreePosition& renderTreePosition)
{
    const RenderElement& parentRenderer = renderTreePosition.parent();
    if (!parentRenderer.canHaveChildren())
        return false;
    if (parentRenderer.element() && !parentRenderer.element()->childShouldCreateRenderer(textNode))
        return false;
    if (textNode.isEditingText())
        return true;
    if (!textNode.length())
        return false;
    if (!textNode.containsOnlyWhitespace())
        return true;
    // This text node has nothing but white space. We may still need a renderer in some cases.
    if (parentRenderer.isTable() || parentRenderer.isTableRow() || parentRenderer.isTableSection() || parentRenderer.isRenderTableCol() || parentRenderer.isFrameSet())
        return false;
    if (parentRenderer.style().preserveNewline()) // pre/pre-wrap/pre-line always make renderers.
        return true;

    RenderObject* previousRenderer = renderTreePosition.previousSiblingRenderer(textNode);
    if (previousRenderer && previousRenderer->isBR()) // <span><br/> <br/></span>
        return false;

    if (parentRenderer.isRenderInline()) {
        // <span><div/> <div/></span>
        if (previousRenderer && !previousRenderer->isInline())
            return false;
    } else {
        if (parentRenderer.isRenderBlock() && !parentRenderer.childrenInline() && (!previousRenderer || !previousRenderer->isInline()))
            return false;
        
        RenderObject* first = parentRenderer.firstChild();
        while (first && first->isFloatingOrOutOfFlowPositioned())
            first = first->nextSibling();
        RenderObject* nextRenderer = renderTreePosition.nextSiblingRenderer(textNode);
        if (!first || nextRenderer == first) {
            // Whitespace at the start of a block just goes away. Don't even make a render object for this text.
            return false;
        }
    }
    return true;
}

static void createTextRenderer(Text& textNode, RenderTreePosition& renderTreePosition)
{
    ASSERT(!textNode.renderer());

    auto newRenderer = textNode.createTextRenderer(renderTreePosition.parent().style());
    ASSERT(newRenderer);

    renderTreePosition.computeNextSibling(textNode);

    if (!renderTreePosition.canInsert(*newRenderer))
        return;

    // Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
    // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
    newRenderer->setFlowThreadState(renderTreePosition.parent().flowThreadState());

    textNode.setRenderer(newRenderer.get());
    renderTreePosition.insert(*newRenderer.leakPtr());
}

void RenderTreeUpdater::updateTextRenderer(Text& text)
{
    bool hasRenderer = text.renderer();
    bool needsRenderer = textRendererIsNeeded(text, renderTreePosition());
    if (hasRenderer) {
        if (needsRenderer)
            return;
        Style::detachTextRenderer(text);
        invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(text);
        return;
    }
    if (!needsRenderer)
        return;
    createTextRenderer(text, renderTreePosition());
    invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(text);
}

void RenderTreeUpdater::invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(Node& current)
{
    // FIXME: This needs to traverse in composed tree order.

    // This function finds sibling text renderers where the results of textRendererIsNeeded may have changed as a result of
    // the current node gaining or losing the renderer. This can only affect white space text nodes.
    for (Node* sibling = current.nextSibling(); sibling; sibling = sibling->nextSibling()) {
        if (is<Element>(*sibling)) {
            if (m_styleUpdate->elementUpdate(downcast<Element>(*sibling)))
                return;
            // Text renderers beyond rendered elements can't be affected.
            if (!sibling->renderer() || RenderTreePosition::isRendererReparented(*sibling->renderer()))
                continue;
            return;
        }
        if (!is<Text>(*sibling))
            continue;
        Text& textSibling = downcast<Text>(*sibling);
        if (m_styleUpdate->textUpdate(textSibling))
            return;
        if (!textSibling.containsOnlyWhitespace())
            continue;
        m_invalidatedWhitespaceOnlyTextSiblings.add(&textSibling);
    }
}

static bool needsPseudoElement(Element& current, PseudoId pseudoId)
{
    if (!current.renderer() || !current.renderer()->canHaveGeneratedChildren())
        return false;
    if (current.isPseudoElement())
        return false;
    if (!pseudoElementRendererIsNeeded(current.renderer()->getCachedPseudoStyle(pseudoId)))
        return false;
    return true;
}

void RenderTreeUpdater::updateBeforeOrAfterPseudoElement(Element& current, PseudoId pseudoId)
{
    PseudoElement* pseudoElement = pseudoId == BEFORE ? current.beforePseudoElement() : current.afterPseudoElement();

    auto* renderer = pseudoElement ? pseudoElement->renderer() : nullptr;
    if (renderer)
        renderTreePosition().invalidateNextSibling(*renderer);

    bool needsPseudoElement = WebCore::needsPseudoElement(current, pseudoId);
    if (!needsPseudoElement) {
        if (pseudoElement) {
            if (pseudoId == BEFORE)
                current.clearBeforePseudoElement();
            else
                current.clearAfterPseudoElement();
        }
        return;
    }

    Style::ElementUpdate elementUpdate;

    Ref<RenderStyle> newStyle = *current.renderer()->getCachedPseudoStyle(pseudoId, &current.renderer()->style());

    if (renderer && m_document.frame()->animation().updateAnimations(*renderer, newStyle, newStyle))
        elementUpdate.isSynthetic = true;

    elementUpdate.change = renderer ? Style::determineChange(renderer->style(), newStyle) : Style::Detach;
    elementUpdate.style = WTFMove(newStyle);

    if (elementUpdate.change == Style::NoChange)
        return;

    if (!pseudoElement) {
        auto newPseudoElement = PseudoElement::create(current, pseudoId);
        pseudoElement = newPseudoElement.ptr();
        InspectorInstrumentation::pseudoElementCreated(m_document.page(), newPseudoElement);
        if (pseudoId == BEFORE)
            current.setBeforePseudoElement(WTFMove(newPseudoElement));
        else
            current.setAfterPseudoElement(WTFMove(newPseudoElement));
    }

    updateElementRenderer(*pseudoElement, elementUpdate);

    if (elementUpdate.change == Style::Detach)
        pseudoElement->didAttachRenderers();
    else
        pseudoElement->didRecalcStyle(elementUpdate.change);
}

}



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef RenderTreeUpdater_h
#define RenderTreeUpdater_h

#include "RenderTreePosition.h"
#include "StyleChange.h"
#include "StyleUpdate.h"
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>

namespace WebCore {

class ContainerNode;
class Document;
class Element;
class Node;
class RenderStyle;
class Text;

class RenderTreeUpdater {
public:
    RenderTreeUpdater(Document&);

    void commit(std::unique_ptr<const Style::Update>);

private:
    void updateRenderTree(ContainerNode& root);
    void updateTextRenderer(Text&);
    void updateElementRenderer(Element&, const Style::ElementUpdate&);
    void createRenderer(Element&, RenderStyle&);
    void invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(Node&);
    void updateBeforeOrAfterPseudoElement(Element&, PseudoId);

    struct Parent {
        Element* element { nullptr };
        Style::Change styleChange { Style::NoChange };
        Optional<RenderTreePosition> renderTreePosition;

        Parent(ContainerNode& root);
        Parent(Element&, Style::Change);
    };
    Parent& parent() { return m_parentStack.last(); }
    RenderTreePosition& renderTreePosition();

    void pushParent(Element&, Style::Change);
    void popParent();
    void popParentsToDepth(unsigned depth);

    Document& m_document;
    std::unique_ptr<const Style::Update> m_styleUpdate;

    Vector<Parent> m_parentStack;

    HashSet<Text*> m_invalidatedWhitespaceOnlyTextSiblings;
};

}
#endif



#include "Element.h"
#include "NodeRenderStyle.h"
#include "RenderStyle.h"
#include "StyleUpdate.h"

namespace WebCore {
namespace Style {

    return remainingRelations;
}

void commitRelations(std::unique_ptr<Relations> relations, Update& update)
{
    if (!relations)
        return;

            element.setChildrenAffectedByLastChildRules();
            break;
        case Relation::FirstChild:
            if (auto* style = update.elementStyle(element))
                style->setFirstChildState();
            break;
        case Relation::LastChild:
            if (auto* style = update.elementStyle(element))
                style->setLastChildState();
            break;
        case Relation::NthChildIndex:
            if (auto* style = update.elementStyle(element))
                style->setUnique();
            element.setChildIndex(relation.value);
            break;
        case Relation::Unique:
            if (auto* style = update.elementStyle(element))
                style->setUnique();
            break;
        }

Lines 35-40 class RenderStyle; Source/WebCore/style/StyleRelations.h_sec1
- Source/WebCore/style/StyleRelations.h -1 / +3 lines
35		35
36	namespace Style {	36	namespace Style {
37		37
		38	class Update;
		39
38	struct Relation {	40	struct Relation {
39	enum Type {	41	enum Type {
40	AffectedByActive,	42	AffectedByActive,
Lines 66-72 struct Relation { Source/WebCore/style/StyleRelations.h_sec2
66	using Relations = Vector<Relation, 8>;	68	using Relations = Vector<Relation, 8>;
67		69
68	std::unique_ptr<Relations> commitRelationsToRenderStyle(RenderStyle&, const Element&, const Relations&);	70	std::unique_ptr<Relations> commitRelationsToRenderStyle(RenderStyle&, const Element&, const Relations&);
69	void commitRelationsToDocument(std::unique_ptr<Relations>);	71	void commitRelations(std::unique_ptr<Relations>, Update&);
70		72
71	}	73	}
72	}	74	}



#include "NodeRenderStyle.h"
#include "RenderStyle.h"
#include "SVGElement.h"
#include "StyleUpdate.h"
#include "StyledElement.h"
#include "VisitedLinkState.h"
#include "WebVTTElement.h"

static const unsigned cStyleSearchThreshold = 10;

struct SharingResolver::Context {
    const Update& update;
    const StyledElement& element;
    bool elementAffectedByClassRules;
    EInsideLink elementLinkState;

    return is<HTMLElement>(element) && downcast<HTMLElement>(element).hasDirectionAuto();
}

RefPtr<RenderStyle> SharingResolver::resolve(const Element& searchElement, const Update& update)
{
    if (!is<StyledElement>(searchElement))
        return nullptr;

    auto& parentElement = *element.parentElement();
    if (parentElement.shadowRoot())
        return nullptr;
    if (!update.elementStyle(parentElement))
        return nullptr;
    // If the element has inline style it is probably unique.
    if (element.inlineStyle())

        return nullptr;

    Context context {
        update,
        element,
        element.hasClass() && classNamesAffectedByRules(element.classNames()),
        m_document.visitedLinkState().determineLinkState(element)


    m_elementsSharingStyle.add(&element, shareElement);

    return RenderStyle::clone(update.elementStyle(*shareElement));
}

StyledElement* SharingResolver::findSibling(const Context& context, Node* node, unsigned& count) const

bool SharingResolver::canShareStyleWithElement(const Context& context, const StyledElement& candidateElement) const
{
    auto& element = context.element;
    auto* style = context.update.elementStyle(candidateElement);
    if (!style)
        return false;
    if (style->unique())

Lines 42-52 class StyledElement; Source/WebCore/style/StyleSharingResolver.h_sec1
- Source/WebCore/style/StyleSharingResolver.h -1 / +3 lines
42		42
43	namespace Style {	43	namespace Style {
44		44
		45	class Update;
		46
45	class SharingResolver {	47	class SharingResolver {
46	public:	48	public:
47	SharingResolver(const Document&, const DocumentRuleSets&, const SelectorFilter&);	49	SharingResolver(const Document&, const DocumentRuleSets&, const SelectorFilter&);
48		50
49	RefPtr<RenderStyle> resolve(const Element&);	51	RefPtr<RenderStyle> resolve(const Element&, const Update&);
50		52
51	private:	53	private:
52	struct Context;	54	struct Context;



 *           (C) 2001 Peter Kelly (pmk@post.com)
 *           (C) 2001 Dirk Mueller (mueller@kde.org)
 *           (C) 2007 David Smith (catfish.man@gmail.com)
 * Copyright (C) 2004-2010, 2012-2016 Apple Inc. All rights reserved.
 *           (C) 2007 Eric Seidel (eric@webkit.org)
 *
 * This library is free software; you can redistribute it and/or

#include "config.h"
#include "StyleTreeResolver.h"

#include "AXObjectCache.h"
#include "AnimationController.h"
#include "AuthorStyleSheets.h"
#include "CSSFontSelector.h"
#include "ComposedTreeAncestorIterator.h"
#include "ComposedTreeIterator.h"
#include "ElementIterator.h"
#include "HTMLBodyElement.h"
#include "FlowThreadController.h"
#include "HTMLSlotElement.h"
#include "InspectorInstrumentation.h"
#include "LoaderStrategy.h"
#include "MainFrame.h"
#include "NodeRenderStyle.h"
#include "NodeTraversal.h"
#include "PlatformStrategies.h"
#include "RenderFullScreen.h"
#include "RenderNamedFlowThread.h"
#include "RenderText.h"
#include "RenderTreePosition.h"
#include "RenderWidget.h"
#include "Settings.h"
#include "ShadowRoot.h"
#include "StyleResolver.h"


namespace Style {

enum DetachType { NormalDetach, ReattachDetach };

static void attachTextRenderer(Text&, RenderTreePosition&);
static void detachRenderTree(Element&, DetachType);
static void resolveTextNode(Text&, RenderTreePosition&);

class SelectorFilterPusher {

    ensurePlaceholderStyle(document);
}

TreeResolver::~TreeResolver()
{
}

TreeResolver::Scope::Scope(Document& document)
    : styleResolver(document.ensureStyleResolver())
    , sharingResolver(document, styleResolver.ruleSets(), selectorFilter)

TreeResolver::Parent::Parent(Document& document, Change change)
    : element(nullptr)
    , style(*document.renderStyle())
    , renderTreePosition(*document.renderView())
    , change(change)
{
}

TreeResolver::Parent::Parent(Element& element, ElementUpdate& update)
    : element(&element)
    , style(*update.style)
    , change(update.change)
    , change(change)
{
}


    return m_scopeStack.removeLast();
}

static bool shouldCreateRenderer(const Element& element, const RenderElement& parentRenderer)
{
    if (!element.document().shouldCreateRenderers())
        return false;
    if (!parentRenderer.canHaveChildren() && !(element.isPseudoElement() && parentRenderer.canHaveGeneratedChildren()))
        return false;
    if (parentRenderer.element() && !parentRenderer.element()->childShouldCreateRenderer(element))
        return false;
    return true;
}

Ref<RenderStyle> TreeResolver::styleForElement(Element& element, RenderStyle& inheritedStyle)
{
    if (!m_document.haveStylesheetsLoaded() && !element.renderer()) {

        return *placeholderStyle;
    }

    scope().styleResolver.setOverrideDocumentElementStyle(m_documentElementStyle.get());

    if (element.hasCustomStyleResolveCallbacks()) {
        RenderStyle* shadowHostStyle = scope().shadowRoot ? m_update->elementStyle(*scope().shadowRoot->host()) : nullptr;
        if (auto customStyle = element.resolveCustomStyle(inheritedStyle, shadowHostStyle)) {
            if (customStyle->relations)
                commitRelations(WTFMove(customStyle->relations), *m_update);

            return WTFMove(customStyle->renderStyle);
        }
    }

    if (auto style = scope().sharingResolver.resolve(element, *m_update))
        return *style;

    auto elementStyle = scope().styleResolver.styleForElement(element, &inheritedStyle, MatchAllRules, nullptr, &scope().selectorFilter);

    if (elementStyle.relations)
        commitRelations(WTFMove(elementStyle.relations), *m_update);
}

#if ENABLE(CSS_REGIONS)
static RenderNamedFlowThread* moveToFlowThreadIfNeeded(Element& element, const RenderStyle& style)
{
    if (!element.shouldMoveToFlowThread(style))
        return 0;

    FlowThreadController& flowThreadController = element.document().renderView()->flowThreadController();
    RenderNamedFlowThread& parentFlowRenderer = flowThreadController.ensureRenderFlowThreadWithName(style.flowThread());
    flowThreadController.registerNamedFlowContentElement(element, parentFlowRenderer);
    return &parentFlowRenderer;
}
#endif

void TreeResolver::createRenderer(Element& element, RenderTreePosition& renderTreePosition, RefPtr<RenderStyle>&& resolvedStyle)
{
    ASSERT(shouldCreateRenderer(element, renderTreePosition.parent()));
    ASSERT(resolvedStyle);

    RenderNamedFlowThread* parentFlowRenderer = 0;
#if ENABLE(CSS_REGIONS)
    parentFlowRenderer = moveToFlowThreadIfNeeded(element, *resolvedStyle);
#endif

    if (!element.rendererIsNeeded(*resolvedStyle))
        return;

    renderTreePosition.computeNextSibling(element);

    RenderTreePosition insertionPosition = parentFlowRenderer
        ? RenderTreePosition(*parentFlowRenderer, parentFlowRenderer->nextRendererForElement(element))
        : renderTreePosition;

    RenderElement* newRenderer = element.createElementRenderer(resolvedStyle.releaseNonNull(), insertionPosition).leakPtr();
    if (!newRenderer)
        return;
    if (!insertionPosition.canInsert(*newRenderer)) {
        newRenderer->destroy();
        return;
    }

    return WTFMove(elementStyle.renderStyle);
    // for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
    newRenderer->setFlowThreadState(insertionPosition.parent().flowThreadState());

    // Code below updateAnimations() can depend on Element::renderer() already being set.
    element.setRenderer(newRenderer);

    // FIXME: There's probably a better way to factor this.
    // This just does what setAnimatedStyle() does, except with setStyleInternal() instead of setStyle().
    Ref<RenderStyle> animatedStyle = newRenderer->style();
    newRenderer->animation().updateAnimations(*newRenderer, animatedStyle, animatedStyle);
    newRenderer->setStyleInternal(WTFMove(animatedStyle));

    newRenderer->initializeStyle();

#if ENABLE(FULLSCREEN_API)
    if (m_document.webkitIsFullScreen() && m_document.webkitCurrentFullScreenElement() == &element) {
        newRenderer = RenderFullScreen::wrapRenderer(newRenderer, &insertionPosition.parent(), m_document);
        if (!newRenderer)
            return;
    }
#endif
    // Note: Adding newRenderer instead of renderer(). renderer() may be a child of newRenderer.
    insertionPosition.insert(*newRenderer);
}

static void invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(Node& current)

    newRenderer->setFlowThreadState(renderTreePosition.parent().flowThreadState());

    textNode.setRenderer(newRenderer.get());
    // Parent takes care of the animations, no need to call setAnimatableStyle.
    renderTreePosition.insert(*newRenderer.leakPtr());
}


        textNode.renderer()->setTextWithOffset(textNode.data(), offsetOfReplacedData, lengthOfReplacedData);
}

void TreeResolver::createRenderTreeForChildren(ContainerNode& current, RenderStyle& inheritedStyle, RenderTreePosition& renderTreePosition)
{
    for (Node* child = current.firstChild(); child; child = child->nextSibling()) {
        ASSERT((!child->renderer() || child->isNamedFlowContentNode()) || current.shadowRoot());
        if (child->renderer()) {
            renderTreePosition.invalidateNextSibling(*child->renderer());
            continue;
        }
        if (is<Text>(*child)) {
            attachTextRenderer(downcast<Text>(*child), renderTreePosition);
            continue;
        }
        if (is<Element>(*child))
            createRenderTreeRecursively(downcast<Element>(*child), inheritedStyle, renderTreePosition, nullptr);
    }
}

void TreeResolver::createRenderTreeForShadowRoot(ShadowRoot& shadowRoot)
{
    ASSERT(shadowRoot.host());
    ASSERT(shadowRoot.host()->renderer());

    pushScope(shadowRoot);

    auto& renderer = *shadowRoot.host()->renderer();
    RenderTreePosition renderTreePosition(renderer);
    createRenderTreeForChildren(shadowRoot, renderer.style(), renderTreePosition);

    popScope();

    shadowRoot.clearNeedsStyleRecalc();
    shadowRoot.clearChildNeedsStyleRecalc();
}

static PseudoElement* beforeOrAfterPseudoElement(Element& current, PseudoId pseudoId)
{
    ASSERT(pseudoId == BEFORE || pseudoId == AFTER);
    if (pseudoId == BEFORE)
        return current.beforePseudoElement();
    return current.afterPseudoElement();
}

static void setBeforeOrAfterPseudoElement(Element& current, Ref<PseudoElement>&& pseudoElement, PseudoId pseudoId)
{
    ASSERT(pseudoId == BEFORE || pseudoId == AFTER);
    if (pseudoId == BEFORE) {
        current.setBeforePseudoElement(WTFMove(pseudoElement));
        return;
    }
    current.setAfterPseudoElement(WTFMove(pseudoElement));
}

static void clearBeforeOrAfterPseudoElement(Element& current, PseudoId pseudoId)
{
    ASSERT(pseudoId == BEFORE || pseudoId == AFTER);
    if (pseudoId == BEFORE) {
        current.clearBeforePseudoElement();
        return;
    }
    current.clearAfterPseudoElement();
}

static void resetStyleForNonRenderedDescendants(Element& current)
{
    // FIXME: This is not correct with shadow trees. This should be done with ComposedTreeIterator.
    ASSERT(!current.renderer());
    bool elementNeedingStyleRecalcAffectsNextSiblingElementStyle = false;
    for (auto& child : childrenOfType<Element>(current)) {
        ASSERT(!child.renderer());
        bool affectedByPreviousSibling = child.styleIsAffectedByPreviousSibling() && elementNeedingStyleRecalcAffectsNextSiblingElementStyle;
        if (child.needsStyleRecalc() || elementNeedingStyleRecalcAffectsNextSiblingElementStyle)
            elementNeedingStyleRecalcAffectsNextSiblingElementStyle = child.affectsNextSiblingElementStyle();

    }
}

static bool needsPseudoElement(Element& current, PseudoId pseudoId)
{
    if (!current.renderer() || !current.renderer()->canHaveGeneratedChildren())
        return false;
    if (current.isPseudoElement())
        return false;
    if (!pseudoElementRendererIsNeeded(current.renderer()->getCachedPseudoStyle(pseudoId)))
        return false;
    return true;
}

void TreeResolver::createRenderTreeForBeforeOrAfterPseudoElement(Element& current, PseudoId pseudoId, RenderTreePosition& renderTreePosition)
{
    if (!needsPseudoElement(current, pseudoId))
        return;
    Ref<PseudoElement> pseudoElement = PseudoElement::create(current, pseudoId);
    InspectorInstrumentation::pseudoElementCreated(m_document.page(), pseudoElement.get());
    setBeforeOrAfterPseudoElement(current, pseudoElement.copyRef(), pseudoId);
    createRenderTreeRecursively(pseudoElement.get(), *current.renderStyle(), renderTreePosition, nullptr);
}

#if ENABLE(SHADOW_DOM) || ENABLE(DETAILS_ELEMENT)
void TreeResolver::createRenderTreeForSlotAssignees(HTMLSlotElement& slot, RenderStyle& inheritedStyle, RenderTreePosition& renderTreePosition)
{
    ASSERT(shouldCreateRenderer(slot, renderTreePosition.parent()));

    if (auto* assignedNodes = slot.assignedNodes()) {
        pushEnclosingScope();
        for (auto* child : *assignedNodes) {
            if (is<Text>(*child))
                attachTextRenderer(downcast<Text>(*child), renderTreePosition);
            else if (is<Element>(*child))
                createRenderTreeRecursively(downcast<Element>(*child), inheritedStyle, renderTreePosition, nullptr);
        }
        popScope();
    } else {
        SelectorFilterPusher selectorFilterPusher(scope().selectorFilter, slot);
        createRenderTreeForChildren(slot, inheritedStyle, renderTreePosition);
    }

    slot.clearNeedsStyleRecalc();
    slot.clearChildNeedsStyleRecalc();
}
#endif

void TreeResolver::createRenderTreeRecursively(Element& current, RenderStyle& inheritedStyle, RenderTreePosition& renderTreePosition, RefPtr<RenderStyle>&& resolvedStyle)
{
    ASSERT(!current.renderer());

    PostResolutionCallbackDisabler callbackDisabler(m_document);
    WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;

    bool shouldCallCreateRenderer = shouldCreateRenderer(current, renderTreePosition.parent());

    RefPtr<RenderStyle> style = resolvedStyle;
    if (!style)
        style = styleForElement(current, inheritedStyle);

#if ENABLE(SHADOW_DOM) || ENABLE(DETAILS_ELEMENT)
    if (is<HTMLSlotElement>(current)) {
        if (shouldCallCreateRenderer && current.rendererIsNeeded(*style))
            createRenderTreeForSlotAssignees(downcast<HTMLSlotElement>(current), inheritedStyle, renderTreePosition);
        return;
    }
#endif

    if (current.hasCustomStyleResolveCallbacks())
        current.willAttachRenderers();

    if (shouldCallCreateRenderer)
        createRenderer(current, renderTreePosition, style.releaseNonNull());

    if (auto* renderer = current.renderer()) {
        SelectorFilterPusher selectorFilterPusher(scope().selectorFilter, current, SelectorFilterPusher::NoPush);

        RenderTreePosition childRenderTreePosition(*renderer);
        createRenderTreeForBeforeOrAfterPseudoElement(current, BEFORE, childRenderTreePosition);

        auto* shadowRoot = current.shadowRoot();
        if (shadowRoot) {
            selectorFilterPusher.push();
            createRenderTreeForShadowRoot(*shadowRoot);
        } else if (current.firstChild())
            selectorFilterPusher.push();

        bool skipChildren = shadowRoot;
        if (!skipChildren)
            createRenderTreeForChildren(current, renderer->style(), childRenderTreePosition);

        if (AXObjectCache* cache = m_document.axObjectCache())
            cache->updateCacheAfterNodeIsAttached(&current);

        createRenderTreeForBeforeOrAfterPseudoElement(current, AFTER, childRenderTreePosition);

        current.updateFocusAppearanceAfterAttachIfNeeded();
    } else
        resetStyleForNonRenderedDescendants(current);

    current.clearNeedsStyleRecalc();
    current.clearChildNeedsStyleRecalc();

    if (current.hasCustomStyleResolveCallbacks())
        current.didAttachRenderers();
}

static void detachChildren(ContainerNode& current, DetachType detachType)
{
    for (Node* child = current.firstChild(); child; child = child->nextSibling()) {

}
#endif

void detachRenderTree(Element& current, DetachType detachType)
{
    WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;


        current.didDetachRenderers();
}

ElementUpdate TreeResolver::resolveElement(Element& element)
{
    auto newStyle = styleForElement(element, parent().style);

    auto* renderer = element.renderer();
    if (!pseudoStyleCache)
        return false;

    bool affectsRenderedSubtree = renderer || newStyle->display() != NONE || newStyle->hasFlowInto();
    if (!affectsRenderedSubtree)
        return { };
        if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
            newPseudoStyle = renderer->uncachedFirstLineStyle(newStyle);
        else
            newPseudoStyle = renderer->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
        if (!newPseudoStyle)
            return true;
        if (*newPseudoStyle != *cache) {
            if (pseudoId < FIRST_INTERNAL_PSEUDOID)
                newStyle->setHasPseudoStyle(pseudoId);
            newStyle->addCachedPseudoStyle(newPseudoStyle);
            if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
                // FIXME: We should do an actual diff to determine whether a repaint vs. layout
                // is needed, but for now just assume a layout will be required. The diff code
                // in RenderObject::setStyle would need to be factored out so that it could be reused.
                renderer->setNeedsLayoutAndPrefWidthsRecalc();
            }
            return true;
        }
    }
    return false;
}

    ElementUpdate update;
{
    Change localChange = Detach;
    RefPtr<RenderStyle> newStyle;
    RefPtr<RenderStyle> currentStyle = current.renderStyle();

    bool needsNewRenderer = !renderer || element.styleChangeType() == ReconstructRenderTree || parent().change == Detach;
    if (!needsNewRenderer && m_document.frame()->animation().updateAnimations(*renderer, newStyle, newStyle))
        update.isSynthetic = true;
        localChange = determineChange(*currentStyle, style);
    }
    if (localChange == Detach) {
        if (current.renderer() || current.isNamedFlowContentNode())
            detachRenderTree(current, ReattachDetach);
#if ENABLE(SHADOW_DOM) || ENABLE(DETAILS_ELEMENT)
        else if (is<HTMLSlotElement>(current))
            detachRenderTree(current, ReattachDetach);
#endif
        createRenderTreeRecursively(current, parent().style, parent().renderTreePosition, newStyle.release());
        invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(current);

    update.change = needsNewRenderer ? Detach : determineChange(renderer->style(), newStyle);
    update.style = WTFMove(newStyle);

    if (element.styleChangeType() == SyntheticStyleChange)
        update.isSynthetic = true;

    if (&element == m_document.documentElement()) {
        m_documentElementStyle = update.style;

        // If "rem" units are used anywhere in the document, and if the document element's font size changes, then force font updating
        // all the way down the tree. This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
        if (m_document.authorStyleSheets().usesRemUnits() && update.change != NoChange && renderer && renderer->style().fontSize() != update.style->fontSize()) {
            // Cached RenderStyles may depend on the rem units.
            scope().styleResolver.invalidateMatchedPropertiesCache();
            update.change = Force;
        }
    }
    if (parent().change == Force || current.styleChangeType() >= FullStyleChange)
        return Force;

    // This is needed for resolving color:-webkit-text for subsequent elements.
    // FIXME: We shouldn't mutate document when resolving style.
    if (&element == m_document.body())
        m_document.setTextColor(update.style->visitedDependentColor(CSSPropertyColor));

    if (update.change != Detach && (parent().change == Force || element.styleChangeType() >= FullStyleChange))
        update.change = Force;

    return update;
}

void resolveTextNode(Text& text, RenderTreePosition& renderTreePosition)

    invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(text);
}

void TreeResolver::resolveBeforeOrAfterPseudoElement(Element& current, Change change, PseudoId pseudoId, RenderTreePosition& renderTreePosition)
{
    if (!current.renderer())
        return;
    PseudoElement* existingPseudoElement = beforeOrAfterPseudoElement(current, pseudoId);
    if (!existingPseudoElement) {
        createRenderTreeForBeforeOrAfterPseudoElement(current, pseudoId, renderTreePosition);
        return;
    }

    if (existingPseudoElement->renderer())
        renderTreePosition.invalidateNextSibling(*existingPseudoElement->renderer());

    if (change == NoChange && !existingPseudoElement->needsStyleRecalc())
        return;

    if (needsPseudoElement(current, pseudoId)) {
        auto change = resolveElement(*existingPseudoElement);
        existingPseudoElement->didRecalcStyle(change);
        existingPseudoElement->clearNeedsStyleRecalc();
    } else
        clearBeforeOrAfterPseudoElement(current, pseudoId);
}

#if PLATFORM(IOS)
static EVisibility elementImplicitVisibility(const Element* element)
{

};
#endif // PLATFORM(IOS)

void TreeResolver::pushParent(Element& element, ElementUpdate& update)
{
    scope().selectorFilter.pushParent(&element);

    Parent parent(element, update);

    if (auto* shadowRoot = element.shadowRoot()) {
        pushScope(*shadowRoot);

#endif

    m_parentStack.append(WTFMove(parent));

    resolveBeforeOrAfterPseudoElement(element, change, BEFORE, renderTreePosition);
}

void TreeResolver::popParent()
{
    auto& parentElement = *parent().element;

    resolveBeforeOrAfterPseudoElement(parentElement, parent().change, AFTER, parent().renderTreePosition);

    parentElement.clearNeedsStyleRecalc();
    parentElement.clearChildNeedsStyleRecalc();


        popParent();
}

static bool shouldResolvePseudoElement(PseudoElement* pseudoElement)
{
    if (!pseudoElement)
        return false;
    bool needsStyleRecalc = pseudoElement->needsStyleRecalc();
    pseudoElement->clearNeedsStyleRecalc();
    return needsStyleRecalc;
}

void TreeResolver::resolveComposedTree()
{
    ASSERT(m_parentStack.size() == 1);

        ASSERT(node.containingShadowRoot() == scope().shadowRoot);
        ASSERT(node.parentElement() == parent.element || is<ShadowRoot>(node.parentNode()) || node.parentElement()->shadowRoot());

        if (auto* existingRenderer = node.renderer())
            parent.renderTreePosition.invalidateNextSibling(*existingRenderer);

        if (is<Text>(node)) {
            auto& text = downcast<Text>(node);
            if (text.styleChangeType() == ReconstructRenderTree && parent.change != Detach)
                m_update->addText(text, parent.element);

            text.clearNeedsStyleRecalc();
            it.traverseNextSkippingChildren();
            continue;
        }

        if (element.needsStyleRecalc() || parent.elementNeedingStyleRecalcAffectsNextSiblingElementStyle)
            parent.elementNeedingStyleRecalcAffectsNextSiblingElementStyle = element.affectsNextSiblingElementStyle();

        bool shouldResolveForPseudoElement = shouldResolvePseudoElement(element.beforePseudoElement()) || shouldResolvePseudoElement(element.afterPseudoElement());

        ElementUpdate update;
        update.style = element.renderStyle();

        bool shouldResolve = parent.change >= Inherit || element.needsStyleRecalc() || shouldResolveForPseudoElement || affectedByPreviousSibling;
        if (shouldResolve) {
#if PLATFORM(IOS)
            CheckForVisibilityChangeOnRecalcStyle checkForVisibilityChange(&element, element.renderStyle());

                    continue;
                }
            }
            change = resolveElement(element);

            update = resolveElement(element);

            if (element.hasCustomStyleResolveCallbacks())
                element.didRecalcStyle(update.change);

            if (affectedByPreviousSibling && update.change != Detach)
                update.change = Force;

            if (update.style)
                m_update->addElement(element, parent.element, update);

            element.clearNeedsStyleRecalc();
                change = Force;
        }


#if ENABLE(SHADOW_DOM) || ENABLE(DETAILS_ELEMENT)
        if (is<HTMLSlotElement>(element)) {
            // FIXME: We should compute style for the slot and use it as parent style.
            // Duplicate the style from the parent context.
            ElementUpdate slotUpdate;
            slotUpdate.style = parent.style.ptr();
            slotUpdate.change = update.change;
            if (!shouldResolve)
                m_update->addElement(element, parent.element, update);
            pushParent(element, slotUpdate);
            it.traverseNext();
            continue;
        }
#endif
        if (!update.style) {
        if (!renderer) {
            resetStyleForNonRenderedDescendants(element);
            element.clearChildNeedsStyleRecalc();
        }

        bool shouldIterateChildren = update.style && (element.childNeedsStyleRecalc() || update.change != NoChange);
        if (!shouldIterateChildren) {
            it.traverseNextSkippingChildren();
            continue;
        }

        pushParent(element, update);

        it.traverseNext();
    }

    popParentsToDepth(1);
}

std::unique_ptr<const Update> TreeResolver::resolve(Change change)
{
    auto& renderView = *m_document.renderView();

    Element* documentElement = m_document.documentElement();
    if (!documentElement)
        return nullptr;
    if (change != Force && !documentElement->childNeedsStyleRecalc() && !documentElement->needsStyleRecalc())
        return nullptr;

    m_update = std::make_unique<Update>(m_document);
    m_scopeStack.append(adoptRef(*new Scope(m_document)));
    m_parentStack.append(Parent(m_document, change));

    // Pseudo element removal and similar may only work with these flags still set. Reset them after the style recalc.
    renderView.setUsesFirstLineRules(renderView.usesFirstLineRules() || scope().styleResolver.usesFirstLineRules());
    renderView.setUsesFirstLetterRules(renderView.usesFirstLetterRules() || scope().styleResolver.usesFirstLetterRules());

    m_parentStack.append(Parent(m_document, change));

    resolveComposedTree();

    renderView.setUsesFirstLineRules(scope().styleResolver.usesFirstLineRules());


    m_parentStack.clear();
    m_scopeStack.clear();
}

    if (m_update->roots().isEmpty())
        return { };

    return WTFMove(m_update);
}

static Vector<std::function<void ()>>& postResolutionCallbackQueue()



#include "SelectorFilter.h"
#include "StyleChange.h"
#include "StyleSharingResolver.h"
#include "StyleUpdate.h"
#include <functional>
#include <wtf/HashMap.h>
#include <wtf/RefPtr.h>

namespace WebCore {

class ShadowRoot;
class StyleResolver;
class Text;
class TreeChange;

namespace Style {

class TreeResolver {
public:
    TreeResolver(Document&);
    ~TreeResolver();

    std::unique_ptr<const Update> resolve(Change);

private:
    Ref<RenderStyle> styleForElement(Element&, RenderStyle& inheritedStyle);

    void resolveComposedTree();
    ElementUpdate resolveElement(Element&);
    void resolveBeforeOrAfterPseudoElement(Element&, Change, PseudoId, RenderTreePosition&);


    void createRenderTreeRecursively(Element&, RenderStyle&, RenderTreePosition&, RefPtr<RenderStyle>&& resolvedStyle);
    void createRenderer(Element&, RenderTreePosition&, RefPtr<RenderStyle>&& resolvedStyle);
    void createRenderTreeForBeforeOrAfterPseudoElement(Element&, PseudoId, RenderTreePosition&);
    void createRenderTreeForChildren(ContainerNode&, RenderStyle&, RenderTreePosition&);
    void createRenderTreeForShadowRoot(ShadowRoot&);

#if ENABLE(SHADOW_DOM) || ENABLE(DETAILS_ELEMENT)
    void createRenderTreeForSlotAssignees(HTMLSlotElement&, RenderStyle& inheritedStyle, RenderTreePosition&);
#endif

    struct Scope : RefCounted<Scope> {
        StyleResolver& styleResolver;

    struct Parent {
        Element* element;
        Ref<RenderStyle> style;
        RenderTreePosition renderTreePosition;
        Change change;
        bool didPushScope { false };
        bool elementNeedingStyleRecalcAffectsNextSiblingElementStyle { false };

        Parent(Document&, Change);
        Parent(Element&, ElementUpdate&);
    };

    Scope& scope() { return m_scopeStack.last(); }

    void pushEnclosingScope();
    void popScope();

    void pushParent(Element&, ElementUpdate&);
    void popParent();
    void popParentsToDepth(unsigned depth);

    Document& m_document;
    RefPtr<RenderStyle> m_documentElementStyle;

    Vector<Ref<Scope>, 4> m_scopeStack;
    Vector<Parent, 32> m_parentStack;

    std::unique_ptr<Update> m_update;
};

enum DetachType { NormalDetach, ReattachDetach };
void detachRenderTree(Element&, DetachType = NormalDetach);
void detachTextRenderer(Text&);

void updateTextRendererAfterContentChange(Text&, unsigned offsetOfReplacedData, unsigned lengthOfReplacedData);



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "StyleUpdate.h"

#include "ComposedTreeAncestorIterator.h"
#include "Document.h"
#include "Element.h"
#include "NodeRenderStyle.h"
#include "Text.h"

namespace WebCore {
namespace Style {

Update::Update(Document& document)
    : m_document(document)
{
}

const ElementUpdate* Update::elementUpdate(const Element& element) const
{
    auto it = m_elements.find(&element);
    if (it == m_elements.end())
        return nullptr;
    return &it->value;
}

bool Update::textUpdate(const Text& text) const
{
    return m_texts.contains(&text);
}

RenderStyle* Update::elementStyle(const Element& element) const
{
    if (auto* update = elementUpdate(element))
        return update->style.get();
    return element.renderStyle();
}

void Update::addElement(Element& element, Element* parent, ElementUpdate& change)
{
    ASSERT(!m_elements.contains(&element));
    ASSERT(!parent || composedTreeAncestors(element).first() == parent);

    addPossibleRoot(parent);
    m_elements.add(&element, change);
}

void Update::addText(Text& text, Element* parent)
{
    ASSERT(!m_texts.contains(&text));
    ASSERT(!parent || composedTreeAncestors(text).first() == parent);

    addPossibleRoot(parent);
    m_texts.add(&text);
}

void Update::addPossibleRoot(Element* element)
{
    if (!element) {
        m_roots.add(&m_document);
        return;
    }
    if (m_elements.contains(element))
        return;
    m_roots.add(element);
}

}
}



/*
 * Copyright (C) 2016 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef StyleUpdate_h
#define StyleUpdate_h

#include "Node.h"
#include "StyleChange.h"
#include "StyleRelations.h"
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/RefPtr.h>

namespace WebCore {

class ContainerNode;
class Document;
class Element;
class Node;
class RenderStyle;
class Text;

namespace Style {

struct ElementUpdate {
    RefPtr<RenderStyle> style;
    Change change { NoChange };
    bool isSynthetic { false };
};

class Update {
public:
    Update(Document&);

    const ListHashSet<ContainerNode*>& roots() const { return m_roots; }

    const ElementUpdate* elementUpdate(const Element&) const;
    bool textUpdate(const Text&) const;

    RenderStyle* elementStyle(const Element&) const;

    const Document& document() const { return m_document; }

    void addElement(Element&, Element* parent, ElementUpdate&);
    void addText(Text&, Element* parent);

private:
    void addPossibleRoot(Element*);

    Document& m_document;
    ListHashSet<ContainerNode*> m_roots;
    HashMap<const Element*, ElementUpdate> m_elements;
    HashSet<const Text*> m_texts;
};

}
}
#endif

Lines 183-193 protected: Source/WebCore/svg/SVGElement.h_sec1
- Source/WebCore/svg/SVGElement.h -1 / +2 lines
183	void updateRelativeLengthsInformation() { updateRelativeLengthsInformation(selfHasRelativeLengths(), this); }	183	void updateRelativeLengthsInformation() { updateRelativeLengthsInformation(selfHasRelativeLengths(), this); }
184	void updateRelativeLengthsInformation(bool hasRelativeLengths, SVGElement*);	184	void updateRelativeLengthsInformation(bool hasRelativeLengths, SVGElement*);
185		185
		186	bool willRecalcStyle(Style::Change) override;
		187
186	class InstanceInvalidationGuard;	188	class InstanceInvalidationGuard;
187		189
188	private:	190	private:
189	RenderStyle* computedStyle(PseudoId = NOPSEUDO) final;	191	RenderStyle* computedStyle(PseudoId = NOPSEUDO) final;
190	bool willRecalcStyle(Style::Change) override;
191		192
192	virtual bool isSupported(StringImpl* feature, StringImpl* version) const;	193	virtual bool isSupported(StringImpl* feature, StringImpl* version) const;
193		194



    SVGGraphicsElement::svgAttributeChanged(attrName);
}

bool SVGUseElement::willRecalcStyle(Style::Change change)
{
    // FIXME: Shadow tree should be updated before style recalc.
    if (m_shadowTreeNeedsUpdate)
        updateShadowTree();
    return SVGGraphicsElement::willRecalcStyle(change);
}

static HashSet<AtomicString> createAllowedElementSet()

Lines 63-69 private: Source/WebCore/svg/SVGUseElement.h_sec1
- Source/WebCore/svg/SVGUseElement.h -1 / +1 lines
63	void buildPendingResource() override;	63	void buildPendingResource() override;
64	void parseAttribute(const QualifiedName&, const AtomicString&) override;	64	void parseAttribute(const QualifiedName&, const AtomicString&) override;
65	void svgAttributeChanged(const QualifiedName&) override;	65	void svgAttributeChanged(const QualifiedName&) override;
66	void willAttachRenderers() override;	66	bool willRecalcStyle(Style::Change) override;
67	RenderPtr<RenderElement> createElementRenderer(Ref<RenderStyle>&&, const RenderTreePosition&) override;	67	RenderPtr<RenderElement> createElementRenderer(Ref<RenderStyle>&&, const RenderTreePosition&) override;
68	void toClipPath(Path&) override;	68	void toClipPath(Path&) override;
69	bool haveLoadedRequiredResources() override;	69	bool haveLoadedRequiredResources() override;



2016-03-31  Antti Koivisto  <antti@apple.com>

        Separate render tree updating from style resolve
        https://bugs.webkit.org/show_bug.cgi?id=155298

        Reviewed by Andreas Kling.

        * TestExpectations:

            Skip mathml/presentation/menclose-notation-attribute-change-value.html. It will be fixed by upcoming MathML refactoring.

        * css3/blending/repaint/blend-mode-isolate-stacking-context-expected.txt:
        * css3/viewport-percentage-lengths/viewport-percentage-lengths-resize-expected.txt:

            This is a progression.

        * editing/mac/spelling/autocorrection-contraction-expected.txt:
        * editing/mac/spelling/autocorrection-removing-underline-after-paste-expected.txt:
        * editing/mac/spelling/autocorrection-removing-underline-expected.txt:
        * editing/mac/spelling/autocorrection-simple-expected.txt:
        * editing/style/remove-underline-from-stylesheet-expected.txt:
        * editing/style/typing-style-003-expected.txt:

            Non-rendered whitespace related changes.

        * platform/ios-simulator/TestExpectations:

            Skip fast/regions/position-writing-modes-in-variable-width-regions.html on iOS. Similar tests are mostly already skipped.

        * platform/ios-simulator/editing/style/typing-style-003-expected.txt: Added.
        * platform/mac-wk2/editing/mac/spelling/autocorrection-contraction-expected.txt:
        * platform/mac/editing/inserting/editable-html-element-expected.txt:
        * platform/mac/editing/inserting/editing-empty-divs-expected.txt:
        * platform/mac/editing/inserting/insert-at-end-02-expected.txt:
        * platform/mac/editing/pasteboard/4989774-expected.txt:
        * platform/mac/editing/selection/4983858-expected.txt:

            Non-rendered whitespace related changes.

2016-03-31  Youenn Fablet  <youenn.fablet@crf.canon.fr>

        Remove forEach use from Fetch Headers builtin constructor

Lines 990-995 webkit.org/b/154686 inspector/indexeddb/ LayoutTests/TestExpectations_sec1
- LayoutTests/TestExpectations +3 lines
990	storage/indexeddb/modern/exceed-open-file-limit.html [ Skip ]	990	storage/indexeddb/modern/exceed-open-file-limit.html [ Skip ]
991	webkit.org/b/155028 storage/indexeddb/modern/256-open-databases.html [ Skip ]	991	webkit.org/b/155028 storage/indexeddb/modern/256-open-databases.html [ Skip ]
992		992
		993	# Fixed by upcoming MathML refactoring
		994	webkit.org/b/155019 mathml/presentation/menclose-notation-attribute-change-value.html [ Skip ]
		995
993	### END OF IndexedDB failures	996	### END OF IndexedDB failures
994	########################################	997	########################################
995		998

Lines 21-30 Test if unsetting a parent's stacking co LayoutTests/css3/blending/repaint/blend-mode-isolate-stacking-context-expected.txt_sec1
- LayoutTests/css3/blending/repaint/blend-mode-isolate-stacking-context-expected.txt -2 / +2 lines
21	(rect 48 290 60 60)	21	(rect 48 290 60 60)
22	(rect 28 290 60 60)	22	(rect 28 290 60 60)
23	(rect 48 290 60 60)	23	(rect 48 290 60 60)
24	(rect 48 408 60 60)
25	(rect 48 408 60 60)
26	(rect 28 526 60 60)	24	(rect 28 526 60 60)
27	(rect 48 526 60 60)	25	(rect 48 526 60 60)
		26	(rect 48 408 60 60)
		27	(rect 48 408 60 60)
28	(rect 48 644 60 60)	28	(rect 48 644 60 60)
29	(rect 68 644 60 60)	29	(rect 68 644 60 60)
30	(rect 48 644 60 60)	30	(rect 48 644 60 60)



PASS getComputedStyle(test).fontSize is "30px"
PASS getComputedStyle(test).width is "450px"
PASS getComputedStyle(testpseudo, ':after').marginLeft is "120px"
PASS getComputedStyle(testpseudo, ':after').paddingRight is "225px"
PASS innerWidth is 900
PASS innerHeight is 640
PASS getComputedStyle(test).fontSize is "32px"
PASS getComputedStyle(test).width is "450px"
PASS getComputedStyle(testpseudo, ':after').marginLeft is "128px"
PASS getComputedStyle(testpseudo, ':after').paddingRight is "225px"
PASS innerWidth is 500
PASS innerHeight is 640
PASS getComputedStyle(test).fontSize is "32px"
PASS getComputedStyle(test).width is "250px"
PASS getComputedStyle(testpseudo, ':after').marginLeft is "100px"
PASS getComputedStyle(testpseudo, ':after').paddingRight is "160px"
PASS innerWidth is 800
PASS innerHeight is 600
PASS getComputedStyle(test).fontSize is "30px"

Lines 279-282 layer at (0,0) size 800x600 LayoutTests/editing/mac/spelling/autocorrection-contraction-expected.txt_sec1
- LayoutTests/editing/mac/spelling/autocorrection-contraction-expected.txt -1 / +1 lines
279	RenderText {#text} at (0,0) size 160x28	279	RenderText {#text} at (0,0) size 160x28
280	text run at (0,0) width 154: "would' wouldn't"	280	text run at (0,0) width 154: "would' wouldn't"
281	text run at (153,0) width 7: " "	281	text run at (153,0) width 7: " "
282	caret: position 16 of child 0 {#text} of child 5 {DIV} of child 3 {DIV} of body	282	caret: position 16 of child 0 {#text} of child 6 {DIV} of child 3 {DIV} of body

Lines 82-85 layer at (0,0) size 800x600 LayoutTests/editing/mac/spelling/autocorrection-removing-underline-after-paste-expected.txt_sec1
- LayoutTests/editing/mac/spelling/autocorrection-removing-underline-after-paste-expected.txt -1 / +1 lines
82	text run at (0,28) width 34: "baz"	82	text run at (0,28) width 34: "baz"
83	RenderBlock {DIV} at (14,70) size 756x28	83	RenderBlock {DIV} at (14,70) size 756x28
84	RenderBR {BR} at (0,0) size 0x28	84	RenderBR {BR} at (0,0) size 0x28
85	caret: position 0 of child 0 {BR} of child 4 {DIV} of child 5 {DIV} of body	85	caret: position 0 of child 0 {BR} of child 5 {DIV} of child 5 {DIV} of body

Lines 78-81 layer at (0,0) size 800x600 LayoutTests/editing/mac/spelling/autocorrection-removing-underline-expected.txt_sec1
- LayoutTests/editing/mac/spelling/autocorrection-removing-underline-expected.txt -1 / +1 lines
78	RenderInline {SPAN} at (0,0) size 1x28	78	RenderInline {SPAN} at (0,0) size 1x28
79	RenderBlock {DIV} at (14,42) size 756x28	79	RenderBlock {DIV} at (14,42) size 756x28
80	RenderBR {BR} at (0,0) size 0x28	80	RenderBR {BR} at (0,0) size 0x28
81	caret: position 0 of child 0 {BR} of child 2 {DIV} of child 5 {DIV} of body	81	caret: position 0 of child 0 {BR} of child 3 {DIV} of child 5 {DIV} of body

Lines 137-140 layer at (0,0) size 800x600 LayoutTests/editing/mac/spelling/autocorrection-simple-expected.txt_sec1
- LayoutTests/editing/mac/spelling/autocorrection-simple-expected.txt -1 / +1 lines
137	RenderBlock {DIV} at (14,42) size 756x28	137	RenderBlock {DIV} at (14,42) size 756x28
138	RenderText {#text} at (0,0) size 138x28	138	RenderText {#text} at (0,0) size 138x28
139	text run at (0,0) width 138: "the notational,"	139	text run at (0,0) width 138: "the notational,"
140	caret: position 15 of child 0 {#text} of child 2 {DIV} of child 7 {DIV} of body	140	caret: position 15 of child 0 {#text} of child 3 {DIV} of child 7 {DIV} of body

Lines 76-80 This tests removing underline from style LayoutTests/editing/style/remove-underline-from-stylesheet-expected.txt_sec1
- LayoutTests/editing/style/remove-underline-from-stylesheet-expected.txt +2 lines
76	\| "xxxxxx "	76	\| "xxxxxx "
77	\| "<#selection-anchor>xxxxxx<#selection-focus>"	77	\| "<#selection-anchor>xxxxxx<#selection-focus>"
78	\| " xxxxxx"	78	\| " xxxxxx"
		79	\| "
		80	"
79	\| <span>	81	\| <span>
80	\| id="test"	82	\| id="test"



EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
xxxxxxxxxxxxxxx
execTypeCharacterCommand: x <span id="test"></span>
execTypeCharacterCommand: xx <span id="test"></span>
execTypeCharacterCommand: xxx <span id="test"></span>
execBoldCommand: xxx <span id="test"></span>
execTypeCharacterCommand: xxx<b>x</b> <span id="test"></span>
execTypeCharacterCommand: xxx<b>xx</b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><span id="test"></span>
execItalicCommand: xxx<b>xxx</b><span id="test"></span>

Lines 1-3 LayoutTests/fast/dom/beforeload/remove-bad-object-in-beforeload-listener-expected.txt_sec1
- LayoutTests/fast/dom/beforeload/remove-bad-object-in-beforeload-listener-expected.txt +1 lines
1	This page tests that you can correctly remove an object element with an invalid data URL in its beforeload listener without causing a crash.	1	This page tests that you can correctly remove an object element with an invalid data URL in its beforeload listener without causing a crash.
2		2
3	PASS	3	PASS
		4

Lines 1-3 LayoutTests/fast/regions/br-content-node-crash-expected.txt_sec1
- LayoutTests/fast/regions/br-content-node-crash-expected.txt -1 lines
1	Test that moving a br element to a named flow does not crash when the br element should not have a renderer created.	1	Test that moving a br element to a named flow does not crash when the br element should not have a renderer created.
2	To manually test, move the mouse to the upper left corner of the document and try to make a selection to the bottom of the document. It should not crash.	2	To manually test, move the mouse to the upper left corner of the document and try to make a selection to the bottom of the document. It should not crash.
3

Lines 2043-2048 fast/regions/percentage-margins-mixed-lt LayoutTests/platform/ios-simulator/TestExpectations_sec1
- LayoutTests/platform/ios-simulator/TestExpectations +1 lines
2043	fast/regions/percentage-margins-mixed-rtl-dominant-regions.html [ ImageOnlyFailure ]	2043	fast/regions/percentage-margins-mixed-rtl-dominant-regions.html [ ImageOnlyFailure ]
2044	fast/regions/percentage-margins-rtl-variable-width-regions.html [ ImageOnlyFailure ]	2044	fast/regions/percentage-margins-rtl-variable-width-regions.html [ ImageOnlyFailure ]
2045	fast/regions/percentage-margins-variable-width-regions.html [ ImageOnlyFailure ]	2045	fast/regions/percentage-margins-variable-width-regions.html [ ImageOnlyFailure ]
		2046	fast/regions/position-writing-modes-in-variable-width-regions.html [ ImageOnlyFailure ]
2046	fast/regions/positioning/fixed-in-named-flow-position-changed.html [ ImageOnlyFailure ]	2047	fast/regions/positioning/fixed-in-named-flow-position-changed.html [ ImageOnlyFailure ]
2047	fast/regions/positioning/fixed-inside-fixed-in-named-flow.html [ ImageOnlyFailure ]	2048	fast/regions/positioning/fixed-inside-fixed-in-named-flow.html [ ImageOnlyFailure ]
2048	fast/regions/positioning/fixed-inside-named-flow-zIndex.html [ ImageOnlyFailure ]	2049	fast/regions/positioning/fixed-inside-named-flow-zIndex.html [ ImageOnlyFailure ]



EDITING DELEGATE: shouldBeginEditingInDOMRange:range from 0 of DIV > BODY > HTML > #document to 3 of DIV > BODY > HTML > #document
EDITING DELEGATE: webViewDidBeginEditing:WebViewDidBeginEditingNotification
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 0 of DIV > BODY > HTML > #document to 0 of DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > DIV > BODY > HTML > #document to 3 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > B > DIV > BODY > HTML > #document to 1 of #text > B > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > B > DIV > BODY > HTML > #document to 1 of #text > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > B > DIV > BODY > HTML > #document to 1 of #text > B > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > B > DIV > BODY > HTML > #document to 2 of #text > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > B > DIV > BODY > HTML > #document to 2 of #text > B > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > B > DIV > BODY > HTML > #document to 3 of #text > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > B > DIV > BODY > HTML > #document to 1 of #text > I > B > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > I > B > DIV > BODY > HTML > #document to 1 of #text > I > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > B > DIV > BODY > HTML > #document to 1 of #text > I > B > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > I > B > DIV > BODY > HTML > #document to 2 of #text > I > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > I > B > DIV > BODY > HTML > #document to 2 of #text > I > B > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > I > B > DIV > BODY > HTML > #document to 3 of #text > I > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > DIV > BODY > HTML > #document to 1 of #text > I > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > I > DIV > BODY > HTML > #document to 1 of #text > I > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > DIV > BODY > HTML > #document to 1 of #text > I > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > I > DIV > BODY > HTML > #document to 2 of #text > I > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > I > DIV > BODY > HTML > #document to 2 of #text > I > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > I > DIV > BODY > HTML > #document to 3 of #text > I > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > DIV > BODY > HTML > #document to 3 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
xxxxxxxxxxxxxxx
execTypeCharacterCommand: x <span id="test"></span>
execTypeCharacterCommand: xx<span id="test"></span>
execTypeCharacterCommand: xxx<span id="test"></span>
execBoldCommand: xxx<span id="test"></span>
execTypeCharacterCommand: xxx<b>x</b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xx</b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><span id="test"></span>
execItalicCommand: xxx<b>xxx</b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx<i>x</i></b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx<i>xx</i></b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx<i>xxx</i></b><span id="test"></span>
execBoldCommand: xxx<b>xxx<i>xxx</i></b><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>x</i><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xx</i><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i><span id="test"></span>
execItalicCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i><span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i>x<span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i>xx<span id="test"></span>
execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i>xxx<span id="test"></span>

Lines 259-262 layer at (0,0) size 800x600 LayoutTests/platform/mac-wk2/editing/mac/spelling/autocorrection-contraction-expected.txt_sec1
- LayoutTests/platform/mac-wk2/editing/mac/spelling/autocorrection-contraction-expected.txt -1 / +1 lines
259	RenderText {#text} at (0,0) size 172x28	259	RenderText {#text} at (0,0) size 172x28
260	text run at (0,0) width 166: "wouldn' wouldn't"	260	text run at (0,0) width 166: "wouldn' wouldn't"
261	text run at (165,0) width 7: " "	261	text run at (165,0) width 7: " "
262	caret: position 17 of child 0 {#text} of child 5 {DIV} of child 3 {DIV} of body	262	caret: position 17 of child 0 {#text} of child 6 {DIV} of child 3 {DIV} of body

Lines 22-28 layer at (0,0) size 800x600 LayoutTests/platform/mac/editing/inserting/editable-html-element-expected.txt_sec1
- LayoutTests/platform/mac/editing/inserting/editable-html-element-expected.txt -1 lines
22	text run at (0,18) width 767: "inserting a paragraph separator doesn't split the body (inserting a paragraph separator usually splits/clones the enclosing"	22	text run at (0,18) width 767: "inserting a paragraph separator doesn't split the body (inserting a paragraph separator usually splits/clones the enclosing"
23	text run at (766,18) width 5: " "	23	text run at (766,18) width 5: " "
24	text run at (0,36) width 132: "block flow element)."	24	text run at (0,36) width 132: "block flow element)."
25	RenderText {#text} at (0,0) size 0x0
26	RenderBlock {DIV} at (0,54) size 784x18	25	RenderBlock {DIV} at (0,54) size 784x18
27	RenderBR {BR} at (0,0) size 0x18	26	RenderBR {BR} at (0,0) size 0x18
28	caret: position 0 of child 0 {BR} of child 2 {DIV} of body	27	caret: position 0 of child 0 {BR} of child 2 {DIV} of body



      RenderBlock {DIV} at (0,230) size 708x22 [border: (1px dotted #0000FF)]
        RenderText {#text} at (1,1) size 8x18
          text run at (1,1) width 8: "c"
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,268) size 784x18
        RenderText {#text} at (0,0) size 240x18
          text run at (0,0) width 240: "This div contains a self-closing p tag."

        RenderBlock (anonymous) at (1,1) size 706x18
          RenderText {#text} at (0,0) size 8x18
            text run at (0,0) width 8: "c"
          RenderText {#text} at (0,0) size 0x0
        RenderBlock {P} at (1,35) size 706x0
caret: position 1 of child 0 {#text} of child 21 {DIV} of body

Lines 29-33 layer at (0,0) size 800x600 LayoutTests/platform/mac/editing/inserting/insert-at-end-02-expected.txt_sec1
- LayoutTests/platform/mac/editing/inserting/insert-at-end-02-expected.txt -1 lines
29	RenderBlock (anonymous) at (2,46) size 780x18	29	RenderBlock (anonymous) at (2,46) size 780x18
30	RenderText {#text} at (0,0) size 8x18	30	RenderText {#text} at (0,0) size 8x18
31	text run at (0,0) width 8: "x"	31	text run at (0,0) width 8: "x"
32	RenderText {#text} at (0,0) size 0x0
33	caret: position 1 of child 5 {#text} of child 5 {DIV} of body	32	caret: position 1 of child 5 {#text} of child 5 {DIV} of body

Lines 12-17 layer at (0,0) size 800x600 LayoutTests/platform/mac/editing/pasteboard/4989774-expected.txt_sec1
- LayoutTests/platform/mac/editing/pasteboard/4989774-expected.txt -2 lines
12	text run at (634,103) width 102: "You should see"	12	text run at (634,103) width 102: "You should see"
13	text run at (735,103) width 5: " "	13	text run at (735,103) width 5: " "
14	text run at (0,121) width 364: "several pictures above all in the same line/paragraph."	14	text run at (0,121) width 364: "several pictures above all in the same line/paragraph."
15	RenderText {#text} at (0,0) size 0x0
16	RenderText {#text} at (0,0) size 0x0
17	caret: position 164 of child 4 {#text} of body	15	caret: position 164 of child 4 {#text} of body

Lines 10-16 layer at (0,0) size 800x600 LayoutTests/platform/mac/editing/selection/4983858-expected.txt_sec1
- LayoutTests/platform/mac/editing/selection/4983858-expected.txt -1 lines
10	text run at (716,0) width 65: "paragraph"	10	text run at (716,0) width 65: "paragraph"
11	text run at (780,0) width 4: " "	11	text run at (780,0) width 4: " "
12	text run at (0,18) width 165: "below should be selected:"	12	text run at (0,18) width 165: "below should be selected:"
13	RenderText {#text} at (0,0) size 0x0
14	RenderBlock {DIV} at (0,36) size 784x18	13	RenderBlock {DIV} at (0,36) size 784x18
15	RenderText {#text} at (0,0) size 22x18	14	RenderText {#text} at (0,0) size 22x18
16	text run at (0,0) width 22: "foo"	15	text run at (0,0) width 22: "foo"

Return to Bug 155298

Lines 2626-2637 set(WebCore_SOURCES Source/WebCore/CMakeLists.txt_sec1
- Source/WebCore/CMakeLists.txt +2 lines
2626	style/IdChangeInvalidation.cpp	2626	style/IdChangeInvalidation.cpp
2627	style/InlineTextBoxStyle.cpp	2627	style/InlineTextBoxStyle.cpp
2628	style/RenderTreePosition.cpp	2628	style/RenderTreePosition.cpp
		2629	style/RenderTreeUpdater.cpp
2629	style/StyleChange.cpp	2630	style/StyleChange.cpp
2630	style/StyleFontSizeFunctions.cpp	2631	style/StyleFontSizeFunctions.cpp
2631	style/StyleRelations.cpp	2632	style/StyleRelations.cpp
2632	style/StyleResolveForDocument.cpp	2633	style/StyleResolveForDocument.cpp
2633	style/StyleSharingResolver.cpp	2634	style/StyleSharingResolver.cpp
2634	style/StyleTreeResolver.cpp	2635	style/StyleTreeResolver.cpp
		2636	style/StyleUpdate.cpp
2635		2637
2636	svg/SVGAElement.cpp	2638	svg/SVGAElement.cpp
2637	svg/SVGAltGlyphDefElement.cpp	2639	svg/SVGAltGlyphDefElement.cpp

Lines 133-138 Source/WebCore/dom/Document.cpp_sec1
- Source/WebCore/dom/Document.cpp -4 / +15 lines
133	#include "ProcessingInstruction.h"	133	#include "ProcessingInstruction.h"
134	#include "RenderChildIterator.h"	134	#include "RenderChildIterator.h"
135	#include "RenderLayerCompositor.h"	135	#include "RenderLayerCompositor.h"
		136	#include "RenderTreeUpdater.h"
136	#include "RenderView.h"	137	#include "RenderView.h"
137	#include "RenderWidget.h"	138	#include "RenderWidget.h"
138	#include "ResourceLoadObserver.h"	139	#include "ResourceLoadObserver.h"
Lines 1926-1940 void Document::recalcStyle(Style::Change Source/WebCore/dom/Document.cpp_sec2
1926	}	1927	}
1927		1928
1928	Style::TreeResolver resolver(*this);	1929	Style::TreeResolver resolver(*this);
1929	resolver.resolve(change);	1930	auto styleUpdate = resolver.resolve(change);
1930
1931	updatedCompositingLayers = frameView.updateCompositingLayersAfterStyleChange();
1932		1931
1933	clearNeedsStyleRecalc();	1932	clearNeedsStyleRecalc();
1934	clearChildNeedsStyleRecalc();	1933	clearChildNeedsStyleRecalc();
1935	unscheduleStyleRecalc();	1934	unscheduleStyleRecalc();
1936		1935
1937	m_inStyleRecalc = false;	1936	m_inStyleRecalc = false;
		1937
		1938	if (styleUpdate) {
		1939	TemporaryChange<bool> inRenderTreeUpdate(m_inRenderTreeUpdate, true);
		1940
		1941	RenderTreeUpdater updater(*this);
		1942	updater.commit(WTFMove(styleUpdate));
		1943	}
		1944
		1945	updatedCompositingLayers = frameView.updateCompositingLayersAfterStyleChange();
1938	}	1946	}
1939		1947
1940	// If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.	1948	// If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.
Lines 2052-2058 Ref<RenderStyle> Document::styleForEleme Source/WebCore/dom/Document.cpp_sec3
2052	TemporaryChange<bool> change(m_ignorePendingStylesheets, true);	2060	TemporaryChange<bool> change(m_ignorePendingStylesheets, true);
2053	auto elementStyle = element.resolveStyle(parentStyle);	2061	auto elementStyle = element.resolveStyle(parentStyle);
2054		2062
2055	Style::commitRelationsToDocument(WTFMove(elementStyle.relations));	2063	if (elementStyle.relations) {
		2064	Style::Update emptyUpdate(*this);
		2065	Style::commitRelations(WTFMove(elementStyle.relations), emptyUpdate);
		2066	}
2056		2067
2057	return WTFMove(elementStyle.renderStyle);	2068	return WTFMove(elementStyle.renderStyle);
2058	}	2069	}

Lines 1244-1250 public: Source/WebCore/dom/Document.h_sec1
- Source/WebCore/dom/Document.h -1 / +3 lines
1244	void setNeedsNotifyRemoveAllPendingStylesheet() { m_needsNotifyRemoveAllPendingStylesheet = true; }	1244	void setNeedsNotifyRemoveAllPendingStylesheet() { m_needsNotifyRemoveAllPendingStylesheet = true; }
1245	void clearStyleResolver();	1245	void clearStyleResolver();
1246		1246
1247	bool inStyleRecalc() { return m_inStyleRecalc; }	1247	bool inStyleRecalc() const { return m_inStyleRecalc; }
		1248	bool inRenderTreeUpdate() const { return m_inRenderTreeUpdate; }
1248		1249
1249	// Return a Locale for the default locale if the argument is null or empty.	1250	// Return a Locale for the default locale if the argument is null or empty.
1250	Locale& getCachedLocale(const AtomicString& locale = nullAtom);	1251	Locale& getCachedLocale(const AtomicString& locale = nullAtom);
Lines 1508-1513 private: Source/WebCore/dom/Document.h_sec2
1508	bool m_pendingStyleRecalcShouldForce;	1509	bool m_pendingStyleRecalcShouldForce;
1509	bool m_inStyleRecalc;	1510	bool m_inStyleRecalc;
1510	bool m_closeAfterStyleRecalc;	1511	bool m_closeAfterStyleRecalc;
		1512	bool m_inRenderTreeUpdate { false };
1511		1513
1512	bool m_gotoAnchorNeededAfterStylesheetsLoad;	1514	bool m_gotoAnchorNeededAfterStylesheetsLoad;
1513	bool m_isDNSPrefetchEnabled;	1515	bool m_isDNSPrefetchEnabled;

Lines 2564-2571 void Element::setChildrenAffectedByPrope Source/WebCore/dom/Element.cpp_sec1
- Source/WebCore/dom/Element.cpp -2 lines
2564	void Element::setChildIndex(unsigned index)	2564	void Element::setChildIndex(unsigned index)
2565	{	2565	{
2566	ElementRareData& rareData = ensureElementRareData();	2566	ElementRareData& rareData = ensureElementRareData();
2567	if (RenderStyle* style = renderStyle())
2568	style->setUnique();
2569	rareData.setChildIndex(index);	2567	rareData.setChildIndex(index);
2570	}	2568	}
2571		2569

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +215 lines
		1	2016-03-31 Antti Koivisto <antti@apple.com>
		2
		3	Separate render tree updating from style resolve
		4	https://bugs.webkit.org/show_bug.cgi?id=155298
		5
		6	Reviewed by Andreas Kling.
		7
		8	This patch splits computing document style and applying the results into two distinct steps:
		9
		10	Style::TreeResolver::resolve()
		11	\|
		12	\| Style::Update
		13	V
		14	RenderTreeUpdater::commit()
		15
		16	Style::TreeResolver::resolve() returns a Style::Update object that contains all the changes to be made
		17	for the whole composed tree. RenderTreeUpdater then applies the changes updating, building or tearing
		18	down portions of the render tree as needed.
		19
		20	Style::Update consists of a map that contains new style for each newly resolved element along with some
		21	metadata. A separate map contains text nodes that require reconstruction. It also tracks change roots so
		22	RenderTreeUpdater needs to traverse the changed subtrees only.
		23
		24	The patch eliminates the recursive render tree build code path replacing it with iterative functions.
		25
		26	This will enable future optimizations. For example we won't need to commit to immediate rendering
		27	changes simply because some script or internal function requires up-to-date style.
		28
		29	* CMakeLists.txt:
		30	* WebCore.xcodeproj/project.pbxproj:
		31	* css/StyleResolver.cpp:
		32	(WebCore::StyleResolver::State::State):
		33	(WebCore::StyleResolver::styleForElement):
		34	* css/StyleResolver.h:
		35	(WebCore::StyleResolver::setOverrideDocumentElementStyle):
		36	(WebCore::StyleResolver::State::State):
		37
		38	Root element style is needed for resolving other elements. Add a way to provide it without looking
		39	into active document style.
		40
		41	* dom/Document.cpp:
		42	(WebCore::Document::recalcStyle):
		43
		44	Resolve the document style and commit it immediately (for now).
		45
		46	(WebCore::Document::styleForElementIgnoringPendingStylesheets):
		47	* dom/Document.h:
		48	(WebCore::Document::setNeedsNotifyRemoveAllPendingStylesheet):
		49	(WebCore::Document::inStyleRecalc):
		50	(WebCore::Document::inRenderTreeUpdate):
		51	* dom/Element.cpp:
		52	(WebCore::Element::setChildIndex):
		53
		54	Setting the unique bit is now done by style relations update code.
		55
		56	* dom/Node.cpp:
		57	(WebCore::Node::setNeedsStyleRecalc):
		58
		59	Prevent spurious style invalidation during render tree updating.
		60
		61	* rendering/RenderBox.cpp:
		62	(WebCore::RenderBox::styleDidChange):
		63
		64	Capturing body element color for color:-webkit-text is now done by TreeResolver.
65
66	* rendering/RenderElement.h:
67	(WebCore::RenderElement::setAnimatableStyle): Deleted.
68
69	No longer used.
70
71	* style/RenderTreePosition.cpp:
72	(WebCore::RenderTreePosition::nextSiblingRenderer):
73
74	Skip over non-rendered slot elements.
75
76	* style/RenderTreeUpdater.cpp: Added.
77	(WebCore::RenderTreeUpdater::Parent::Parent):
78	(WebCore::RenderTreeUpdater::RenderTreeUpdater):
79	(WebCore::hasDisplayContents):
80	(WebCore::findRenderingRoot):
81	(WebCore::RenderTreeUpdater::commit):
82
83	Call updateRenderTree for each change root.
84
85	(WebCore::shouldCreateRenderer):
86	(WebCore::RenderTreeUpdater::updateRenderTree):
87
88	Iteratively traverse the composed tree starting for a change root.
89	Apply the changes calling updateElementRenderer and updateTextRenderer as needed.
90	Enter subtrees that haves changes to apply.
91
92	(WebCore::RenderTreeUpdater::renderTreePosition):
93
94	We may not create renderers for all elements (<slot> or more generally display:contents) that
95	have rendered descendants. Search the parent stack to find the valid position.
96
97	(WebCore::RenderTreeUpdater::pushParent):
98	(WebCore::RenderTreeUpdater::popParent):
99	(WebCore::RenderTreeUpdater::popParentsToDepth):
100
101	Maintain parent stack.
102
103	(WebCore::pseudoStyleCacheIsInvalid):
104	(WebCore::RenderTreeUpdater::updateElementRenderer):
105
106	Create, delete or update the renderer.
107
108	(WebCore::moveToFlowThreadIfNeeded):
109	(WebCore::RenderTreeUpdater::createRenderer):
110	(WebCore::textRendererIsNeeded):
111	(WebCore::createTextRenderer):
112	(WebCore::RenderTreeUpdater::updateTextRenderer):
113	(WebCore::RenderTreeUpdater::invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded):
114
115	This is moved from TreeResolver.
116
117	(WebCore::needsPseudoElement):
118	(WebCore::RenderTreeUpdater::updateBeforeOrAfterPseudoElement):
119
120	Pseudo elements are handled entirely during render tree construction. Compute their style and
121	create or delete them as needed.
122
123	* style/RenderTreeUpdater.h: Added.
124	(WebCore::RenderTreeUpdater::parent):
125	* style/StyleRelations.cpp:
126	(WebCore::Style::commitRelationsToRenderStyle):
127	(WebCore::Style::commitRelations):
128
129	Commit to Style::Update instead of the document if needed.
130
131	(WebCore::Style::commitRelationsToDocument): Deleted.
132	* style/StyleRelations.h:
133	* style/StyleSharingResolver.cpp:
134	(WebCore::Style::elementHasDirectionAuto):
135	(WebCore::Style::SharingResolver::resolve):
136
137	Fetch the shareable style from Style::Update instead of the active document style.
138
139	(WebCore::Style::SharingResolver::findSibling):
140	(WebCore::Style::SharingResolver::canShareStyleWithElement):
141	* style/StyleSharingResolver.h:
142	* style/StyleTreeResolver.cpp:
143	(WebCore::Style::TreeResolver::Parent::Parent):
144
145	No need for render tree position anymore.
146
147	(WebCore::Style::TreeResolver::popScope):
148	(WebCore::Style::TreeResolver::styleForElement):
149	(WebCore::Style::invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded):
150	(WebCore::Style::createTextRendererIfNeeded):
151	(WebCore::Style::updateTextRendererAfterContentChange):
152	(WebCore::Style::resetStyleForNonRenderedDescendants):
153	(WebCore::Style::detachChildren):
154	(WebCore::Style::detachSlotAssignees):
155	(WebCore::Style::detachRenderTree):
156	(WebCore::Style::TreeResolver::resolveElement):
157
158	Just resolve the style and return it, no more applying or entering render tree construction code paths.
159
160	(WebCore::Style::resolveTextNode):
161	(WebCore::Style::elementImplicitVisibility):
162	(WebCore::Style::TreeResolver::pushParent):
163	(WebCore::Style::TreeResolver::popParent):
164	(WebCore::Style::TreeResolver::popParentsToDepth):
165	(WebCore::Style::shouldResolvePseudoElement):
166	(WebCore::Style::TreeResolver::resolveComposedTree):
167
168	Add style changes to Style::Update.
169
170	(WebCore::Style::TreeResolver::resolve):
171
172	Return Style::Update object if non-empty.
173
174	(WebCore::Style::postResolutionCallbackQueue):
175	(WebCore::Style::shouldCreateRenderer): Deleted.
176	(WebCore::Style::moveToFlowThreadIfNeeded): Deleted.
177	(WebCore::Style::TreeResolver::createRenderer): Deleted.
178	(WebCore::Style::TreeResolver::createRenderTreeForChildren): Deleted.
179	(WebCore::Style::TreeResolver::createRenderTreeForShadowRoot): Deleted.
180	(WebCore::Style::beforeOrAfterPseudoElement): Deleted.
181	(WebCore::Style::setBeforeOrAfterPseudoElement): Deleted.
182	(WebCore::Style::clearBeforeOrAfterPseudoElement): Deleted.
183	(WebCore::Style::needsPseudoElement): Deleted.
184	(WebCore::Style::TreeResolver::createRenderTreeForBeforeOrAfterPseudoElement): Deleted.
185	(WebCore::Style::TreeResolver::createRenderTreeForSlotAssignees): Deleted.
186	(WebCore::Style::TreeResolver::createRenderTreeRecursively): Deleted.
187	(WebCore::Style::pseudoStyleCacheIsInvalid): Deleted.
188	(WebCore::Style::TreeResolver::resolveBeforeOrAfterPseudoElement): Deleted.
189
190	Remove the recursive render tree building code path.
191
192	* style/StyleTreeResolver.h:
193	(WebCore::Style::TreeResolver::scope):
194	* style/StyleUpdate.cpp: Added.
195	(WebCore::Style::Update::Update):
196	(WebCore::Style::Update::elementUpdate):
197	(WebCore::Style::Update::textUpdate):
198	(WebCore::Style::Update::elementStyle):
199	(WebCore::Style::Update::addElement):
200	(WebCore::Style::Update::addText):
201	(WebCore::Style::Update::addPossibleRoot):
202	* style/StyleUpdate.h: Added.
203	(WebCore::Style::Update::roots):
204	(WebCore::Style::Update::document):
205	* svg/SVGElement.h:
206	(WebCore::SVGElement::updateRelativeLengthsInformation):
207	* svg/SVGUseElement.cpp:
208	(WebCore::SVGUseElement::svgAttributeChanged):
209	(WebCore::SVGUseElement::willRecalcStyle):
210	(WebCore::SVGUseElement::willAttachRenderers): Deleted.
211
212	Switvh willAttachRenderers to willRecalcStyle as the former is now called too late.
213
214	* svg/SVGUseElement.h:
215
1	2016-03-31 Youenn Fablet <youenn.fablet@crf.canon.fr>	216	2016-03-31 Youenn Fablet <youenn.fablet@crf.canon.fr>
2		217
3	Remove forEach use from Fetch Headers builtin constructor	218	Remove forEach use from Fetch Headers builtin constructor

Lines 6557-6562 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- Source/WebCore/WebCore.xcodeproj/project.pbxproj +16 lines
6557	E424A3A01330DF1E00CF6DC9 /* LegacyTileGridTile.mm in Sources / = {isa = PBXBuildFile; fileRef = E424A39F1330DF1E00CF6DC9 / LegacyTileGridTile.mm */; };	6557	E424A3A01330DF1E00CF6DC9 /* LegacyTileGridTile.mm in Sources / = {isa = PBXBuildFile; fileRef = E424A39F1330DF1E00CF6DC9 / LegacyTileGridTile.mm */; };
6558	E425A49A18292B840020CFCF /* CollectionIndexCache.h in Headers / = {isa = PBXBuildFile; fileRef = E425A49918292B840020CFCF / CollectionIndexCache.h */; };	6558	E425A49A18292B840020CFCF /* CollectionIndexCache.h in Headers / = {isa = PBXBuildFile; fileRef = E425A49918292B840020CFCF / CollectionIndexCache.h */; };
6559	E4295FA412B0614E00D1ACE0 /* ResourceLoadPriority.h in Headers / = {isa = PBXBuildFile; fileRef = E4295FA312B0614E00D1ACE0 / ResourceLoadPriority.h */; settings = {ATTRIBUTES = (Private, ); }; };	6559	E4295FA412B0614E00D1ACE0 /* ResourceLoadPriority.h in Headers / = {isa = PBXBuildFile; fileRef = E4295FA312B0614E00D1ACE0 / ResourceLoadPriority.h */; settings = {ATTRIBUTES = (Private, ); }; };
		6560	E42E76DA1C7AF76C00E3614D /* StyleUpdate.cpp in Sources / = {isa = PBXBuildFile; fileRef = E42E76D91C7AF76C00E3614D / StyleUpdate.cpp */; };
		6561	E42E76DC1C7AF77600E3614D /* StyleUpdate.h in Headers / = {isa = PBXBuildFile; fileRef = E42E76DB1C7AF77600E3614D / StyleUpdate.h */; };
6560	E43105B816750F0C00DB2FB8 /* NodeTraversal.cpp in Sources / = {isa = PBXBuildFile; fileRef = E43105B716750F0C00DB2FB8 / NodeTraversal.cpp */; };	6562	E43105B816750F0C00DB2FB8 /* NodeTraversal.cpp in Sources / = {isa = PBXBuildFile; fileRef = E43105B716750F0C00DB2FB8 / NodeTraversal.cpp */; };
6561	E43105BB16750F1600DB2FB8 /* NodeTraversal.h in Headers / = {isa = PBXBuildFile; fileRef = E43105BA16750F1600DB2FB8 / NodeTraversal.h */; settings = {ATTRIBUTES = (Private, ); }; };	6563	E43105BB16750F1600DB2FB8 /* NodeTraversal.h in Headers / = {isa = PBXBuildFile; fileRef = E43105BA16750F1600DB2FB8 / NodeTraversal.h */; settings = {ATTRIBUTES = (Private, ); }; };
6562	E43A023B17EB370A004CDD25 /* RenderElement.h in Headers / = {isa = PBXBuildFile; fileRef = E43A023A17EB370A004CDD25 / RenderElement.h */; settings = {ATTRIBUTES = (Private, ); }; };	6564	E43A023B17EB370A004CDD25 /* RenderElement.h in Headers / = {isa = PBXBuildFile; fileRef = E43A023A17EB370A004CDD25 / RenderElement.h */; settings = {ATTRIBUTES = (Private, ); }; };
Lines 6612-6617 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
6612	E45390490EAFD637003695C8 /* WebCoreSystemInterfaceIOS.mm in Sources / = {isa = PBXBuildFile; fileRef = E45390380EAFD637003695C8 / WebCoreSystemInterfaceIOS.mm */; };	6614	E45390490EAFD637003695C8 /* WebCoreSystemInterfaceIOS.mm in Sources / = {isa = PBXBuildFile; fileRef = E45390380EAFD637003695C8 / WebCoreSystemInterfaceIOS.mm */; };
6613	E453904D0EAFD637003695C8 /* WidgetIOS.mm in Sources / = {isa = PBXBuildFile; fileRef = E453903C0EAFD637003695C8 / WidgetIOS.mm */; };	6615	E453904D0EAFD637003695C8 /* WidgetIOS.mm in Sources / = {isa = PBXBuildFile; fileRef = E453903C0EAFD637003695C8 / WidgetIOS.mm */; };
6614	E45390AE0EAFF4B5003695C8 /* SystemMemoryIOS.cpp in Sources / = {isa = PBXBuildFile; fileRef = E45390AD0EAFF4B5003695C8 / SystemMemoryIOS.cpp */; };	6616	E45390AE0EAFF4B5003695C8 /* SystemMemoryIOS.cpp in Sources / = {isa = PBXBuildFile; fileRef = E45390AD0EAFF4B5003695C8 / SystemMemoryIOS.cpp */; };
		6617	E46180291C8A06CD0026C02C /* RenderTreeUpdater.h in Headers / = {isa = PBXBuildFile; fileRef = E46180281C8A06CD0026C02C / RenderTreeUpdater.h */; };
		6618	E461802B1C8A06D90026C02C /* RenderTreeUpdater.cpp in Sources / = {isa = PBXBuildFile; fileRef = E461802A1C8A06D90026C02C / RenderTreeUpdater.cpp */; };
6615	E461802D1C8DD2900026C02C /* StyleRelations.h in Headers / = {isa = PBXBuildFile; fileRef = E461802C1C8DD2900026C02C / StyleRelations.h */; };	6619	E461802D1C8DD2900026C02C /* StyleRelations.h in Headers / = {isa = PBXBuildFile; fileRef = E461802C1C8DD2900026C02C / StyleRelations.h */; };
6616	E461802F1C8DD4D20026C02C /* StyleRelations.cpp in Sources / = {isa = PBXBuildFile; fileRef = E461802E1C8DD4D20026C02C / StyleRelations.cpp */; };	6620	E461802F1C8DD4D20026C02C /* StyleRelations.cpp in Sources / = {isa = PBXBuildFile; fileRef = E461802E1C8DD4D20026C02C / StyleRelations.cpp */; };
6617	E461D65D1BB0C7F000CB5645 /* AuthorStyleSheets.cpp in Sources / = {isa = PBXBuildFile; fileRef = E461D65C1BB0C7F000CB5645 / AuthorStyleSheets.cpp */; };	6621	E461D65D1BB0C7F000CB5645 /* AuthorStyleSheets.cpp in Sources / = {isa = PBXBuildFile; fileRef = E461D65C1BB0C7F000CB5645 / AuthorStyleSheets.cpp */; };
Lines 14591-14596 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
14591	E424A39F1330DF1E00CF6DC9 /* LegacyTileGridTile.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LegacyTileGridTile.mm; sourceTree = "<group>"; };	14595	E424A39F1330DF1E00CF6DC9 /* LegacyTileGridTile.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LegacyTileGridTile.mm; sourceTree = "<group>"; };
14592	E425A49918292B840020CFCF /* CollectionIndexCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CollectionIndexCache.h; sourceTree = "<group>"; };	14596	E425A49918292B840020CFCF /* CollectionIndexCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CollectionIndexCache.h; sourceTree = "<group>"; };
14593	E4295FA312B0614E00D1ACE0 /* ResourceLoadPriority.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceLoadPriority.h; sourceTree = "<group>"; };	14597	E4295FA312B0614E00D1ACE0 /* ResourceLoadPriority.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceLoadPriority.h; sourceTree = "<group>"; };
		14598	E42E76D91C7AF76C00E3614D /* StyleUpdate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StyleUpdate.cpp; sourceTree = "<group>"; };
		14599	E42E76DB1C7AF77600E3614D /* StyleUpdate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleUpdate.h; sourceTree = "<group>"; };
14594	E43105B716750F0C00DB2FB8 /* NodeTraversal.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NodeTraversal.cpp; sourceTree = "<group>"; };	14600	E43105B716750F0C00DB2FB8 /* NodeTraversal.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NodeTraversal.cpp; sourceTree = "<group>"; };
14595	E43105BA16750F1600DB2FB8 /* NodeTraversal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NodeTraversal.h; sourceTree = "<group>"; };	14601	E43105BA16750F1600DB2FB8 /* NodeTraversal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NodeTraversal.h; sourceTree = "<group>"; };
14596	E43A023A17EB370A004CDD25 /* RenderElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderElement.h; sourceTree = "<group>"; };	14602	E43A023A17EB370A004CDD25 /* RenderElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderElement.h; sourceTree = "<group>"; };
Lines 14638-14643 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
14638	E45390380EAFD637003695C8 /* WebCoreSystemInterfaceIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCoreSystemInterfaceIOS.mm; sourceTree = "<group>"; };	14644	E45390380EAFD637003695C8 /* WebCoreSystemInterfaceIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCoreSystemInterfaceIOS.mm; sourceTree = "<group>"; };
14639	E453903C0EAFD637003695C8 /* WidgetIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WidgetIOS.mm; sourceTree = "<group>"; };	14645	E453903C0EAFD637003695C8 /* WidgetIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WidgetIOS.mm; sourceTree = "<group>"; };
14640	E45390AD0EAFF4B5003695C8 /* SystemMemoryIOS.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SystemMemoryIOS.cpp; sourceTree = "<group>"; };	14646	E45390AD0EAFF4B5003695C8 /* SystemMemoryIOS.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SystemMemoryIOS.cpp; sourceTree = "<group>"; };
		14647	E46180281C8A06CD0026C02C /* RenderTreeUpdater.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderTreeUpdater.h; sourceTree = "<group>"; };
		14648	E461802A1C8A06D90026C02C /* RenderTreeUpdater.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderTreeUpdater.cpp; sourceTree = "<group>"; };
14641	E461802C1C8DD2900026C02C /* StyleRelations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleRelations.h; sourceTree = "<group>"; };	14649	E461802C1C8DD2900026C02C /* StyleRelations.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleRelations.h; sourceTree = "<group>"; };
14642	E461802E1C8DD4D20026C02C /* StyleRelations.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StyleRelations.cpp; sourceTree = "<group>"; };	14650	E461802E1C8DD4D20026C02C /* StyleRelations.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StyleRelations.cpp; sourceTree = "<group>"; };
14643	E461D65C1BB0C7F000CB5645 /* AuthorStyleSheets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AuthorStyleSheets.cpp; sourceTree = "<group>"; };	14651	E461D65C1BB0C7F000CB5645 /* AuthorStyleSheets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AuthorStyleSheets.cpp; sourceTree = "<group>"; };
Lines 23506-23511 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec5
23506	1C0106FF192594DF008A4201 /* InlineTextBoxStyle.h */,	23514	1C0106FF192594DF008A4201 /* InlineTextBoxStyle.h */,
23507	5824ABA81AE849C8009074B7 /* RenderTreePosition.cpp */,	23515	5824ABA81AE849C8009074B7 /* RenderTreePosition.cpp */,
23508	5824ABA91AE849C8009074B7 /* RenderTreePosition.h */,	23516	5824ABA91AE849C8009074B7 /* RenderTreePosition.h */,
		23517	E461802A1C8A06D90026C02C /* RenderTreeUpdater.cpp */,
		23518	E46180281C8A06CD0026C02C /* RenderTreeUpdater.h */,
23509	E401E0A51C3C0CF700F34D10 /* StyleChange.cpp */,	23519	E401E0A51C3C0CF700F34D10 /* StyleChange.cpp */,
23510	E401E0A31C3C0B8300F34D10 /* StyleChange.h */,	23520	E401E0A31C3C0B8300F34D10 /* StyleChange.h */,
23511	E4D58EB617B4ED8900CBDCA8 /* StyleFontSizeFunctions.cpp */,	23521	E4D58EB617B4ED8900CBDCA8 /* StyleFontSizeFunctions.cpp */,
Lines 23518-23523 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec6
23518	E47A3AC41C5EAC7900CCBFA7 /* StyleSharingResolver.h */,	23528	E47A3AC41C5EAC7900CCBFA7 /* StyleSharingResolver.h */,
23519	E4DEAA1517A93DC3000E0430 /* StyleTreeResolver.cpp */,	23529	E4DEAA1517A93DC3000E0430 /* StyleTreeResolver.cpp */,
23520	E4DEAA1617A93DC3000E0430 /* StyleTreeResolver.h */,	23530	E4DEAA1617A93DC3000E0430 /* StyleTreeResolver.h */,
		23531	E42E76D91C7AF76C00E3614D /* StyleUpdate.cpp */,
		23532	E42E76DB1C7AF77600E3614D /* StyleUpdate.h */,
23521	);	23533	);
23522	path = style;	23534	path = style;
23523	sourceTree = "<group>";	23535	sourceTree = "<group>";
Lines 25953-25958 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec7
25953	5C4304B1191AC908000E2BC0 /* EXTShaderTextureLOD.h in Headers */,	25965	5C4304B1191AC908000E2BC0 /* EXTShaderTextureLOD.h in Headers */,
25954	7728694F14F8882500F484DC /* EXTTextureFilterAnisotropic.h in Headers */,	25966	7728694F14F8882500F484DC /* EXTTextureFilterAnisotropic.h in Headers */,
25955	A75E8B890E1DE2D6007F2481 /* FEBlend.h in Headers */,	25967	A75E8B890E1DE2D6007F2481 /* FEBlend.h in Headers */,
		25968	E46180291C8A06CD0026C02C /* RenderTreeUpdater.h in Headers */,
25956	A75E8B8B0E1DE2D6007F2481 /* FEColorMatrix.h in Headers */,	25969	A75E8B8B0E1DE2D6007F2481 /* FEColorMatrix.h in Headers */,
25957	A75E8B8D0E1DE2D6007F2481 /* FEComponentTransfer.h in Headers */,	25970	A75E8B8D0E1DE2D6007F2481 /* FEComponentTransfer.h in Headers */,
25958	A75E8B8F0E1DE2D6007F2481 /* FEComposite.h in Headers */,	25971	A75E8B8F0E1DE2D6007F2481 /* FEComposite.h in Headers */,
Lines 26144-26149 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec8
26144	A8EA79F70A1916DF00A8EF5F /* HTMLDListElement.h in Headers */,	26157	A8EA79F70A1916DF00A8EF5F /* HTMLDListElement.h in Headers */,
26145	93F198E508245E59001E9ABC /* HTMLDocument.h in Headers */,	26158	93F198E508245E59001E9ABC /* HTMLDocument.h in Headers */,
26146	977B3867122883E900B81FF8 /* HTMLDocumentParser.h in Headers */,	26159	977B3867122883E900B81FF8 /* HTMLDocumentParser.h in Headers */,
		26160	E42E76DC1C7AF77600E3614D /* StyleUpdate.h in Headers */,
26147	93309DE8099E64920056E581 /* htmlediting.h in Headers */,	26161	93309DE8099E64920056E581 /* htmlediting.h in Headers */,
26148	93F198E608245E59001E9ABC /* HTMLElement.h in Headers */,	26162	93F198E608245E59001E9ABC /* HTMLElement.h in Headers */,
26149	A17C81230F2A5CF7005DAAEB /* HTMLElementFactory.h in Headers */,	26163	A17C81230F2A5CF7005DAAEB /* HTMLElementFactory.h in Headers */,
Lines 30530-30535 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec9
30530	A84EBD780CB8C89200079609 /* JSStyleSheetListCustom.cpp in Sources */,	30544	A84EBD780CB8C89200079609 /* JSStyleSheetListCustom.cpp in Sources */,
30531	E1FF8F64180745D800132674 /* JSSubtleCrypto.cpp in Sources */,	30545	E1FF8F64180745D800132674 /* JSSubtleCrypto.cpp in Sources */,
30532	E1FF8F681807460800132674 /* JSSubtleCryptoCustom.cpp in Sources */,	30546	E1FF8F681807460800132674 /* JSSubtleCryptoCustom.cpp in Sources */,
		30547	E461802B1C8A06D90026C02C /* RenderTreeUpdater.cpp in Sources */,
30533	B20111070AB7740500DB0E68 /* JSSVGAElement.cpp in Sources */,	30548	B20111070AB7740500DB0E68 /* JSSVGAElement.cpp in Sources */,
30534	24D9129113CA951E00D21915 /* JSSVGAltGlyphDefElement.cpp in Sources */,	30549	24D9129113CA951E00D21915 /* JSSVGAltGlyphDefElement.cpp in Sources */,
30535	6515EC910D9723FF0063D49A /* JSSVGAltGlyphElement.cpp in Sources */,	30550	6515EC910D9723FF0063D49A /* JSSVGAltGlyphElement.cpp in Sources */,
Lines 31068-31073 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec10
31068	0F43C85D189E10CF00019AE2 /* PerformanceTiming.cpp in Sources */,	31083	0F43C85D189E10CF00019AE2 /* PerformanceTiming.cpp in Sources */,
31069	FD581FB41520F93B003A7A75 /* PeriodicWave.cpp in Sources */,	31084	FD581FB41520F93B003A7A75 /* PeriodicWave.cpp in Sources */,
31070	49D5DC2D0F423A73008F20FD /* PerspectiveTransformOperation.cpp in Sources */,	31085	49D5DC2D0F423A73008F20FD /* PerspectiveTransformOperation.cpp in Sources */,
		31086	E42E76DA1C7AF76C00E3614D /* StyleUpdate.cpp in Sources */,
31071	D0FF2A5D11F8C45A007E74E0 /* PingLoader.cpp in Sources */,	31087	D0FF2A5D11F8C45A007E74E0 /* PingLoader.cpp in Sources */,
31072	CD7D33431C7A123F00041293 /* PixelBufferConformerCV.cpp in Sources */,	31088	CD7D33431C7A123F00041293 /* PixelBufferConformerCV.cpp in Sources */,
31073	0FDF45A71BD1C6FD00E4FA8C /* PlatformCAAnimation.cpp in Sources */,	31089	0FDF45A71BD1C6FD00E4FA8C /* PlatformCAAnimation.cpp in Sources */,

Lines 381-390 void RenderBox::styleDidChange(StyleDiff Source/WebCore/rendering/RenderBox.cpp_sec1
- Source/WebCore/rendering/RenderBox.cpp -4 lines
381	bool isBodyRenderer = isBody();	381	bool isBodyRenderer = isBody();
382	bool isDocElementRenderer = isDocumentElementRenderer();	382	bool isDocElementRenderer = isDocumentElementRenderer();
383		383
384	// Set the text color if we're the body.
385	if (isBodyRenderer)
386	document().setTextColor(newStyle.visitedDependentColor(CSSPropertyColor));
387
388	if (isDocElementRenderer \|\| isBodyRenderer) {	384	if (isDocElementRenderer \|\| isBodyRenderer) {
389	// Propagate the new writing mode and direction up to the RenderView.	385	// Propagate the new writing mode and direction up to the RenderView.
390	auto* documentElementRenderer = document().documentElement()->renderer();	386	auto* documentElementRenderer = document().documentElement()->renderer();

Lines 50-58 public: Source/WebCore/rendering/RenderElement.h_sec1
- Source/WebCore/rendering/RenderElement.h -12 lines
50	// continue even if the style isn't different from the current style.	50	// continue even if the style isn't different from the current style.
51	void setStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);	51	void setStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);
52		52
53	// Called to update a style that is allowed to trigger animations.
54	void setAnimatableStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference);
55
56	// The pseudo element style can be cached or uncached. Use the cached method if the pseudo element doesn't respect	53	// The pseudo element style can be cached or uncached. Use the cached method if the pseudo element doesn't respect
57	// any pseudo classes (and therefore has no concept of changing state).	54	// any pseudo classes (and therefore has no concept of changing state).
58	RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = nullptr) const;	55	RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = nullptr) const;
Lines 343-357 private: Source/WebCore/rendering/RenderElement.h_sec2
343	static bool s_noLongerAffectsParentBlock;	340	static bool s_noLongerAffectsParentBlock;
344	};	341	};
345		342
346	inline void RenderElement::setAnimatableStyle(Ref<RenderStyle>&& style, StyleDifference minimalStyleDifference)
347	{
348	Ref<RenderStyle> animatedStyle = WTFMove(style);
349	if (animation().updateAnimations(*this, animatedStyle, animatedStyle))
350	minimalStyleDifference = std::max(minimalStyleDifference, StyleDifferenceRecompositeLayer);
351
352	setStyle(WTFMove(animatedStyle), minimalStyleDifference);
353	}
354
355	inline void RenderElement::setAncestorLineBoxDirty(bool f)	343	inline void RenderElement::setAncestorLineBoxDirty(bool f)
356	{	344	{
357	m_ancestorLineBoxDirty = f;	345	m_ancestorLineBoxDirty = f;

Line 0 Source/WebCore/style/RenderTreeUpdater.cpp_sec1
- Source/WebCore/style/RenderTreeUpdater.cpp +511 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "RenderTreeUpdater.h"
		28
		29	#include "AXObjectCache.h"
		30	#include "ComposedTreeAncestorIterator.h"
		31	#include "ComposedTreeIterator.h"
		32	#include "Document.h"
		33	#include "Element.h"
		34	#include "FlowThreadController.h"
		35	#include "HTMLSlotElement.h"
		36	#include "InspectorInstrumentation.h"
		37	#include "PseudoElement.h"
		38	#include "RenderFullScreen.h"
		39	#include "RenderNamedFlowThread.h"
		40	#include "StyleResolver.h"
		41	#include "StyleTreeResolver.h"
		42
		43	namespace WebCore {
		44
		45	RenderTreeUpdater::Parent::Parent(ContainerNode& root)
		46	: element(is<Document>(root) ? nullptr : downcast<Element>(&root))
		47	, renderTreePosition(RenderTreePosition(*root.renderer()))
		48	{
		49	}
		50
		51	RenderTreeUpdater::Parent::Parent(Element& element, Style::Change styleChange)
		52	: element(&element)
		53	, styleChange(styleChange)
		54	, renderTreePosition(element.renderer() ? makeOptional(RenderTreePosition(*element.renderer())) : Nullopt)
		55	{
		56	}
		57
		58
		59	RenderTreeUpdater::RenderTreeUpdater(Document& document)
		60	: m_document(document)
		61	{
		62	}
		63
		64	// Slots have implicit display:contents until it is supported for reals.
65	static bool hasDisplayContents(const Node& node)
66	{
67	return is<HTMLSlotElement>(node);
68	}
69
70	static ContainerNode& findRenderingRoot(ContainerNode& node)
71	{
72	auto& document = node.document();
73	for (ComposedTreeAncestorIterator it(document, node), end(document); it != end; ++it) {
74	if (it->renderer())
75	return *it;
76	ASSERT(hasDisplayContents(*it));
77	}
78	ASSERT_NOT_REACHED();
79	return document;
80	}
81
82	void RenderTreeUpdater::commit(std::unique_ptr<const Style::Update> styleUpdate)
83	{
84	ASSERT(&m_document == &styleUpdate->document());
85
86	if (!m_document.shouldCreateRenderers())
87	return;
88
89	m_styleUpdate = WTFMove(styleUpdate);
90
91	for (auto* root : m_styleUpdate->roots())
92	updateRenderTree(findRenderingRoot(*root));
93
94	m_styleUpdate = nullptr;
95	}
96
97	static bool shouldCreateRenderer(const Element& element, const RenderElement& parentRenderer)
98	{
99	if (!parentRenderer.canHaveChildren() && !(element.isPseudoElement() && parentRenderer.canHaveGeneratedChildren()))
100	return false;
101	if (parentRenderer.element() && !parentRenderer.element()->childShouldCreateRenderer(element))
102	return false;
103	return true;
104	}
105
106	void RenderTreeUpdater::updateRenderTree(ContainerNode& root)
107	{
108	ASSERT(root.renderer());
109	ASSERT(m_parentStack.isEmpty());
110
111	m_parentStack.append(Parent(root));
112
113	auto descendants = composedTreeDescendants(root);
114	auto it = descendants.begin();
115	auto end = descendants.end();
116
117	// FIXME: SVG <use> element may cause tree mutations during style recalc.
118	it.dropAssertions();
119
120	while (it != end) {
121	popParentsToDepth(it.depth());
122
123	auto& node = *it;
124
125	if (auto* renderer = node.renderer())
126	renderTreePosition().invalidateNextSibling(*renderer);
127
128	if (is<Text>(node)) {
129	auto& text = downcast<Text>(node);
130	if (parent().styleChange == Style::Detach \|\| m_styleUpdate->textUpdate(text) \|\| m_invalidatedWhitespaceOnlyTextSiblings.contains(&text))
131	updateTextRenderer(text);
132
133	it.traverseNextSkippingChildren();
134	continue;
135	}
136
137	auto& element = downcast<Element>(node);
138
139	auto* elementUpdate = m_styleUpdate->elementUpdate(element);
140
141	auto changeType = Style::NoChange;
142	if (elementUpdate) {
143	if (hasDisplayContents(element)) {
144	if (!shouldCreateRenderer(element, renderTreePosition().parent())) {
145	it.traverseNextSkippingChildren();
146	continue;
147	}
148	pushParent(element, parent().styleChange);
149	it.traverseNext();
150	continue;
151	}
152
153	updateElementRenderer(element, *elementUpdate);
154	changeType = elementUpdate->change;
155	}
156
157	if (!element.renderer() \|\| !elementUpdate) {
158	it.traverseNextSkippingChildren();
159	continue;
160	}
161
162	pushParent(element, changeType);
163
164	it.traverseNext();
165	}
166
167	popParentsToDepth(0);
168
169	m_invalidatedWhitespaceOnlyTextSiblings.clear();
170	}
171
172	RenderTreePosition& RenderTreeUpdater::renderTreePosition()
173	{
174	for (unsigned i = m_parentStack.size(); i; --i) {
175	if (auto& position = m_parentStack[i - 1].renderTreePosition)
176	return *position;
177	}
178	ASSERT_NOT_REACHED();
179	return *m_parentStack.last().renderTreePosition;
180	}
181
182	void RenderTreeUpdater::pushParent(Element& element, Style::Change changeType)
183	{
184	m_parentStack.append(Parent(element, changeType));
185
186	updateBeforeOrAfterPseudoElement(element, BEFORE);
187	}
188
189	void RenderTreeUpdater::popParent()
190	{
191	auto& parent = m_parentStack.last();
192
193	if (parent.element) {
194	updateBeforeOrAfterPseudoElement(*parent.element, AFTER);
195
196	if (parent.element->hasCustomStyleResolveCallbacks() && parent.styleChange == Style::Detach && parent.element->renderer())
197	parent.element->didAttachRenderers();
198	}
199	m_parentStack.removeLast();
200	}
201
202	void RenderTreeUpdater::popParentsToDepth(unsigned depth)
203	{
204	ASSERT(m_parentStack.size() >= depth);
205
206	while (m_parentStack.size() > depth)
207	popParent();
208	}
209
210	static bool pseudoStyleCacheIsInvalid(RenderElement* renderer, RenderStyle* newStyle)
211	{
212	const RenderStyle& currentStyle = renderer->style();
213
214	const PseudoStyleCache* pseudoStyleCache = currentStyle.cachedPseudoStyles();
215	if (!pseudoStyleCache)
216	return false;
217
218	for (auto& cache : *pseudoStyleCache) {
219	RefPtr<RenderStyle> newPseudoStyle;
220	PseudoId pseudoId = cache->styleType();
221	if (pseudoId == FIRST_LINE \|\| pseudoId == FIRST_LINE_INHERITED)
222	newPseudoStyle = renderer->uncachedFirstLineStyle(newStyle);
223	else
224	newPseudoStyle = renderer->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
225	if (!newPseudoStyle)
226	return true;
227	if (newPseudoStyle != cache) {
228	if (pseudoId < FIRST_INTERNAL_PSEUDOID)
229	newStyle->setHasPseudoStyle(pseudoId);
230	newStyle->addCachedPseudoStyle(newPseudoStyle);
231	if (pseudoId == FIRST_LINE \|\| pseudoId == FIRST_LINE_INHERITED) {
232	// FIXME: We should do an actual diff to determine whether a repaint vs. layout
233	// is needed, but for now just assume a layout will be required. The diff code
234	// in RenderObject::setStyle would need to be factored out so that it could be reused.
235	renderer->setNeedsLayoutAndPrefWidthsRecalc();
236	}
237	return true;
238	}
239	}
240	return false;
241	}
242
243	void RenderTreeUpdater::updateElementRenderer(Element& element, const Style::ElementUpdate& update)
244	{
245	bool shouldTearDownRenderers = update.change == Style::Detach && (element.renderer() \|\| element.isNamedFlowContentNode());
246	if (shouldTearDownRenderers)
247	detachRenderTree(element, Style::ReattachDetach);
248
249	bool shouldCreateNewRenderer = !element.renderer() && update.style;
250	if (shouldCreateNewRenderer) {
251	if (element.hasCustomStyleResolveCallbacks())
252	element.willAttachRenderers();
253	createRenderer(element, *update.style);
254	invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(element);
255	return;
256	}
257
258	if (!element.renderer())
259	return;
260	auto& renderer = *element.renderer();
261
262	if (update.isSynthetic) {
263	renderer.setStyle(*update.style, StyleDifferenceRecompositeLayer);
264	return;
265	}
266
267	if (update.change == Style::NoChange) {
268	if (pseudoStyleCacheIsInvalid(&renderer, update.style.get()) \|\| (parent().styleChange == Style::Force && renderer.requiresForcedStyleRecalcPropagation())) {
269	renderer.setStyle(*update.style, StyleDifferenceEqual);
270	return;
271	}
272	return;
273	}
274
275	renderer.setStyle(*update.style, StyleDifferenceEqual);
276	}
277
278	#if ENABLE(CSS_REGIONS)
279	static RenderNamedFlowThread* moveToFlowThreadIfNeeded(Element& element, const RenderStyle& style)
280	{
281	if (!element.shouldMoveToFlowThread(style))
282	return nullptr;
283
284	FlowThreadController& flowThreadController = element.document().renderView()->flowThreadController();
285	RenderNamedFlowThread& parentFlowRenderer = flowThreadController.ensureRenderFlowThreadWithName(style.flowThread());
286	flowThreadController.registerNamedFlowContentElement(element, parentFlowRenderer);
287	return &parentFlowRenderer;
288	}
289	#endif
290
291	void RenderTreeUpdater::createRenderer(Element& element, RenderStyle& style)
292	{
293	if (!shouldCreateRenderer(element, renderTreePosition().parent()))
294	return;
295
296	RenderNamedFlowThread* parentFlowRenderer = nullptr;
297	#if ENABLE(CSS_REGIONS)
298	parentFlowRenderer = moveToFlowThreadIfNeeded(element, style);
299	#endif
300
301	if (!element.rendererIsNeeded(style))
302	return;
303
304	renderTreePosition().computeNextSibling(element);
305
306	RenderTreePosition insertionPosition = parentFlowRenderer
307	? RenderTreePosition(*parentFlowRenderer, parentFlowRenderer->nextRendererForElement(element))
308	: renderTreePosition();
309
310	RenderElement* newRenderer = element.createElementRenderer(style, insertionPosition).leakPtr();
311	if (!newRenderer)
312	return;
313	if (!insertionPosition.canInsert(*newRenderer)) {
314	newRenderer->destroy();
315	return;
316	}
317
318	// Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
319	// for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
320	newRenderer->setFlowThreadState(insertionPosition.parent().flowThreadState());
321
322	element.setRenderer(newRenderer);
323
324	Ref<RenderStyle> animatedStyle = newRenderer->style();
325	newRenderer->animation().updateAnimations(*newRenderer, animatedStyle, animatedStyle);
326	newRenderer->setStyleInternal(WTFMove(animatedStyle));
327
328	newRenderer->initializeStyle();
329
330	#if ENABLE(FULLSCREEN_API)
331	if (m_document.webkitIsFullScreen() && m_document.webkitCurrentFullScreenElement() == &element) {
332	newRenderer = RenderFullScreen::wrapRenderer(newRenderer, &insertionPosition.parent(), m_document);
333	if (!newRenderer)
334	return;
335	}
336	#endif
337	// Note: Adding newRenderer instead of renderer(). renderer() may be a child of newRenderer.
338	insertionPosition.insert(*newRenderer);
339
340	if (AXObjectCache* cache = m_document.axObjectCache())
341	cache->updateCacheAfterNodeIsAttached(&element);
342	}
343
344	static bool textRendererIsNeeded(const Text& textNode, const RenderTreePosition& renderTreePosition)
345	{
346	const RenderElement& parentRenderer = renderTreePosition.parent();
347	if (!parentRenderer.canHaveChildren())
348	return false;
349	if (parentRenderer.element() && !parentRenderer.element()->childShouldCreateRenderer(textNode))
350	return false;
351	if (textNode.isEditingText())
352	return true;
353	if (!textNode.length())
354	return false;
355	if (!textNode.containsOnlyWhitespace())
356	return true;
357	// This text node has nothing but white space. We may still need a renderer in some cases.
358	if (parentRenderer.isTable() \|\| parentRenderer.isTableRow() \|\| parentRenderer.isTableSection() \|\| parentRenderer.isRenderTableCol() \|\| parentRenderer.isFrameSet())
359	return false;
360	if (parentRenderer.style().preserveNewline()) // pre/pre-wrap/pre-line always make renderers.
361	return true;
362
363	RenderObject* previousRenderer = renderTreePosition.previousSiblingRenderer(textNode);
364	if (previousRenderer && previousRenderer->isBR()) // <span><br/> <br/></span>
365	return false;
366
367	if (parentRenderer.isRenderInline()) {
368	// <span><div/> <div/></span>
369	if (previousRenderer && !previousRenderer->isInline())
370	return false;
371	} else {
372	if (parentRenderer.isRenderBlock() && !parentRenderer.childrenInline() && (!previousRenderer \|\| !previousRenderer->isInline()))
373	return false;
374
375	RenderObject* first = parentRenderer.firstChild();
376	while (first && first->isFloatingOrOutOfFlowPositioned())
377	first = first->nextSibling();
378	RenderObject* nextRenderer = renderTreePosition.nextSiblingRenderer(textNode);
379	if (!first \|\| nextRenderer == first) {
380	// Whitespace at the start of a block just goes away. Don't even make a render object for this text.
381	return false;
382	}
383	}
384	return true;
385	}
386
387	static void createTextRenderer(Text& textNode, RenderTreePosition& renderTreePosition)
388	{
389	ASSERT(!textNode.renderer());
390
391	auto newRenderer = textNode.createTextRenderer(renderTreePosition.parent().style());
392	ASSERT(newRenderer);
393
394	renderTreePosition.computeNextSibling(textNode);
395
396	if (!renderTreePosition.canInsert(*newRenderer))
397	return;
398
399	// Make sure the RenderObject already knows it is going to be added to a RenderFlowThread before we set the style
400	// for the first time. Otherwise code using inRenderFlowThread() in the styleWillChange and styleDidChange will fail.
401	newRenderer->setFlowThreadState(renderTreePosition.parent().flowThreadState());
402
403	textNode.setRenderer(newRenderer.get());
404	renderTreePosition.insert(*newRenderer.leakPtr());
405	}
406
407	void RenderTreeUpdater::updateTextRenderer(Text& text)
408	{
409	bool hasRenderer = text.renderer();
410	bool needsRenderer = textRendererIsNeeded(text, renderTreePosition());
411	if (hasRenderer) {
412	if (needsRenderer)
413	return;
414	Style::detachTextRenderer(text);
415	invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(text);
416	return;
417	}
418	if (!needsRenderer)
419	return;
420	createTextRenderer(text, renderTreePosition());
421	invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(text);
422	}
423
424	void RenderTreeUpdater::invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(Node& current)
425	{
426	// FIXME: This needs to traverse in composed tree order.
427
428	// This function finds sibling text renderers where the results of textRendererIsNeeded may have changed as a result of
429	// the current node gaining or losing the renderer. This can only affect white space text nodes.
430	for (Node* sibling = current.nextSibling(); sibling; sibling = sibling->nextSibling()) {
431	if (is<Element>(*sibling)) {
432	if (m_styleUpdate->elementUpdate(downcast<Element>(*sibling)))
433	return;
434	// Text renderers beyond rendered elements can't be affected.
435	if (!sibling->renderer() \|\| RenderTreePosition::isRendererReparented(*sibling->renderer()))
436	continue;
437	return;
438	}
439	if (!is<Text>(*sibling))
440	continue;
441	Text& textSibling = downcast<Text>(*sibling);
442	if (m_styleUpdate->textUpdate(textSibling))
443	return;
444	if (!textSibling.containsOnlyWhitespace())
445	continue;
446	m_invalidatedWhitespaceOnlyTextSiblings.add(&textSibling);
447	}
448	}
449
450	static bool needsPseudoElement(Element& current, PseudoId pseudoId)
451	{
452	if (!current.renderer() \|\| !current.renderer()->canHaveGeneratedChildren())
453	return false;
454	if (current.isPseudoElement())
455	return false;
456	if (!pseudoElementRendererIsNeeded(current.renderer()->getCachedPseudoStyle(pseudoId)))
457	return false;
458	return true;
459	}
460
461	void RenderTreeUpdater::updateBeforeOrAfterPseudoElement(Element& current, PseudoId pseudoId)
462	{
463	PseudoElement* pseudoElement = pseudoId == BEFORE ? current.beforePseudoElement() : current.afterPseudoElement();
464
465	auto* renderer = pseudoElement ? pseudoElement->renderer() : nullptr;
466	if (renderer)
467	renderTreePosition().invalidateNextSibling(*renderer);
468
469	bool needsPseudoElement = WebCore::needsPseudoElement(current, pseudoId);
470	if (!needsPseudoElement) {
471	if (pseudoElement) {
472	if (pseudoId == BEFORE)
473	current.clearBeforePseudoElement();
474	else
475	current.clearAfterPseudoElement();
476	}
477	return;
478	}
479
480	Style::ElementUpdate elementUpdate;
481
482	Ref<RenderStyle> newStyle = *current.renderer()->getCachedPseudoStyle(pseudoId, &current.renderer()->style());
483
484	if (renderer && m_document.frame()->animation().updateAnimations(*renderer, newStyle, newStyle))
485	elementUpdate.isSynthetic = true;
486
487	elementUpdate.change = renderer ? Style::determineChange(renderer->style(), newStyle) : Style::Detach;
488	elementUpdate.style = WTFMove(newStyle);
489
490	if (elementUpdate.change == Style::NoChange)
491	return;
492
493	if (!pseudoElement) {
494	auto newPseudoElement = PseudoElement::create(current, pseudoId);
495	pseudoElement = newPseudoElement.ptr();
496	InspectorInstrumentation::pseudoElementCreated(m_document.page(), newPseudoElement);
497	if (pseudoId == BEFORE)
498	current.setBeforePseudoElement(WTFMove(newPseudoElement));
499	else
500	current.setAfterPseudoElement(WTFMove(newPseudoElement));
501	}
502
503	updateElementRenderer(*pseudoElement, elementUpdate);
504
505	if (elementUpdate.change == Style::Detach)
506	pseudoElement->didAttachRenderers();
507	else
508	pseudoElement->didRecalcStyle(elementUpdate.change);
509	}
510
511	}

Lines 29-34 Source/WebCore/style/StyleRelations.cpp_sec1
- Source/WebCore/style/StyleRelations.cpp -4 / +7 lines
29	#include "Element.h"	29	#include "Element.h"
30	#include "NodeRenderStyle.h"	30	#include "NodeRenderStyle.h"
31	#include "RenderStyle.h"	31	#include "RenderStyle.h"
		32	#include "StyleUpdate.h"
32		33
33	namespace WebCore {	34	namespace WebCore {
34	namespace Style {	35	namespace Style {
Lines 85-91 std::unique_ptr<Relations> commitRelatio Source/WebCore/style/StyleRelations.cpp_sec2
85	return remainingRelations;	86	return remainingRelations;
86	}	87	}
87		88
88	void commitRelationsToDocument(std::unique_ptr<Relations> relations)	89	void commitRelations(std::unique_ptr<Relations> relations, Update& update)
89	{	90	{
90	if (!relations)	91	if (!relations)
91	return;	92	return;
Lines 124-141 void commitRelationsToDocument(std::uniq Source/WebCore/style/StyleRelations.cpp_sec3
124	element.setChildrenAffectedByLastChildRules();	125	element.setChildrenAffectedByLastChildRules();
125	break;	126	break;
126	case Relation::FirstChild:	127	case Relation::FirstChild:
127	if (auto* style = element.renderStyle())	128	if (auto* style = update.elementStyle(element))
128	style->setFirstChildState();	129	style->setFirstChildState();
129	break;	130	break;
130	case Relation::LastChild:	131	case Relation::LastChild:
131	if (auto* style = element.renderStyle())	132	if (auto* style = update.elementStyle(element))
132	style->setLastChildState();	133	style->setLastChildState();
133	break;	134	break;
134	case Relation::NthChildIndex:	135	case Relation::NthChildIndex:
		136	if (auto* style = update.elementStyle(element))
		137	style->setUnique();
135	element.setChildIndex(relation.value);	138	element.setChildIndex(relation.value);
136	break;	139	break;
137	case Relation::Unique:	140	case Relation::Unique:
138	if (auto* style = element.renderStyle())	141	if (auto* style = update.elementStyle(element))
139	style->setUnique();	142	style->setUnique();
140	break;	143	break;
141	}	144	}

Lines 32-38 Source/WebCore/style/StyleTreeResolver.h_sec1
- Source/WebCore/style/StyleTreeResolver.h -18 / +14 lines
32	#include "SelectorFilter.h"	32	#include "SelectorFilter.h"
33	#include "StyleChange.h"	33	#include "StyleChange.h"
34	#include "StyleSharingResolver.h"	34	#include "StyleSharingResolver.h"
		35	#include "StyleUpdate.h"
35	#include <functional>	36	#include <functional>
		37	#include <wtf/HashMap.h>
36	#include <wtf/RefPtr.h>	38	#include <wtf/RefPtr.h>
37		39
38	namespace WebCore {	40	namespace WebCore {
Lines 47-78 class Settings; Source/WebCore/style/StyleTreeResolver.h_sec2
47	class ShadowRoot;	49	class ShadowRoot;
48	class StyleResolver;	50	class StyleResolver;
49	class Text;	51	class Text;
		52	class TreeChange;
50		53
51	namespace Style {	54	namespace Style {
52		55
53	class TreeResolver {	56	class TreeResolver {
54	public:	57	public:
55	TreeResolver(Document&);	58	TreeResolver(Document&);
		59	~TreeResolver();
56		60
57	void resolve(Change);	61	std::unique_ptr<const Update> resolve(Change);
58		62
59	private:	63	private:
60	Ref<RenderStyle> styleForElement(Element&, RenderStyle& inheritedStyle);	64	Ref<RenderStyle> styleForElement(Element&, RenderStyle& inheritedStyle);
61		65
62	void resolveComposedTree();	66	void resolveComposedTree();
63	Change resolveElement(Element&);	67	ElementUpdate resolveElement(Element&);
64	void resolveBeforeOrAfterPseudoElement(Element&, Change, PseudoId, RenderTreePosition&);
65
66
67	void createRenderTreeRecursively(Element&, RenderStyle&, RenderTreePosition&, RefPtr<RenderStyle>&& resolvedStyle);
68	void createRenderer(Element&, RenderTreePosition&, RefPtr<RenderStyle>&& resolvedStyle);
69	void createRenderTreeForBeforeOrAfterPseudoElement(Element&, PseudoId, RenderTreePosition&);
70	void createRenderTreeForChildren(ContainerNode&, RenderStyle&, RenderTreePosition&);
71	void createRenderTreeForShadowRoot(ShadowRoot&);
72
73	#if ENABLE(SHADOW_DOM) \|\| ENABLE(DETAILS_ELEMENT)
74	void createRenderTreeForSlotAssignees(HTMLSlotElement&, RenderStyle& inheritedStyle, RenderTreePosition&);
75	#endif
76		68
77	struct Scope : RefCounted<Scope> {	69	struct Scope : RefCounted<Scope> {
78	StyleResolver& styleResolver;	70	StyleResolver& styleResolver;
Lines 88-100 private: Source/WebCore/style/StyleTreeResolver.h_sec3
88	struct Parent {	80	struct Parent {
89	Element* element;	81	Element* element;
90	Ref<RenderStyle> style;	82	Ref<RenderStyle> style;
91	RenderTreePosition renderTreePosition;
92	Change change;	83	Change change;
93	bool didPushScope { false };	84	bool didPushScope { false };
94	bool elementNeedingStyleRecalcAffectsNextSiblingElementStyle { false };	85	bool elementNeedingStyleRecalcAffectsNextSiblingElementStyle { false };
95		86
96	Parent(Document&, Change);	87	Parent(Document&, Change);
97	Parent(Element&, RenderStyle&, RenderTreePosition, Change);	88	Parent(Element&, ElementUpdate&);
98	};	89	};
99		90
100	Scope& scope() { return m_scopeStack.last(); }	91	Scope& scope() { return m_scopeStack.last(); }
Lines 104-119 private: Source/WebCore/style/StyleTreeResolver.h_sec4
104	void pushEnclosingScope();	95	void pushEnclosingScope();
105	void popScope();	96	void popScope();
106		97
107	void pushParent(Element&, RenderStyle&, RenderTreePosition, Change);	98	void pushParent(Element&, ElementUpdate&);
108	void popParent();	99	void popParent();
109	void popParentsToDepth(unsigned depth);	100	void popParentsToDepth(unsigned depth);
110		101
111	Document& m_document;	102	Document& m_document;
		103	RefPtr<RenderStyle> m_documentElementStyle;
		104
112	Vector<Ref<Scope>, 4> m_scopeStack;	105	Vector<Ref<Scope>, 4> m_scopeStack;
113	Vector<Parent, 32> m_parentStack;	106	Vector<Parent, 32> m_parentStack;
		107
		108	std::unique_ptr<Update> m_update;
114	};	109	};
115		110
116	void detachRenderTree(Element&);	111	enum DetachType { NormalDetach, ReattachDetach };
		112	void detachRenderTree(Element&, DetachType = NormalDetach);
117	void detachTextRenderer(Text&);	113	void detachTextRenderer(Text&);
118		114
119	void updateTextRendererAfterContentChange(Text&, unsigned offsetOfReplacedData, unsigned lengthOfReplacedData);	115	void updateTextRendererAfterContentChange(Text&, unsigned offsetOfReplacedData, unsigned lengthOfReplacedData);

Line 0 Source/WebCore/style/StyleUpdate.cpp_sec1
- Source/WebCore/style/StyleUpdate.cpp +93 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "StyleUpdate.h"
		28
		29	#include "ComposedTreeAncestorIterator.h"
		30	#include "Document.h"
		31	#include "Element.h"
		32	#include "NodeRenderStyle.h"
		33	#include "Text.h"
		34
		35	namespace WebCore {
		36	namespace Style {
		37
		38	Update::Update(Document& document)
		39	: m_document(document)
		40	{
		41	}
		42
		43	const ElementUpdate* Update::elementUpdate(const Element& element) const
		44	{
		45	auto it = m_elements.find(&element);
		46	if (it == m_elements.end())
		47	return nullptr;
		48	return &it->value;
		49	}
		50
		51	bool Update::textUpdate(const Text& text) const
		52	{
		53	return m_texts.contains(&text);
		54	}
		55
		56	RenderStyle* Update::elementStyle(const Element& element) const
		57	{
		58	if (auto* update = elementUpdate(element))
		59	return update->style.get();
		60	return element.renderStyle();
		61	}
		62
		63	void Update::addElement(Element& element, Element* parent, ElementUpdate& change)
		64	{
65	ASSERT(!m_elements.contains(&element));
66	ASSERT(!parent \|\| composedTreeAncestors(element).first() == parent);
67
68	addPossibleRoot(parent);
69	m_elements.add(&element, change);
70	}
71
72	void Update::addText(Text& text, Element* parent)
73	{
74	ASSERT(!m_texts.contains(&text));
75	ASSERT(!parent \|\| composedTreeAncestors(text).first() == parent);
76
77	addPossibleRoot(parent);
78	m_texts.add(&text);
79	}
80
81	void Update::addPossibleRoot(Element* element)
82	{
83	if (!element) {
84	m_roots.add(&m_document);
85	return;
86	}
87	if (m_elements.contains(element))
88	return;
89	m_roots.add(element);
90	}
91
92	}
93	}

Line 0 Source/WebCore/style/StyleUpdate.h_sec1
- Source/WebCore/style/StyleUpdate.h +81 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#ifndef StyleUpdate_h
		27	#define StyleUpdate_h
		28
		29	#include "Node.h"
		30	#include "StyleChange.h"
		31	#include "StyleRelations.h"
		32	#include <wtf/HashMap.h>
		33	#include <wtf/HashSet.h>
		34	#include <wtf/ListHashSet.h>
		35	#include <wtf/RefPtr.h>
		36
		37	namespace WebCore {
		38
		39	class ContainerNode;
		40	class Document;
		41	class Element;
		42	class Node;
		43	class RenderStyle;
		44	class Text;
		45
		46	namespace Style {
		47
		48	struct ElementUpdate {
		49	RefPtr<RenderStyle> style;
		50	Change change { NoChange };
		51	bool isSynthetic { false };
		52	};
		53
		54	class Update {
		55	public:
		56	Update(Document&);
		57
		58	const ListHashSet<ContainerNode*>& roots() const { return m_roots; }
		59
		60	const ElementUpdate* elementUpdate(const Element&) const;
		61	bool textUpdate(const Text&) const;
		62
		63	RenderStyle* elementStyle(const Element&) const;
		64
65	const Document& document() const { return m_document; }
66
67	void addElement(Element&, Element* parent, ElementUpdate&);
68	void addText(Text&, Element* parent);
69
70	private:
71	void addPossibleRoot(Element*);
72
73	Document& m_document;
74	ListHashSet<ContainerNode*> m_roots;
75	HashMap<const Element*, ElementUpdate> m_elements;
76	HashSet<const Text*> m_texts;
77	};
78
79	}
80	}
81	#endif

Lines 178-188 void SVGUseElement::svgAttributeChanged( Source/WebCore/svg/SVGUseElement.cpp_sec1
- Source/WebCore/svg/SVGUseElement.cpp -2 / +3 lines
178	SVGGraphicsElement::svgAttributeChanged(attrName);	178	SVGGraphicsElement::svgAttributeChanged(attrName);
179	}	179	}
180		180
181	void SVGUseElement::willAttachRenderers()	181	bool SVGUseElement::willRecalcStyle(Style::Change change)
182	{	182	{
		183	// FIXME: Shadow tree should be updated before style recalc.
183	if (m_shadowTreeNeedsUpdate)	184	if (m_shadowTreeNeedsUpdate)
184	updateShadowTree();	185	updateShadowTree();
185	SVGGraphicsElement::willAttachRenderers();	186	return SVGGraphicsElement::willRecalcStyle(change);
186	}	187	}
187		188
188	static HashSet<AtomicString> createAllowedElementSet()	189	static HashSet<AtomicString> createAllowedElementSet()

Lines 1-3 LayoutTests/ChangeLog_sec1
- LayoutTests/ChangeLog +39 lines
		1	2016-03-31 Antti Koivisto <antti@apple.com>
		2
		3	Separate render tree updating from style resolve
		4	https://bugs.webkit.org/show_bug.cgi?id=155298
		5
		6	Reviewed by Andreas Kling.
		7
		8	* TestExpectations:
		9
		10	Skip mathml/presentation/menclose-notation-attribute-change-value.html. It will be fixed by upcoming MathML refactoring.
		11
		12	* css3/blending/repaint/blend-mode-isolate-stacking-context-expected.txt:
		13	* css3/viewport-percentage-lengths/viewport-percentage-lengths-resize-expected.txt:
		14
		15	This is a progression.
		16
		17	* editing/mac/spelling/autocorrection-contraction-expected.txt:
		18	* editing/mac/spelling/autocorrection-removing-underline-after-paste-expected.txt:
		19	* editing/mac/spelling/autocorrection-removing-underline-expected.txt:
		20	* editing/mac/spelling/autocorrection-simple-expected.txt:
		21	* editing/style/remove-underline-from-stylesheet-expected.txt:
		22	* editing/style/typing-style-003-expected.txt:
		23
		24	Non-rendered whitespace related changes.
		25
		26	* platform/ios-simulator/TestExpectations:
		27
		28	Skip fast/regions/position-writing-modes-in-variable-width-regions.html on iOS. Similar tests are mostly already skipped.
		29
		30	* platform/ios-simulator/editing/style/typing-style-003-expected.txt: Added.
		31	* platform/mac-wk2/editing/mac/spelling/autocorrection-contraction-expected.txt:
		32	* platform/mac/editing/inserting/editable-html-element-expected.txt:
		33	* platform/mac/editing/inserting/editing-empty-divs-expected.txt:
		34	* platform/mac/editing/inserting/insert-at-end-02-expected.txt:
		35	* platform/mac/editing/pasteboard/4989774-expected.txt:
		36	* platform/mac/editing/selection/4983858-expected.txt:
		37
		38	Non-rendered whitespace related changes.
		39
1	2016-03-31 Youenn Fablet <youenn.fablet@crf.canon.fr>	40	2016-03-31 Youenn Fablet <youenn.fablet@crf.canon.fr>
2		41
3	Remove forEach use from Fetch Headers builtin constructor	42	Remove forEach use from Fetch Headers builtin constructor

Lines 17-35 PASS innerHeight is 600 LayoutTests/css3/viewport-percentage-lengths/viewport-percentage-lengths-resize-expected.txt_sec1
- LayoutTests/css3/viewport-percentage-lengths/viewport-percentage-lengths-resize-expected.txt -5 / +5 lines
17	PASS getComputedStyle(test).fontSize is "30px"	17	PASS getComputedStyle(test).fontSize is "30px"
18	PASS getComputedStyle(test).width is "450px"	18	PASS getComputedStyle(test).width is "450px"
19	PASS getComputedStyle(testpseudo, ':after').marginLeft is "120px"	19	PASS getComputedStyle(testpseudo, ':after').marginLeft is "120px"
20	FAIL getComputedStyle(testpseudo, ':after').paddingRight should be 225px. Was 200px.	20	PASS getComputedStyle(testpseudo, ':after').paddingRight is "225px"
21	PASS innerWidth is 900	21	PASS innerWidth is 900
22	PASS innerHeight is 640	22	PASS innerHeight is 640
23	PASS getComputedStyle(test).fontSize is "32px"	23	PASS getComputedStyle(test).fontSize is "32px"
24	PASS getComputedStyle(test).width is "450px"	24	PASS getComputedStyle(test).width is "450px"
25	FAIL getComputedStyle(testpseudo, ':after').marginLeft should be 128px. Was 120px.	25	PASS getComputedStyle(testpseudo, ':after').marginLeft is "128px"
26	FAIL getComputedStyle(testpseudo, ':after').paddingRight should be 225px. Was 200px.	26	PASS getComputedStyle(testpseudo, ':after').paddingRight is "225px"
27	PASS innerWidth is 500	27	PASS innerWidth is 500
28	PASS innerHeight is 640	28	PASS innerHeight is 640
29	PASS getComputedStyle(test).fontSize is "32px"	29	PASS getComputedStyle(test).fontSize is "32px"
30	PASS getComputedStyle(test).width is "250px"	30	PASS getComputedStyle(test).width is "250px"
31	FAIL getComputedStyle(testpseudo, ':after').marginLeft should be 100px. Was 120px.	31	PASS getComputedStyle(testpseudo, ':after').marginLeft is "100px"
32	FAIL getComputedStyle(testpseudo, ':after').paddingRight should be 160px. Was 200px.	32	PASS getComputedStyle(testpseudo, ':after').paddingRight is "160px"
33	PASS innerWidth is 800	33	PASS innerWidth is 800
34	PASS innerHeight is 600	34	PASS innerHeight is 600
35	PASS getComputedStyle(test).fontSize is "30px"	35	PASS getComputedStyle(test).fontSize is "30px"

Lines 52-61 EDITING DELEGATE: webViewDidChangeSelect LayoutTests/editing/style/typing-style-003-expected.txt_sec1
- LayoutTests/editing/style/typing-style-003-expected.txt -4 / +4 lines
52	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification	52	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
53	xxxxxxxxxxxxxxx	53	xxxxxxxxxxxxxxx
54	execTypeCharacterCommand: x <span id="test"></span>	54	execTypeCharacterCommand: x <span id="test"></span>
55	execTypeCharacterCommand: xx<span id="test"></span>	55	execTypeCharacterCommand: xx <span id="test"></span>
56	execTypeCharacterCommand: xxx<span id="test"></span>	56	execTypeCharacterCommand: xxx <span id="test"></span>
57	execBoldCommand: xxx<span id="test"></span>	57	execBoldCommand: xxx <span id="test"></span>
58	execTypeCharacterCommand: xxx<b>x</b><span id="test"></span>	58	execTypeCharacterCommand: xxx<b>x</b> <span id="test"></span>
59	execTypeCharacterCommand: xxx<b>xx</b><span id="test"></span>	59	execTypeCharacterCommand: xxx<b>xx</b><span id="test"></span>
60	execTypeCharacterCommand: xxx<b>xxx</b><span id="test"></span>	60	execTypeCharacterCommand: xxx<b>xxx</b><span id="test"></span>
61	execItalicCommand: xxx<b>xxx</b><span id="test"></span>	61	execItalicCommand: xxx<b>xxx</b><span id="test"></span>

Line 0 LayoutTests/platform/ios-simulator/editing/style/typing-style-003-expected.txt_sec1
- LayoutTests/platform/ios-simulator/editing/style/typing-style-003-expected.txt +72 lines
		1	EDITING DELEGATE: shouldBeginEditingInDOMRange:range from 0 of DIV > BODY > HTML > #document to 3 of DIV > BODY > HTML > #document
		2	EDITING DELEGATE: webViewDidBeginEditing:WebViewDidBeginEditingNotification
		3	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		4	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 0 of DIV > BODY > HTML > #document to 0 of DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		5	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		6	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		7	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		8	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		9	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		10	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > DIV > BODY > HTML > #document to 3 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		11	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		12	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		13	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		14	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > B > DIV > BODY > HTML > #document to 1 of #text > B > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > B > DIV > BODY > HTML > #document to 1 of #text > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		15	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		16	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		17	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > B > DIV > BODY > HTML > #document to 1 of #text > B > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > B > DIV > BODY > HTML > #document to 2 of #text > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		18	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		19	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		20	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > B > DIV > BODY > HTML > #document to 2 of #text > B > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > B > DIV > BODY > HTML > #document to 3 of #text > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		21	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		22	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		23	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		24	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > B > DIV > BODY > HTML > #document to 1 of #text > I > B > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > I > B > DIV > BODY > HTML > #document to 1 of #text > I > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		25	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		26	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		27	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > B > DIV > BODY > HTML > #document to 1 of #text > I > B > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > I > B > DIV > BODY > HTML > #document to 2 of #text > I > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		28	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		29	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		30	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > I > B > DIV > BODY > HTML > #document to 2 of #text > I > B > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > I > B > DIV > BODY > HTML > #document to 3 of #text > I > B > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		31	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		32	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		33	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		34	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > DIV > BODY > HTML > #document to 1 of #text > I > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > I > DIV > BODY > HTML > #document to 1 of #text > I > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		35	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		36	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		37	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > I > DIV > BODY > HTML > #document to 1 of #text > I > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > I > DIV > BODY > HTML > #document to 2 of #text > I > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		38	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		39	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		40	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > I > DIV > BODY > HTML > #document to 2 of #text > I > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > I > DIV > BODY > HTML > #document to 3 of #text > I > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		41	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		42	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		43	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		44	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document toDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		45	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		46	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		47	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 1 of #text > DIV > BODY > HTML > #document to 1 of #text > DIV > BODY > HTML > #document toDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		48	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		49	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		50	EDITING DELEGATE: shouldChangeSelectedDOMRange:range from 2 of #text > DIV > BODY > HTML > #document to 2 of #text > DIV > BODY > HTML > #document toDOMRange:range from 3 of #text > DIV > BODY > HTML > #document to 3 of #text > DIV > BODY > HTML > #document affinity:NSSelectionAffinityDownstream stillSelecting:FALSE
		51	EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification
		52	EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification
		53	xxxxxxxxxxxxxxx
		54	execTypeCharacterCommand: x <span id="test"></span>
		55	execTypeCharacterCommand: xx<span id="test"></span>
		56	execTypeCharacterCommand: xxx<span id="test"></span>
		57	execBoldCommand: xxx<span id="test"></span>
		58	execTypeCharacterCommand: xxx<b>x</b><span id="test"></span>
		59	execTypeCharacterCommand: xxx<b>xx</b><span id="test"></span>
		60	execTypeCharacterCommand: xxx<b>xxx</b><span id="test"></span>
		61	execItalicCommand: xxx<b>xxx</b><span id="test"></span>
		62	execTypeCharacterCommand: xxx<b>xxx<i>x</i></b><span id="test"></span>
		63	execTypeCharacterCommand: xxx<b>xxx<i>xx</i></b><span id="test"></span>
		64	execTypeCharacterCommand: xxx<b>xxx<i>xxx</i></b><span id="test"></span>
65	execBoldCommand: xxx<b>xxx<i>xxx</i></b><span id="test"></span>
66	execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>x</i><span id="test"></span>
67	execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xx</i><span id="test"></span>
68	execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i><span id="test"></span>
69	execItalicCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i><span id="test"></span>
70	execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i>x<span id="test"></span>
71	execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i>xx<span id="test"></span>
72	execTypeCharacterCommand: xxx<b>xxx</b><i><b>xxx</b>xxx</i>xxx<span id="test"></span>

Lines 65-71 layer at (0,0) size 800x600 LayoutTests/platform/mac/editing/inserting/editing-empty-divs-expected.txt_sec1
- LayoutTests/platform/mac/editing/inserting/editing-empty-divs-expected.txt -2 lines
65	RenderBlock {DIV} at (0,230) size 708x22 [border: (1px dotted #0000FF)]	65	RenderBlock {DIV} at (0,230) size 708x22 [border: (1px dotted #0000FF)]
66	RenderText {#text} at (1,1) size 8x18	66	RenderText {#text} at (1,1) size 8x18
67	text run at (1,1) width 8: "c"	67	text run at (1,1) width 8: "c"
68	RenderText {#text} at (0,0) size 0x0
69	RenderBlock {P} at (0,268) size 784x18	68	RenderBlock {P} at (0,268) size 784x18
70	RenderText {#text} at (0,0) size 240x18	69	RenderText {#text} at (0,0) size 240x18
71	text run at (0,0) width 240: "This div contains a self-closing p tag."	70	text run at (0,0) width 240: "This div contains a self-closing p tag."
Lines 81-86 layer at (0,0) size 800x600 LayoutTests/platform/mac/editing/inserting/editing-empty-divs-expected.txt_sec2
81	RenderBlock (anonymous) at (1,1) size 706x18	80	RenderBlock (anonymous) at (1,1) size 706x18
82	RenderText {#text} at (0,0) size 8x18	81	RenderText {#text} at (0,0) size 8x18
83	text run at (0,0) width 8: "c"	82	text run at (0,0) width 8: "c"
84	RenderText {#text} at (0,0) size 0x0
85	RenderBlock {P} at (1,35) size 706x0	83	RenderBlock {P} at (1,35) size 706x0
86	caret: position 1 of child 0 {#text} of child 21 {DIV} of body	84	caret: position 1 of child 0 {#text} of child 21 {DIV} of body