ChangeLog

2011-02-09  Andy Estes  <aestes@apple.com>

        Reviewed by NOBODY (OOPS!).

        HTML5 TreeBuilder regressed a Peacekeeper DOM test by 40%

        https://bugs.webkit.org/show_bug.cgi?id=48719

        The HTML5 fragment parsing algorithm specifies that a new Document

        should be created to serve as the temporary parent of fragment nodes

        during parsing. Document creation is expensive and accounts for ~38% of

        the Peacekeeper DOM performance regression. Avoid the cost of creating

        a dummy document by using the already-created DocumentFragment as the

        root node during fragment parsing.

        With this patch, the regression in Peacekeeper from Safari 5.0.3 to ToT

        is ~24%.

        Test: fast/parser/fragment-parser-doctype.html

        * dom/ContainerNode.h:

        (WebCore::ContainerNode::firstElementChild): Add a method that returns

        the first element-typed child from a ContainerNode.

        * dom/Document.cpp:

        (WebCore::Document::cacheDocumentElement): Call

        ContainerNode::firstElementChild() to retrieve and cache the document

        element.

        * html/parser/HTMLConstructionSite.cpp:

        (WebCore::HTMLConstructionSite::HTMLConstructionSite): Initialize the

        root ContainerNode.

        (WebCore::HTMLConstructionSite::detach): Clear the reference to the

        root ContainerNode.

        (WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML):

        Attach the new element to the root ContainerNode.

        (WebCore::HTMLConstructionSite::insertDoctype): Ditto.

        (WebCore::HTMLConstructionSite::insertCommentOnDocument): Ditto.

        * html/parser/HTMLConstructionSite.h: Store a pointer to a

        ContainerNode that will be used as the root node for document parsing.

        This node might or might not be the same as m_document.

        * html/parser/HTMLTreeBuilder.cpp:

        (WebCore::HTMLTreeBuilder::HTMLTreeBuilder): Initialize the

        HTMLConstructionSite with the correct root ContainerNode based on

        whether or not we're parsing a fragment.

        (WebCore::HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext):

        Remove m_dummyDocumentForFragmentParsing.

        (WebCore::HTMLTreeBuilder::FragmentParsingContext::finished): If the

        fragment has a context element, store only the children of the root

        element (HTML5 Section 10.4, Step 7).

        * html/parser/HTMLTreeBuilder.h:

2011-02-09  Beth Dakin  <bdakin@apple.com>

        Reviewed by Maciej Stachowiak.

78171

Source/WebCore/dom/ContainerNode.h

@@public:

    Node* firstChild() const { return m_firstChild; }

    Node* lastChild() const { return m_lastChild; }

46 ContainerNode* firstElementChild() const;

    bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode&, bool shouldLazyAttach = false);

    bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode&, bool shouldLazyAttach = false);

@@inline Node* Node::lastChild() const

        return 0;

    return toContainerNode(this)->lastChild();

}

    
inline ContainerNode* ContainerNode::firstElementChild() const

{

    Node* child = firstChild();

    while (child && !child->isElementNode())

        child = child->nextSibling();

    return static_cast<ContainerNode*>(child);

}

} // namespace WebCore

77988

Source/WebCore/dom/Document.cpp

