ChangeLog

2011-04-13  Roland Steiner  <rolandsteiner@chromium.org>

        Reviewed by NOBODY (OOPS!).

        Bug 52963 - Enable O(1) access to root from any node in shadow DOM subtree

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

        .) Change base class of ShadowRoot from DocumentFragment to TreeScope.

        .) Re-enable tree scope handling in Node (had ASSERT_NOT_REACHED, etc.).

        .) Merged setTreeScope() with setTreeScopeRecursively()

        .) Call setTreeScopeRecursively in DOM manipulation functions where applicable.

        No new tests. (No new functionality)

        * dom/ContainerNode.cpp: call setTreeScopeRecursively() to update current containing scope

        (WebCore::ContainerNode::removeAllChildren):

        (WebCore::ContainerNode::takeAllChildrenFrom):

        (WebCore::ContainerNode::removeBetween):

        (WebCore::ContainerNode::removeChildren):

        (WebCore::ContainerNode::parserAddChild):

        * dom/Document.cpp:

        (WebCore::Document::Document):

        (WebCore::Document::~Document):

        (WebCore::Document::removedLastRef):

        (WebCore::Document::setDocType):

        * dom/Document.h:

        * dom/Element.h:

        * dom/Node.cpp: 

        (WebCore::Node::treeScope):

        (WebCore::Node::setTreeScopeRecursively): merge setTreeScope()

        * dom/Node.h:

        (WebCore::Node::document):

        * dom/ShadowRoot.cpp:

        (WebCore::ShadowRoot::ShadowRoot):

        (WebCore::ShadowRoot::~ShadowRoot):

        (WebCore::ShadowRoot::nodeName):

        (WebCore::ShadowRoot::nodeType):

        (WebCore::ShadowRoot::cloneNode):

        (WebCore::ShadowRoot::childTypeAllowed):

        * dom/ShadowRoot.h:

        (WebCore::toShadowRoot):

        * dom/TreeScope.cpp:

        (WebCore::TreeScope::TreeScope):

        (WebCore::TreeScope::setParentTreeScope):

        * dom/TreeScope.h:

        * rendering/RenderSlider.cpp:

2011-04-12  Pavel Podivilov  <podivilov@chromium.org>

        Reviewed by Pavel Feldman.

Source/WebCore/dom/ContainerNode.cpp

@@static void collectTargetNodes(Node* node, NodeVector& nodes)

void ContainerNode::removeAllChildren()

{

76 // Note that we do NOT set the tree scope to document here, because this function is usu. called

77 // when the children should be destroyed anyway. Call setTreeScopeRecursively where this is not the case.

    removeAllChildrenInContainer<Node, ContainerNode>(this);

}

@@void ContainerNode::takeAllChildrenFrom(ContainerNode* oldParent)

        RefPtr<Node> child = document()->adoptNode(children[i].release(), ec);

        ASSERT(!ec);

        parserAddChild(child.get());

        // FIXME: Together with adoptNode above, the tree scope might get updated recursively twice

        // (if the document changed or oldParent was in a shadow tree, AND *this is in a shadow tree).

        // Can we do better?

        child->setTreeScopeRecursively(treeScope());

        if (attached() && !child->attached())

            child->attach();

    }

@@void ContainerNode::removeBetween(Node* previousChild, Node* nextChild, Node* ol

    oldChild->setNextSibling(0);

    oldChild->setParent(0);

490 oldChild->setTreeScopeRecursively(document());

491

    allowEventDispatch();

}

@@void ContainerNode::removeChildren()

        n->setPreviousSibling(0);

        n->setNextSibling(0);

        n->setParent(0);

541 n->setTreeScopeRecursively(document());

        m_firstChild = next;

        if (n == m_lastChild)

@@void ContainerNode::parserAddChild(PassRefPtr<Node> newChild)

    Node* last = m_lastChild;

    // FIXME: This method should take a PassRefPtr.

    appendChildToContainer<Node, ContainerNode>(newChild.get(), this);

660 newChild->setTreeScopeRecursively(treeScope());

