ChangeLog

2012-06-12  Hajime Morrita  <morrita@chromium.org>

        [Refactoring] Replace Node's Document pointer with a TreeScope pointer.

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

        Now Node::document() return m_treeScope->rootTreeScope() instead of Node::m_document.

        Each node in shadow tree is no longer need its NodeRareData instance to point the ShadowRoot.

        - Node: Replaced Node::m_docuent with Node::m_treeScope. setDocument() is gone.

        - NodeRareData: Removed m_treeScope

        - TreeScope: Added m_rootTreeScope to make Node::document() fast.

        Reviewed by NOBODY (OOPS!).

        No new tests. No behavioral change.

        * dom/Document.cpp:

        (WebCore::Document::Document):

        (WebCore::Document::~Document):

        (WebCore::Document::suggestedMIMEType):

        * dom/Document.h:

        (WebCore::Node::isDocumentNode):

        (WebCore::Node::document):

        (WebCore::Node::documentInternal):

        (WebCore::Node::Node):

        (WebCore::TreeScope::isDocumentScope):

        * dom/Node.cpp:

        (WebCore::Node::~Node):

        (WebCore::Node::isInShadowTree):

        * dom/Node.h:

        (WebCore::Node::treeScope):

        (WebCore::Node::inDocument):

        (WebCore::Node::setTreeScope):

        * dom/NodeRareData.h:

        (WebCore::NodeRareData::NodeRareData):

        * dom/ShadowRoot.cpp:

        (WebCore::ShadowRoot::ShadowRoot):

        * dom/TreeScope.cpp: Added m_docuent which points the root Document object of the scope tree.

        (WebCore::TreeScope::TreeScope):

        (WebCore::TreeScope::~TreeScope):

        (WebCore::TreeScope::setDocument):

        (WebCore::TreeScope::setParentTreeScope):

        * dom/TreeScope.h:

        (WebCore::TreeScope::document):

        * dom/TreeScopeAdopter.cpp:

        (WebCore::TreeScopeAdopter::moveTreeToNewScope):

        (WebCore::TreeScopeAdopter::moveNodeToNewDocument):

        (WebCore::TreeScopeAdopter::moveNodeListCaches): Extracted.

        * dom/TreeScopeAdopter.h:

2012-06-12  Wei James  <james.wei@intel.com>

        webcore should depend on webcore_arm_neon for only arm target_arch

Source/WebCore/dom/Document.cpp

@@uint64_t Document::s_globalTreeVersion = 0;

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

    : ContainerNode(0, CreateDocument)

429 , TreeScope(this)

429 , TreeScope(this, this)

    , m_guardRefCount(0)

    , m_compatibilityMode(NoQuirksMode)

    , m_compatibilityModeLocked(false)

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

    , m_didDispatchViewportPropertiesChanged(false)

#endif