@@void Document::childrenChanged(bool chan

void Document::cacheDocumentElement() const

{

    ASSERT(!m_documentElement);

    Node* n = firstChild();

    while (n && !n->isElementNode())

        n = n->nextSibling();

    m_documentElement = static_cast<Element*>(n);

708 m_documentElement = static_cast<Element*>(firstElementChild());

}

PassRefPtr<Element> Document::createElement(const AtomicString& name, ExceptionCode& ec)

77988

Source/WebCore/html/parser/HTMLConstructionSite.cpp

@@void HTMLConstructionSite::attachAtSite(

    if (child->parentNode() && site.parent->attached() && !child->attached())

        child->attach();

}

132

133 HTMLConstructionSite::HTMLConstructionSite(Document* document~~, FragmentScriptingPermission scriptingPermission, bool isParsingFragment~~)

132

133HTMLConstructionSite::HTMLConstructionSite(Document* document)

134134 : m_document(document)

    , m_attachmentRoot(document)

    , m_fragmentScriptingPermission(FragmentScriptingAllowed)

    , m_isParsingFragment(false)

    , m_redirectAttachToFosterParent(false)

{

}

HTMLConstructionSite::HTMLConstructionSite(DocumentFragment* fragment, FragmentScriptingPermission scriptingPermission)

    : m_document(fragment->document())

    , m_attachmentRoot(fragment)

135145 , m_fragmentScriptingPermission(scriptingPermission)

136 , m_isParsingFragment(~~isParsingFragment~~)

146 , m_isParsingFragment(true)

    , m_redirectAttachToFosterParent(false)

{

}

@@HTMLConstructionSite::~HTMLConstructionS

void HTMLConstructionSite::detach()

{

    m_document = 0;

158 m_attachmentRoot = 0;

}

void HTMLConstructionSite::setForm(HTMLFormElement* form)

@@void HTMLConstructionSite::insertHTMLHtm

{

    RefPtr<HTMLHtmlElement> element = HTMLHtmlElement::create(m_document);

    element->setAttributeMap(token.takeAtributes(), m_fragmentScriptingPermission);

173 m_openElements.pushHTMLHtmlElement(attach<Element>(m_document, element.get()));

184 m_openElements.pushHTMLHtmlElement(attach<Element>(m_attachmentRoot, element.get()));

#if ENABLE(OFFLINE_WEB_APPLICATIONS)

    element->insertedByParser();

#endif

@@void HTMLConstructionSite::insertHTMLBod

void HTMLConstructionSite::insertDoctype(AtomicHTMLToken& token)

{

    ASSERT(token.type() == HTMLToken::DOCTYPE);

208 attach(m_document, DocumentType::create(m_document, token.name(), String::adopt(token.publicIdentifier()), String::adopt(token.systemIdentifier())));

    attach(m_attachmentRoot, DocumentType::create(m_document, token.name(), String::adopt(token.publicIdentifier()), String::adopt(token.systemIdentifier())));

    // A fragment DOCTYPE shouldn't modify the compatibility mode of the owning document.

    if (m_isParsingFragment)

        return;

    
    if (token.forceQuirks())

        m_document->setCompatibilityMode(Document::QuirksMode);

@@void HTMLConstructionSite::insertComment

void HTMLConstructionSite::insertCommentOnDocument(AtomicHTMLToken& token)

{

    ASSERT(token.type() == HTMLToken::Comment);

225 attach(m_document, Comment::create(m_document, token.comment()));

240 attach(m_attachmentRoot, Comment::create(m_document, token.comment()));

}

void HTMLConstructionSite::insertCommentOnHTMLHtmlElement(AtomicHTMLToken& token)

77988

Source/WebCore/html/parser/HTMLConstructionSite.h

@@class Element;

class HTMLConstructionSite {

    WTF_MAKE_NONCOPYABLE(HTMLConstructionSite);

public:

46 HTMLConstructionSite(Document*, FragmentScriptingPermission, bool isParsingFragment);

46 HTMLConstructionSite(Document*);

47 HTMLConstructionSite(DocumentFragment*, FragmentScriptingPermission);

    ~HTMLConstructionSite();

    void detach();

@@private:

    void dispatchDocumentElementAvailableIfNeeded();

    Document* m_document;

    
    // This is the root ContainerNode to which the parser attaches all newly

    // constructed nodes. It points to a DocumentFragment when parsing fragments

    // and a Document in all other cases.

    ContainerNode* m_attachmentRoot;

    RefPtr<Element> m_head;

    RefPtr<HTMLFormElement> m_form;

    mutable HTMLElementStack m_openElements;

77988

Source/WebCore/html/parser/HTMLTreeBuilder.cpp

@@private:

HTMLTreeBuilder::HTMLTreeBuilder(HTMLDocumentParser* parser, HTMLDocument* document, bool reportErrors, bool usePreHTML5ParserQuirks)

    : m_framesetOk(true)

    , m_document(document)

344 , m_tree(document~~, FragmentScriptingAllowed, false~~)

344 , m_tree(document)

    , m_reportErrors(reportErrors)

    , m_isPaused(false)

    , m_insertionMode(InitialMode)

@@HTMLTreeBuilder::HTMLTreeBuilder(HTMLDoc

HTMLTreeBuilder::HTMLTreeBuilder(HTMLDocumentParser* parser, DocumentFragment* fragment, Element* contextElement, FragmentScriptingPermission scriptingPermission, bool usePreHTML5ParserQuirks)

    : m_framesetOk(true)

    , m_fragmentContext(fragment, contextElement, scriptingPermission)

362 , m_document(m_fragment~~Context.~~document())

363 , m_tree(~~m_docu~~ment, scriptingPermission~~, true~~)

362 , m_document(fragment->document())

363 , m_tree(fragment, scriptingPermission)

    , m_reportErrors(false) // FIXME: Why not report errors in fragments?

    , m_isPaused(false)

    , m_insertionMode(InitialMode)

@@HTMLTreeBuilder::HTMLTreeBuilder(HTMLDoc

    if (contextElement) {

        // Steps 4.2-4.6 of the HTML5 Fragment Case parsing algorithm:

        // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#fragment-case

377 m_document->setCompatibilityMode(contextElement->document()->compatibilityMode());

        processFakeStartTag(htmlTag);

        resetInsertionModeAppropriately();

        m_tree.setForm(closestFormAncestor(contextElement));

@@HTMLTreeBuilder::FragmentParsingContext:

}

HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext(DocumentFragment* fragment, Element* contextElement, FragmentScriptingPermission scriptingPermission)

406 : m_dummyDocumentForFragmentParsing(HTMLDocument::create(0, KURL(), fragment->document()->baseURI()))

407 , m_fragment(fragment)

405 : m_fragment(fragment)

    , m_contextElement(contextElement)

    , m_scriptingPermission(scriptingPermission)

{

    m_dummyDocumentForFragmentParsing->setCompatibilityMode(fragment->document()->compatibilityMode());

}

Document* HTMLTreeBuilder::FragmentParsingContext::document() const

{

    ASSERT(m_fragment);

    return m_dummyDocumentForFragmentParsing.get();

409 ASSERT(!fragment->hasChildNodes());

}

void HTMLTreeBuilder::FragmentParsingContext::finished()

{

    // Populate the DocumentFragment with the parsed content now that we're done.

    ContainerNode* root = m_dummyDocumentForFragmentParsing.get();

    if (m_contextElement)

        root = m_dummyDocumentForFragmentParsing->documentElement();

    m_fragment->takeAllChildrenFrom(root);

    if (!m_contextElement)

        return;

    // The HTML5 spec says to return the children of the fragment's document

    // element when there is a context element (10.4.7).

    RefPtr<ContainerNode> documentElement = m_fragment->firstElementChild();

    m_fragment->removeChildren();

    ASSERT(documentElement);

    m_fragment->takeAllChildrenFrom(documentElement.get());

}

HTMLTreeBuilder::FragmentParsingContext::~FragmentParsingContext()

77988

Source/WebCore/html/parser/HTMLTreeBuilder.h

@@private:

        FragmentParsingContext(DocumentFragment*, Element* contextElement, FragmentScriptingPermission);

        ~FragmentParsingContext();

215 Document* document() const;

        DocumentFragment* fragment() const { return m_fragment; }

        Element* contextElement() const { ASSERT(m_fragment); return m_contextElement; }

        FragmentScriptingPermission scriptingPermission() const { ASSERT(m_fragment); return m_scriptingPermission; }

@@private:

        void finished();

    private:

223 RefPtr<Document> m_dummyDocumentForFragmentParsing;

        DocumentFragment* m_fragment;

        Element* m_contextElement;

77988

LayoutTests/ChangeLog

2011-02-09  Andy Estes  <aestes@apple.com>

        Reviewed by NOBODY (OOPS!).

        HTML5 TreeBuilder regressed a Peacekeeper DOM test by 40%

        https://bugs.webkit.org/show_bug.cgi?id=48719

        * fast/parser/fragment-parser-doctype-expected.txt: Added.

        * fast/parser/fragment-parser-doctype.html: Added.

2011-02-09  Ryosuke Niwa  <rniwa@webkit.org>

        Reviewed by Darin Adler.

78171

LayoutTests/fast/parser/fragment-parser-doctype-expected.txt

Verifying that a fragment's DOCTYPE does not affect parsing:

PASS container.firstChild.nextSibling is null

Verifying that a fragment's DOCTYPE does not change the compatibility mode of the owner document:

PASS container.firstChild.nextSibling is null

PASS successfullyParsed is true

TEST COMPLETE

0

LayoutTests/fast/parser/fragment-parser-doctype.html

<html>

<head>

<link rel="stylesheet" href="../js/resources/js-test-style.css">

<script src="../js/resources/js-test-pre.js"></script>

</head>

<body>

<p id="description"></p>

<div id="console"></div>

<script>

    debug("Verifying that a fragment's DOCTYPE does not affect parsing:");

    var container = document.createElement("div");

    document.body.appendChild(container);

    container.innerHTML = "<!DOCTYPE html><p><table>"

    shouldBeNull("container.firstChild.nextSibling");    

</script>

<p id="test"><table></table>

<script>

    debug ("Verifying that a fragment's DOCTYPE does not change the compatibility mode of the owner document:");

    var test = document.getElementById("test");

    shouldBeNull("container.firstChild.nextSibling");

    var successfullyParsed = true;

</script>

<script src="../js/resources/js-test-post.js"></script>

</body>

</html>

0