661

    allowEventDispatch();

    // FIXME: Why doesn't this use notifyChildInserted(newChild) instead?

Source/WebCore/dom/Document.cpp

@@private:

uint64_t Document::s_globalTreeVersion = 0;

Document::Document(Frame* frame, const KURL& url, bool isXHTML, bool isHTML)

380 : TreeScope(~~this~~)

380 : TreeScope(0)

    , m_guardRefCount(0)

    , m_compatibilityMode(NoQuirksMode)

    , m_compatibilityModeLocked(false)

@@Document::Document(Frame* frame, const KURL& url, bool isXHTML, bool isHTML)

    , m_writingModeSetOnDocumentElement(false)

    , m_writeRecursionIsTooDeep(false)

    , m_writeRecursionDepth(0)

#ifndef NDEBUG

    , m_tearDownHasBegun(false)

#endif

439442{

443

    m_document = this;

    m_pageGroupUserSheetCacheValid = false;

@@Document::Document(Frame* frame, const KURL& url, bool isXHTML, bool isHTML)

Document::~Document()

{

518 ASSERT(m_tearDownHasBegun);

    ASSERT(!renderer());

    ASSERT(!m_inPageCache);

    ASSERT(!m_savedRenderer);

    ASSERT(m_ranges.isEmpty());

    ASSERT(!m_styleRecalcTimer.isActive());

    ASSERT(!m_parentTreeScope);

525 ASSERT(m_guardRefCount == 0);

    m_scriptRunner.clear();

@@Document::~Document()

void Document::removedLastRef()

{

    ASSERT(!m_deletionHasBegun);

    ASSERT(!m_tearDownHasBegun);

#ifndef NDEBUG

    m_tearDownHasBegun = true;

#endif

    if (m_guardRefCount) {

        // If removing a child removes the last self-only ref, we don't

        // want the scope to be destructed until after

@@void Document::removedLastRef()

        destroyTreeScopeData();

        removeAllChildren();

609 ASSERT(m_markers);

599610 m_markers->detach();

611 m_markers = 0;

        detachParser();

@@void Document::setDocType(PassRefPtr<DocumentType> docType)

    ASSERT(!m_docType || !docType);

    m_docType = docType;

    if (m_docType)

704 m_docType->setTreeScope(this);

716 m_docType->setTreeScopeRecursively(this);

}

DOMImplementation* Document::implementation()

Source/WebCore/dom/Document.h

@@private:

#endif

    RefPtr<ContentSecurityPolicy> m_contentSecurityPolicy;

#ifndef NDEBUG

    bool m_tearDownHasBegun;

#endif

};

// Put these methods here, because they require the Document definition, but we really want to inline them.

Source/WebCore/dom/Element.h

@@class DOMStringMap;

class DOMTokenList;

class ElementRareData;

class IntSize;

42class ShadowRoot;

class WebKitAnimationList;

enum SpellcheckAttributeState {

@@public:

    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

    virtual void recalcStyle(StyleChange = NoChange);

233 // FIXME: Make these return a proper ShadowRoot* (requires changes wrt. WebDOMOperations.h).

    ContainerNode* shadowRoot() const;

    ContainerNode* ensureShadowRoot();

    void removeShadowRoot();

Source/WebCore/dom/Node.cpp

#include "ScopedEventQueue.h"

#include "ScriptController.h"

#include "SelectorNodeList.h"

80#include "ShadowRoot.h"

#include "StaticNodeList.h"

#include "TagNodeList.h"

#include "Text.h"

@@void Node::setDocument(Document* document)

TreeScope* Node::treeScope() const

{

476 // FIXME: Using m_document directly is not good -> see comment with document() in the header file.

475477 if (!hasRareData())

476 return document();

478 return m_document;

477479 TreeScope* scope = rareData()->treeScope();

    // FIXME: Until we land shadow scopes, there should be no non-document scopes.

    ASSERT(!scope);

    return scope ? scope : document();

480 return scope ? scope : m_document;

481481}

482482

483 void Node::setTreeScope(TreeScope* newTreeScope)

483void Node::setTreeScopeRecursively(TreeScope* newTreeScope, bool includeRoot)

484484{

485 ASSERT(!isDocumentNode());

485 ASSERT(this);

486 ASSERT(!includeRoot || !isDocumentNode());

486487 ASSERT(newTreeScope);

487 ASSERT(!i~~nDocument() || treeScope() == newTreeScope~~);

488 ASSERT(!m_deletionHasBegun);

488489

    if (newTreeScope->isDocumentNode()) {

        if (hasRareData())

            rareData()->setTreeScope(0);

        // Setting the new document scope will be handled implicitly

        // by setDocument() below.

    } else {

        // FIXME: Until we land shadow scopes, this branch should be inert.

        ASSERT_NOT_REACHED();

        ensureRareData()->setTreeScope(newTreeScope);

    }

    setDocument(newTreeScope->document());

}

void Node::setTreeScopeRecursively(TreeScope* newTreeScope)

{

    ASSERT(!isDocumentNode());

    ASSERT(newTreeScope);

    if (treeScope() == newTreeScope)

490 TreeScope* currentTreeScope = treeScope();

491 if (currentTreeScope == newTreeScope)

        return;

    Document* currentDocument = document();

@@void Node::setTreeScopeRecursively(TreeScope* newTreeScope)

    if (currentDocument && currentDocument != newDocument)

        currentDocument->incDOMTreeVersion();

    for (Node* node = this; node; node = node->traverseNextNode(this)) {

        node->setTreeScope(newTreeScope);

        // FIXME: Once shadow scopes are landed, update parent scope, etc.

    for (Node* node = includeRoot ? this : traverseNextNode(this); node; node = node->traverseNextNode(this)) {

        if (newTreeScope == newDocument) {

            if (node->hasRareData())

                node->rareData()->setTreeScope(0);

            // Setting the new document tree scope will be handled implicitly

            // by setDocument() below.

        } else {

            node->ensureRareData()->setTreeScope(newTreeScope);

        }

        node->setDocument(newDocument);

        if (!node->isElementNode())

            continue;

        // FIXME: Remove toShadowRoot() once shadowRoot() returns a proper ShadowRoot*.

        if (ShadowRoot* shadowRoot = toShadowRoot(toElement(node)->shadowRoot())) {

            shadowRoot->setParentTreeScope(newTreeScope);

            if (currentDocument != newDocument)

                shadowRoot->setDocumentRecursively(newDocument);

        }

    }

}

Source/WebCore/dom/Node.h

@@public:

    Document* document() const

    {

        ASSERT(this);

353 // FIXME: below ASSERT is useful, but prevents the use of document() in the constructor or destructor

354 // due to the virtual function call to nodeType().

        ASSERT(m_document || (nodeType() == DOCUMENT_TYPE_NODE && !inDocument()));

        return m_document;

    }

    TreeScope* treeScope() const;

    // Do not use this method to change the scope of a node until after the node has been

    // removed from its previous scope. Do not use to change documents.

    void setTreeScope(TreeScope*);

363361 // Used by the basic DOM methods (e.g., appendChild()).

364 void setTreeScopeRecursively(TreeScope*);

362 void setTreeScopeRecursively(TreeScope*, bool includeRoot = true);

    // Returns true if this node is associated with a document and is in its associated document's

    // node tree, false otherwise.

Source/WebCore/dom/ShadowRoot.cpp

#include "config.h"

#include "ShadowRoot.h"

#include "Document.h"

#include "NodeRareData.h"

namespace WebCore {

ShadowRoot::ShadowRoot(Document* document)

33 : D~~ocumentFragment~~(document)

36 : TreeScope(document)

3437{

3538 ASSERT(document);

    
    // Assume document as parent scope.

    setParentTreeScope(document);

    // Shadow tree scopes have the scope pointer point to themselves.

    // This way, direct children will receive the correct scope pointer.

    ensureRareData()->setTreeScope(this);

}

ShadowRoot::~ShadowRoot()

{

}

String ShadowRoot::nodeName() const

{

    // FIXME: Decide correct node name.

    return "#shadow-root";

}

Node::NodeType ShadowRoot::nodeType() const

{

    // FIXME: Decide correct node type.

    return DOCUMENT_FRAGMENT_NODE;

}

PassRefPtr<Node> ShadowRoot::cloneNode(bool /*deep*/)

{

    // ShadowRoot should not be arbitrarily cloned.

    return 0;

}

bool ShadowRoot::childTypeAllowed(NodeType type)

{

    switch (type) {

        case ELEMENT_NODE:

        case PROCESSING_INSTRUCTION_NODE:

        case COMMENT_NODE:

        case TEXT_NODE:

        case CDATA_SECTION_NODE:

        case ENTITY_REFERENCE_NODE:

            return true;

        default:

            return false;

    }

}

void ShadowRoot::recalcStyle(StyleChange change)

Source/WebCore/dom/ShadowRoot.h

#ifndef ShadowRoot_h

#define ShadowRoot_h

30 #include "D~~ocumentFragment~~.h"

30#include "TreeScope.h"

namespace WebCore {

class Document;

36 class ShadowRoot : public D~~ocumentFragment~~ {

36class ShadowRoot : public TreeScope {

public:

    static PassRefPtr<ShadowRoot> create(Document*);

@@public:

private:

    ShadowRoot(Document*);

    virtual ~ShadowRoot();

    virtual String nodeName() const;

    virtual NodeType nodeType() const;

    virtual PassRefPtr<Node> cloneNode(bool deep);

    virtual bool childTypeAllowed(NodeType);

};

inline PassRefPtr<ShadowRoot> ShadowRoot::create(Document* document)

@@inline PassRefPtr<ShadowRoot> ShadowRoot::create(Document* document)

    return adoptRef(new ShadowRoot(document));

}

inline ShadowRoot* toShadowRoot(Node* node)

{

    ASSERT(!node || node->isShadowBoundary());

    return static_cast<ShadowRoot*>(node);

}

inline const ShadowRoot* toShadowRoot(const Node* node)

{

    ASSERT(!node || node->isShadowBoundary());

    return static_cast<const ShadowRoot*>(node);

}

} // namespace

#endif

Source/WebCore/dom/TreeScope.cpp

@@namespace WebCore {

using namespace HTMLNames;

39 TreeScope::TreeScope(Document* document~~, ConstructionType constructionType~~)

40 : ContainerNode(0, cons~~tructionType~~)

39TreeScope::TreeScope(Document* document)

40 : ContainerNode(document)

    , m_parentTreeScope(0)

    , m_accessKeyMapValid(false)

    , m_numNodeListCaches(0)

{

    m_document = document;

    if (document != this) {

        // Assume document as parent scope

        m_parentTreeScope = document;

        // FIXME: This branch should be inert until shadow scopes are landed.

        ASSERT_NOT_REACHED();

    }

}

TreeScope::~TreeScope()

@@void TreeScope::setParentTreeScope(TreeScope* newParentScope)

    // A document node cannot be re-parented.

    ASSERT(!isDocumentNode());

    // Every scope other than document needs a parent scope.

72 ASSERT(m_parentTreeScope);

    ASSERT(newParentScope);

    m_parentTreeScope = newParentScope;

Source/WebCore/dom/TreeScope.h

@@class HTMLMapElement;

class TreeScope : public ContainerNode {

    friend class Document;

39 friend class Node;

public:

    TreeScope* parentTreeScope() const { return m_parentTreeScope; }

@@public:

    Element* findAnchor(const String& name);

protected:

68 TreeScope(Document*~~, ConstructionType = CreateContainer~~);

69 TreeScope(Document*);

    virtual ~TreeScope();

Source/WebCore/rendering/RenderSlider.cpp

#include "RenderLayer.h"

#include "RenderTheme.h"

#include "RenderView.h"

40 #include "Shadow~~Elemen~~t.h"

40#include "ShadowRoot.h"

#include "SliderThumbElement.h"

#include "StepRange.h"

#include <wtf/MathExtras.h>