{

499 m_document = this;

500

    m_pageGroupUserSheetCacheValid = false;

    m_printing = false;

@@Document::~Document()

    // if the DocumentParser outlives the Document it won't cause badness.

    ASSERT(!m_parser || m_parser->refCount() == 1);

    detachParser();

604 m_document = 0;

605

    m_renderArena.clear();

    clearAXObjectCache();

@@void Document::setContent(const String& content)

String Document::suggestedMIMEType() const

{

1338 if (~~m_document->~~isXHTMLDocument())

1334 if (isXHTMLDocument())

13391335 return "application/xhtml+xml";

1340 if (~~m_document->~~isSVGDocument())

1336 if (isSVGDocument())

13411337 return "image/svg+xml";

1342 if (~~m_document->~~xmlStandalone())

1338 if (xmlStandalone())

13431339 return "text/xml";

1344 if (~~m_document->~~isHTMLDocument())

1340 if (isHTMLDocument())

        return "text/html";

    if (DocumentLoader* documentLoader = loader())

Source/WebCore/dom/Document.h

@@private:

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

inline bool Node::isDocumentNode() const

{

    return this == m_document;

}

14981493inline Node::Node(Document* document, ConstructionType type)

14991494 : m_nodeFlags(type)

1500 , m_d~~ocument~~(document)

1495 , m_treeScope(document)

    , m_previous(0)

    , m_next(0)

    , m_renderer(0)

@@inline Node::Node(Document* document, ConstructionType type)

Node* eventTargetNodeForDocument(Document*);

inline Document* Node::document() const

{

    ASSERT(this);

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

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

    ASSERT(m_treeScope->rootDocument() || (nodeType() == DOCUMENT_TYPE_NODE && !inDocument()));

    return m_treeScope->rootDocument();

}

inline bool Node::isTreeScope() const

{

    // FIXME: This should be replaced with IsTreeScope flag once we introduce it in NodeFlags.

    return this == m_treeScope->rootNode();

}

inline bool Node::isDocumentNode() const

{

    return this == m_treeScope->rootDocument();

}

} // namespace WebCore

#endif // Document_h

Source/WebCore/dom/DocumentFragment.cpp

@@namespace WebCore {

DocumentFragment::DocumentFragment(Document* document, ConstructionType constructionType)

    : ContainerNode(document, constructionType)

{

38 ASSERT(document);

}

PassRefPtr<DocumentFragment> DocumentFragment::create(Document* document)

{

42 ASSERT(document);

    return adoptRef(new DocumentFragment(document));

}

Source/WebCore/dom/DocumentType.cpp

@@DocumentType::DocumentType(Document* document, const String& name, const String&

    , m_publicId(publicId)

    , m_systemId(systemId)

{

37 if (!treeScope())

38 setOrphanTreeScope();

}

KURL DocumentType::baseURI() const

@@void DocumentType::removedFrom(ContainerNode* insertionPoint)

    Node::removedFrom(insertionPoint);

}

void Node::setOrphanTreeScope()

{

    ASSERT(!m_treeScope && nodeType() == DOCUMENT_TYPE_NODE);

    m_treeScope = TreeScope::orphanInstance();

}

8391}

Source/WebCore/dom/Node.cpp

@@Node::~Node()

    if (renderer())

        detach();

409 Document* doc = m_document;

409 Document* doc = treeScope() ? document() : 0;

    if (AXObjectCache::accessibilityEnabled() && doc && doc->axObjectCacheExists())

        doc->axObjectCache()->removeNodeForUse(this);

@@Node::~Node()

    InspectorCounters::decrementCounter(InspectorCounters::NodeCounter);

}

void Node::setDocument(Document* document)

{

    ASSERT(!inDocument() || m_document == document);

    if (inDocument() || m_document == document)

        return;

    m_document = document;

}

NodeRareData* Node::setTreeScope(TreeScope* scope)

{

    if (!scope) {

        if (hasRareData()) {

            NodeRareData* data = rareData();

            data->setTreeScope(0);

            return data;

        }

        return 0;

    }

    NodeRareData* data = ensureRareData();

    data->setTreeScope(scope);

    return data;

}

TreeScope* Node::treeScope() const

{

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

    if (!hasRareData())

        return m_document;

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

    return scope ? scope : m_document;

}

NodeRareData* Node::rareData() const

