Document.cpp

@@uint64_t Document::s_globalTreeVersion = 0;

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

    : ContainerNode(0, CreateDocument)

431 , TreeScope(this)

431 , TreeScope(this, this)

    , m_guardRefCount(0)

    , m_contextFeatures(ContextFeatures::defaultSwitch())

    , m_compatibilityMode(NoQuirksMode)

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

    , m_didDispatchViewportPropertiesChanged(false)

#endif

{

502 m_document = this;

502 setTreeScope(this);

503 setRootDocument(this);

    m_pageGroupUserSheetCacheValid = false;

@@Document::~Document()

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

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

    detachParser();

609 m_d~~ocument~~ = 0;

610 m_treeScope = 0;

    m_renderArena.clear();

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

String Document::suggestedMIMEType() const

{

1344 if (m_document->isXHTMLDocument())

1345 Document* doc = document();

1346 if (doc->isXHTMLDocument())

13451347 return "application/xhtml+xml";

1346 if (m_doc~~ument~~->isSVGDocument())

1348 if (doc->isSVGDocument())

13471349 return "image/svg+xml";

1348 if (m_doc~~ument~~->xmlStandalone())

1350 if (doc->xmlStandalone())

13491351 return "text/xml";

1350 if (m_doc~~ument~~->isHTMLDocument())

1352 if (doc->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 Document* Node::documentInternal() const

{

    if (!m_treeScope)

        return 0;

    return m_treeScope->rootDocument();

}

inline Document* Node::document() const

{

    Document* document = documentInternal();

    // 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(document || (nodeType() == DOCUMENT_TYPE_NODE && !inDocument()));

    return document;

}

15041520inline bool Node::isDocumentNode() const

15051521{

1506 return this == m_document;

1522 return this == documentInternal();

}

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

    : m_nodeFlags(type)

1511 , m_d~~ocument~~(document)

1527 , m_treeScope(document)

    , m_previous(0)

    , m_next(0)

    , m_renderer(0)

Source/WebCore/dom/Node.cpp

@@Node::~Node()

    if (renderer())

        detach();

409 Document* doc = m_document;

409 Document* doc = documentInternal();

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

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

@@Node::~Node()

    InspectorCounters::decrementCounter(InspectorCounters::NodeCounter);

}

424 void Node::setDo~~cument(Document~~* d~~ocument~~)

424void Node::setTreeScope(TreeScope* scope)

425425{

    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;

426 m_treeScope = scope;

}

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;

431 return m_treeScope;

}

NodeRareData* Node::rareData() const

@@void Node::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const

    memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);

    TreeShared<Node, ContainerNode>::reportMemoryUsage(memoryObjectInfo);

    ScriptWrappable::reportMemoryUsage(memoryObjectInfo);

2808 memoryObjectInfo->reportPointer(m_document, MemoryInstrumentation::DOM);

2783 memoryObjectInfo->reportPointer(document(), MemoryInstrumentation::DOM);

    memoryObjectInfo->reportInstrumentedPointer(m_next);

    memoryObjectInfo->reportInstrumentedPointer(m_previous);

}

Source/WebCore/dom/Node.h

@@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;

    }

410 Document* document() const;

    TreeScope* treeScope() const;

@@public:

    // node tree, false otherwise.

    bool inDocument() const 

    { 

425 ASSERT(m_d~~ocument~~ || !getFlag(InDocumentFlag));

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

        return getFlag(InDocumentFlag);

    }

@@protected:

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

    void setTreeScope(TreeScope*);

    Document* documentInternal() const;

private:

    friend class TreeShared<Node, ContainerNode>;

    void removedLastRef();

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

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

    NodeRareData* setTreeScope(TreeScope*);

    void setDocument(Document*);

    enum EditableLevel { Editable, RichlyEditable };

    bool rendererIsEditable(EditableLevel) const;

    bool isEditableToAccessibility(EditableLevel) const;

@@private:

#endif

    mutable uint32_t m_nodeFlags;

788 D~~ocument~~* m_d~~ocument~~;

779 TreeScope* m_treeScope;

    Node* m_previous;

    Node* m_next;

    RenderObject* m_renderer;

Source/WebCore/dom/NodeRareData.h

@@class NodeRareData {

    WTF_MAKE_NONCOPYABLE(NodeRareData); WTF_MAKE_FAST_ALLOCATED;

public:    

    NodeRareData()

183 : m_treeScope(0)

184 , m_childNodeList(0)

183 : 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*);

353 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)

    : DocumentFragment(document, CreateShadowRoot)

49 , TreeScope(this)

49 , TreeScope(this, document)

    , m_prev(0)

    , m_next(0)

    , m_applyAuthorStyles(false)

@@ShadowRoot::ShadowRoot(Document* document)

    setParentTreeScope(document);

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

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

62 ~~ensureRareData()->~~setTreeScope(this);

62 setTreeScope(this);

}

ShadowRoot::~ShadowRoot()

Source/WebCore/dom/TreeScope.cpp

@@namespace WebCore {

using namespace HTMLNames;

54 TreeScope::TreeScope(ContainerNode* rootNode)

54TreeScope::TreeScope(ContainerNode* rootNode, Document* rootDocument)

5555 : m_rootNode(rootNode)

56 , m_rootDocument(rootDocument)

    , m_parentTreeScope(0)

    , m_numNodeListCaches(0)

{

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

    ASSERT(newParentScope);

    m_parentTreeScope = newParentScope;

85 m_rootDocument = newParentScope->rootDocument();

}

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

Source/WebCore/dom/TreeScope.h

@@namespace WebCore {

class ContainerNode;

class DOMSelection;

37class Document;

class Element;

class HTMLMapElement;

class Node;

@@public:

    void adoptIfNeeded(Node*);

    ContainerNode* rootNode() const { return m_rootNode; }

85 Document* rootDocument() const { return m_rootDocument; }

86 void setRootDocument(Document* document) { m_rootDocument = document; }

8487

8588protected:

86 TreeScope(ContainerNode*);

89 TreeScope(ContainerNode*, Document*);

    virtual ~TreeScope();

    void destroyTreeScopeData();

private:

    ContainerNode* m_rootNode;

96 Document* m_rootDocument;

    TreeScope* m_parentTreeScope;

    DocumentOrderedMap m_elementsById;

Source/WebCore/dom/TreeScopeAdopter.cpp

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

        oldDocument->incDOMTreeVersion();

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

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

50 node->setTreeScope(m_newScope);

51 NodeRareData* rareData = node->hasRareData() ? node->rareData() : 0;

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

            rareData->nodeLists()->adoptTreeScope(m_oldScope, m_newScope, oldDocument, newDocument);

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

    if (oldDocument)

        oldDocument->moveNodeIteratorsToNewDocument(node, newDocument);

94 node->setDocument(newDocument);

95

#ifndef NDEBUG

    didMoveToNewDocumentWasCalled = false;

    oldDocumentDidMoveToNewDocumentWasCalledWith = oldDocument;