{

    ASSERT(hasRareData());

@@OwnPtr<NodeRareData> Node::createRareData()

void Node::clearRareData()

{

    ASSERT(hasRareData());

485 if (~~treeScope() &&~~ rareData()->nodeLists())

450 if (rareData()->nodeLists())

        treeScope()->removeNodeListCache();

#if ENABLE(MUTATION_OBSERVERS)

@@ContainerNode* Node::nonShadowBoundaryParentNode() const

bool Node::isInShadowTree() const

{

1534 return treeScope() ~~!= d~~ocument();

1499 return !treeScope()->isDocumentScope();

}

Element* Node::parentOrHostElement() const

Source/WebCore/dom/Node.h

@@public:

    virtual bool isFrameOwnerElement() const { return false; }

    bool isDocumentNode() const;

    bool isShadowRoot() const { return getFlag(IsShadowRootFlag); }

220 bool isTreeScope() const;

    bool inNamedFlow() const { return getFlag(InNamedFlowFlag); }

    bool hasAttrList() const { return getFlag(HasAttrListFlag); }

    bool hasCustomCallbacks() const { return getFlag(HasCustomCallbacksFlag); }

@@public:

    // Returns the document associated with this node. This method never returns NULL, except in the case 

    // of a DocumentType node that is not used with any Document yet. A Document node returns itself.

    Document* document() const

    {

        ASSERT(this);

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

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

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

        return m_document;

    }

409 Document* document() const;

416410

417 TreeScope* treeScope() const;

411 TreeScope* treeScope() const { return m_treeScope; }

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

    // node tree, false otherwise.

    bool inDocument() const 

    { 

        ASSERT(m_document || !getFlag(InDocumentFlag));

    bool inDocument() const

    {

        ASSERT(m_treeScope || !getFlag(InDocumentFlag));

        return getFlag(InDocumentFlag);

    }

@@protected:

    void setHasCustomCallbacks() { setFlag(true, HasCustomCallbacksFlag); }

737 void setOrphanTreeScope();

743738private:

739

    friend class TreeShared<Node, ContainerNode>;

    void removedLastRef();

    // These API should be only used for a tree scope migration.

749 // setTreeScope() returns NodeRareData to save extra nodeRareData() invocations on the caller site.

750 NodeRareData* setTreeScope(TreeScope*);

751745 void setDocument(Document*);

746 void setTreeScope(TreeScope* scope) { m_treeScope = scope; }

    enum EditableLevel { Editable, RichlyEditable };

    bool rendererIsEditable(EditableLevel) const;

@@private:

#endif

    mutable uint32_t m_nodeFlags;

795 D~~ocument~~* m_d~~ocument~~;

790 TreeScope* m_treeScope;

    Node* m_previous;

    Node* m_next;

    RenderObject* m_renderer;

Source/WebCore/dom/NodeRareData.h

@@namespace WebCore {

class LabelsNodeList;

class RadioNodeList;

49 class TreeScope;

struct NodeListsNodeData {

    WTF_MAKE_NONCOPYABLE(NodeListsNodeData); WTF_MAKE_FAST_ALLOCATED;

@@class NodeRareData {

    WTF_MAKE_NONCOPYABLE(NodeRareData); WTF_MAKE_FAST_ALLOCATED;

public:    

    NodeRareData()

97 : m_treeScope(0)

98 , m_childNodeList(0)

96 : m_childNodeList(0)

        , m_tabIndex(0)

        , m_tabIndexWasSetExplicitly(false)

        , m_isFocused(false)

@@public:

        return rareDataMap().get(node);

    }

    TreeScope* treeScope() const { return m_treeScope; }

    void setTreeScope(TreeScope* treeScope) { m_treeScope = treeScope; }

    void clearNodeLists() { m_nodeLists.clear(); }

    void setNodeLists(PassOwnPtr<NodeListsNodeData> lists) { m_nodeLists = lists; }

    NodeListsNodeData* nodeLists() const { return m_nodeLists.get(); }

@@protected:

private:

    void createNodeLists(Node*);

267 TreeScope* m_treeScope;

    OwnPtr<NodeListsNodeData> m_nodeLists;

    ChildNodeList* m_childNodeList;

    OwnPtr<EventTargetData> m_eventTargetData;

Source/WebCore/dom/ShadowRoot.cpp

namespace WebCore {

ShadowRoot::ShadowRoot(Document* document)

48 : DocumentFragment(~~document~~, CreateShadowRoot)

49 , TreeScope(this)

48 : DocumentFragment(0, CreateShadowRoot)

49 , TreeScope(this, document)

    , m_prev(0)

    , m_next(0)

    , m_applyAuthorStyles(false)

@@ShadowRoot::ShadowRoot(Document* 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);

60 rootDocument()->guardRef();

}

ShadowRoot::~ShadowRoot()

@@ShadowRoot::~ShadowRoot()

    // as well as Node. See a comment on TreeScope.h for the reason.

    if (hasRareData())

        clearRareData();

72 rootDocument()->guardDeref();

}

static bool allowsAuthorShadowRoot(Element* element)

Source/WebCore/dom/TreeScope.cpp

@@namespace WebCore {

using namespace HTMLNames;

52 TreeScope::TreeScope(ContainerNode* rootNode)

52TreeScope::TreeScope(ContainerNode* rootNode, Document* document)

5353 : m_rootNode(rootNode)

54 , m_parentTreeScope(0)

54 , m_parentTreeScope(rootNode == document ? 0 : document)

55 , m_rootDocument(document)

    , m_numNodeListCaches(0)

{

    ASSERT(rootNode);

    // TreeScope-mixed objects need to control guard-ref count by

    // itself instead of delegating it to Node constructor/destructor

    // because the TreeScope object, which holds the Document reference,

    // is not available at that timing.

    ASSERT(!rootNode->treeScope());

    rootNode->setTreeScope(this);

}

TreeScope::TreeScope()

    : m_rootNode(0)

    , m_parentTreeScope(0)

    , m_rootDocument(0)

    , m_numNodeListCaches(0)

{

}

TreeScope::~TreeScope()

{

    ASSERT(m_rootNode || this == orphanInstance());

    if (m_rootNode) {

        ASSERT(m_rootNode->treeScope() == this);

        m_rootNode->setTreeScope(0);

    }

    if (m_selection) {

        m_selection->clearTreeScope();

        m_selection = 0;

@@void TreeScope::destroyTreeScopeData()

void TreeScope::setParentTreeScope(TreeScope* newParentScope)

{

    // A document node cannot be re-parented.

77 ASSERT(!~~rootNode()->~~isDocumentNode());

98 ASSERT(!isDocumentScope() && !isOrphan());

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

    ASSERT(newParentScope);

    m_parentTreeScope = newParentScope;

103 m_rootDocument = newParentScope->rootDocument();

}

Element* TreeScope::getElementById(const AtomicString& elementId) const

@@HTMLMapElement* TreeScope::getImageMap(const String& url) const

        return 0;

    size_t hashPos = url.find('#');

    String name = (hashPos == notFound ? url : url.substring(hashPos + 1)).impl();

136 if (root~~Node()->d~~ocument()->isHTMLDocument())

158 if (rootDocument()->isHTMLDocument())

        return static_cast<HTMLMapElement*>(m_imageMapsByName.getElementByLowercasedMapName(AtomicString(name.lower()).impl(), this));

    return static_cast<HTMLMapElement*>(m_imageMapsByName.getElementByMapName(AtomicString(name).impl(), this));

}

@@Element* TreeScope::findAnchor(const String& name)

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

        if (node->hasTagName(aTag)) {

            HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(node);

175 if (root~~Node()->d~~ocument()->inQuirksMode()) {

197 if (rootDocument()->inQuirksMode()) {

                // Quirks mode, case insensitive comparison of names.

                if (equalIgnoringCase(anchor->name(), name))

                    return anchor;

@@void TreeScope::adoptIfNeeded(Node* node)

    ASSERT(node);

    ASSERT(!node->isDocumentNode());

    ASSERT(!node->m_deletionHasBegun);

227 ASSERT(!isOrphan());

    TreeScopeAdopter adopter(node, this);

    if (adopter.needsScopeChange())

        adopter.execute();

@@static Node* focusedFrameOwnerElement(Frame* focusedFrame, Frame* currentFrame)

Node* TreeScope::focusedNode()

{

244 ASSERT(!isOrphan());

245

    Document* document = rootNode()->document();

    Node* node = document->focusedNode();

    if (!node && document->page())

@@TreeScope* commonTreeScope(Node* nodeA, Node* nodeB)

    return treeScopesA[indexA] == treeScopesB[indexB] ? treeScopesA[indexA] : 0;

}

TreeScope* TreeScope::orphanInstance()

{

    DEFINE_STATIC_LOCAL(TreeScope, instance, ());

    return &instance;

}

273304} // namespace WebCore

274305

Source/WebCore/dom/TreeScope.h

@@namespace WebCore {

class ContainerNode;

class DOMSelection;

37class Document;

class Element;

class HTMLMapElement;

class Node;

@@class TreeScope {

    friend class Document;

public:

49 static TreeScope* orphanInstance();

50

4851 TreeScope* parentTreeScope() const { return m_parentTreeScope; }

4952 void setParentTreeScope(TreeScope*);

    Document* rootDocument() const { return m_rootDocument; }

    ContainerNode* rootNode() const { return m_rootNode; }

    bool isDocumentScope() const;

    Node* focusedNode();

    Element* getElementById(const AtomicString&) const;

@@public:

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

    void adoptIfNeeded(Node*);

83 ContainerNode* rootNode() const { return m_rootNode; }

84

8589protected:

86 TreeScope(ContainerNode*);

90 TreeScope(ContainerNode*, Document*);

    virtual ~TreeScope();

    void destroyTreeScopeData();

94 bool isOrphan() const { return this == orphanInstance(); }

9095

9196private:

97 TreeScope();

98

9299 ContainerNode* m_rootNode;

93100 TreeScope* m_parentTreeScope;

    // m_rootDocument is a cache and should be synced with m_parentTreeScope->rootDocument()

    // except m_parentTreeScope is null, which means this is a root scope.

    Document* m_rootDocument;

    DocumentOrderedMap m_elementsById;

    DocumentOrderedMap m_imageMapsByName;

@@inline bool TreeScope::containsMultipleElementsWithId(const AtomicString& id) co

TreeScope* commonTreeScope(Node*, Node*);

inline bool TreeScope::isDocumentScope() const

{

    return !m_parentTreeScope;

}

} // namespace WebCore

#endif // TreeScope_h

Source/WebCore/dom/TreeScopeAdopter.cpp

@@void TreeScopeAdopter::moveTreeToNewScope(Node* root) const

    // that element may contain stale data as changes made to it will have updated the DOMTreeVersion

    // of the document it was moved to. By increasing the DOMTreeVersion of the donating document here

    // we ensure that the collection cache will be invalidated as needed when the element is moved back.

48 Document* oldDocument = m_oldScope ~~? m_oldScope~~->root~~Node()->d~~ocument() ~~: 0~~;

49 Document* newDocument = m_newScope->root~~Node()->d~~ocument();

48 Document* oldDocument = m_oldScope->rootDocument();

49 Document* newDocument = m_newScope->rootDocument();

    bool willMoveToNewDocument = oldDocument != newDocument;

    if (oldDocument && willMoveToNewDocument)

        oldDocument->incDOMTreeVersion();

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

        NodeRareData* rareData = node->setTreeScope(newDocument == m_newScope ? 0 : m_newScope);

        if (rareData && rareData->nodeLists()) {

            rareData->nodeLists()->invalidateCaches();

            if (m_oldScope)

                m_oldScope->removeNodeListCache();

            m_newScope->addNodeListCache();

        }

55 node->setTreeScope(m_newScope);

56 moveNodeListCaches(node);

        if (willMoveToNewDocument)

            moveNodeToNewDocument(node, oldDocument, newDocument);

@@inline void TreeScopeAdopter::moveNodeToNewDocument(Node* node, Document* oldDoc

    if (oldDocument)

        oldDocument->moveNodeIteratorsToNewDocument(node, newDocument);

103 node->setDocument(newDocument);

104

#ifndef NDEBUG

    didMoveToNewDocumentWasCalled = false;

    oldDocumentDidMoveToNewDocumentWasCalledWith = oldDocument;

@@inline void TreeScopeAdopter::moveNodeToNewDocument(Node* node, Document* oldDoc

        oldDocument->guardDeref();

}

inline void TreeScopeAdopter::moveNodeListCaches(Node* node) const

{

    if (!node->hasRareData())

        return;

    NodeRareData* rareData = node->rareData();

    if (!rareData->nodeLists())

        return;

    rareData->nodeLists()->invalidateCaches();

    m_oldScope->removeNodeListCache();

    m_newScope->addNodeListCache();

}

117121}

Source/WebCore/dom/TreeScopeAdopter.h

@@public:

private:

    void moveTreeToNewScope(Node*) const;

47 void moveNodeListCaches(Node*) const;

    void moveTreeToNewDocument(Node*, Document* oldDocument, Document* newDocument) const;

    void moveNodeToNewDocument(Node*, Document* oldDocument, Document* newDocument) const;

Source/WebCore/editing/MoveSelectionCommand.cpp

#include "config.h"

#include "MoveSelectionCommand.h"

29#include "Document.h"

#include "DocumentFragment.h"

#include "ReplaceSelectionCommand.h"

Source/WebCore/editing/RemoveNodeCommand.cpp

#include "config.h"

#include "RemoveNodeCommand.h"

29#include "Document.h"

#include "Node.h"

#include <wtf/Assertions.h>

Source/WebCore/editing/RemoveNodePreservingChildrenCommand.cpp

#include "config.h"

#include "RemoveNodePreservingChildrenCommand.h"

29#include "Document.h"

#include "Node.h"

#include <wtf/Assertions.h>