WebCore/dom/Document.h

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
   6  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   7  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public License
  20  * along with this library; see the file COPYING.LIB.  If not, write to
  21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  *
  24  */
  25
  26 #ifndef Document_h
  27 #define Document_h
  28
  29 #include "Attr.h"
  30 #include "Color.h"
  31 #include "DocumentMarker.h"
  32 #include "HTMLCollection.h"
  33 #include "HTMLFormElement.h"
  34 #include "ScriptExecutionContext.h"
  35 #include "StringHash.h"
  36 #include "Timer.h"
  37 #include <wtf/HashCountedSet.h>
  38 #include <wtf/ListHashSet.h>
  39
  40 // FIXME: We should move Mac off of the old Frame-based user stylesheet loading
  41 // code and onto the new code in Page. We can't do that until the code in Page
  42 // supports non-file: URLs, however.
  43 #if PLATFORM(MAC) || PLATFORM(QT)
  44 #define FRAME_LOADS_USER_STYLESHEET 1
  45 #else
  46 #define FRAME_LOADS_USER_STYLESHEET 0
  47 #endif
  48
  49 namespace WebCore {
  50
  51     class AXObjectCache;
  52     class Attr;
  53     class Attribute;
  54     class CDATASection;
  55     class CachedCSSStyleSheet;
  56     class CanvasRenderingContext2D;
  57     class CharacterData;
  58     class CSSStyleDeclaration;
  59     class CSSStyleSelector;
  60     class CSSStyleSheet;
  61     class Comment;
  62     class Database;
  63     class DOMImplementation;
  64     class DOMSelection;
  65     class DOMWindow;
  66     class DatabaseThread;
  67     class DocLoader;
  68     class DocumentFragment;
  69     class DocumentType;
  70     class EditingText;
  71     class Element;
  72     class EntityReference;
  73     class Event;
  74     class EventListener;
  75     class FormControlElementWithState;
  76     class Frame;
  77     class FrameView;
  78     class HitTestRequest;
  79     class HTMLCanvasElement;
  80     class HTMLDocument;
  81     class HTMLElement;
  82     class HTMLFormElement;
  83     class HTMLHeadElement;
  84     class HTMLInputElement;
  85     class HTMLMapElement;
  86     class IntPoint;
  87     class JSNode;
  88     class MouseEventWithHitTestResults;
  89     class NodeFilter;
  90     class NodeIterator;
  91     class Page;
  92     class PlatformMouseEvent;
  93     class ProcessingInstruction;
  94     class Range;
  95     class RegisteredEventListener;
  96     class RenderArena;
  97     class RenderView;
  98     class SecurityOrigin;
  99     class SegmentedString;
 100     class Settings;
 101     class StyleSheet;
 102     class StyleSheetList;
 103     class Text;
 104     class TextResourceDecoder;
 105     class Tokenizer;
 106     class TreeWalker;
 107     class XMLHttpRequest;
 108
 109 #if ENABLE(SVG)
 110     class SVGDocumentExtensions;
 111 #endif
 112
 113 #if ENABLE(XBL)
 114     class XBLBindingManager;
 115 #endif
 116
 117 #if ENABLE(XPATH)
 118     class XPathEvaluator;
 119     class XPathExpression;
 120     class XPathNSResolver;
 121     class XPathResult;
 122 #endif
 123
 124 #if ENABLE(DASHBOARD_SUPPORT)
 125     struct DashboardRegionValue;
 126 #endif
 127
 128     typedef int ExceptionCode;
 129
 130 class FormElementKey {
 131 public:
 132     FormElementKey(AtomicStringImpl* = 0, AtomicStringImpl* = 0);
 133     ~FormElementKey();
 134     FormElementKey(const FormElementKey&);
 135     FormElementKey& operator=(const FormElementKey&);
 136
 137     AtomicStringImpl* name() const { return m_name; }
 138     AtomicStringImpl* type() const { return m_type; }
 139
 140     // Hash table deleted values, which are only constructed and never copied or destroyed.
 141     FormElementKey(WTF::HashTableDeletedValueType) : m_name(hashTableDeletedValue()) { }
 142     bool isHashTableDeletedValue() const { return m_name == hashTableDeletedValue(); }
 143
 144 private:
 145     void ref() const;
 146     void deref() const;
 147
 148     static AtomicStringImpl* hashTableDeletedValue() { return reinterpret_cast<AtomicStringImpl*>(-1); }
 149
 150     AtomicStringImpl* m_name;
 151     AtomicStringImpl* m_type;
 152 };
 153
 154 inline bool operator==(const FormElementKey& a, const FormElementKey& b)
 155 {
 156     return a.name() == b.name() && a.type() == b.type();
 157 }
 158
 159 struct FormElementKeyHash {
 160     static unsigned hash(const FormElementKey&);
 161     static bool equal(const FormElementKey& a, const FormElementKey& b) { return a == b; }
 162     static const bool safeToCompareToEmptyOrDeleted = true;
 163 };
 164
 165 struct FormElementKeyHashTraits : WTF::GenericHashTraits<FormElementKey> {
 166     static void constructDeletedValue(FormElementKey& slot) { new (&slot) FormElementKey(WTF::HashTableDeletedValue); }
 167     static bool isDeletedValue(const FormElementKey& value) { return value.isHashTableDeletedValue(); }
 168 };
 169
 170 class Document : public ContainerNode, public ScriptExecutionContext {
 171 public:
 172     static PassRefPtr<Document> create(Frame* frame)
 173     {
 174         return new Document(frame, false);
 175     }
 176     static PassRefPtr<Document> createXHTML(Frame* frame)
 177     {
 178         return new Document(frame, true);
 179     }
 180     virtual ~Document();
 181
 182     virtual bool isDocument() const { return true; }
 183
 184     using ContainerNode::ref;
 185     using ContainerNode::deref;
 186     virtual void removedLastRef();
 187
 188     // Nodes belonging to this document hold "self-only" references -
 189     // these are enough to keep the document from being destroyed, but
 190     // not enough to keep it from removing its children. This allows a
 191     // node that outlives its document to still have a valid document
 192     // pointer without introducing reference cycles
 193
 194     void selfOnlyRef()
 195     {
 196         ASSERT(!m_deletionHasBegun);
 197         ++m_selfOnlyRefCount;
 198     }
 199     void selfOnlyDeref()
 200     {
 201         ASSERT(!m_deletionHasBegun);
 202         --m_selfOnlyRefCount;
 203         if (!m_selfOnlyRefCount && !refCount()) {
 204 #ifndef NDEBUG
 205             m_deletionHasBegun = true;
 206 #endif
 207             delete this;
 208         }
 209     }
 210
 211     // DOM methods & attributes for Document
 212
 213     DocumentType* doctype() const { return m_docType.get(); }
 214
 215     DOMImplementation* implementation() const;
 216     virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
 217
 218     Element* documentElement() const
 219     {
 220         if (!m_documentElement)
 221             cacheDocumentElement();
 222         return m_documentElement.get();
 223     }
 224
 225     virtual PassRefPtr<Element> createElement(const AtomicString& tagName, ExceptionCode&);
 226     PassRefPtr<DocumentFragment> createDocumentFragment ();
 227     PassRefPtr<Text> createTextNode(const String& data);
 228     PassRefPtr<Comment> createComment(const String& data);
 229     PassRefPtr<CDATASection> createCDATASection(const String& data, ExceptionCode&);
 230     PassRefPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionCode&);
 231     PassRefPtr<Attr> createAttribute(const String& name, ExceptionCode& ec) { return createAttributeNS(String(), name, ec, true); }
 232     PassRefPtr<Attr> createAttributeNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&, bool shouldIgnoreNamespaceChecks = false);
 233     PassRefPtr<EntityReference> createEntityReference(const String& name, ExceptionCode&);
 234     PassRefPtr<Node> importNode(Node* importedNode, bool deep, ExceptionCode&);
 235     virtual PassRefPtr<Element> createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&);
 236     PassRefPtr<Element> createElement(const QualifiedName&, bool createdByParser);
 237     Element* getElementById(const AtomicString&) const;
 238     bool hasElementWithId(AtomicStringImpl* id) const;
 239     bool containsMultipleElementsWithId(const AtomicString& elementId) { return m_duplicateIds.contains(elementId.impl()); }
 240
 241     Element* elementFromPoint(int x, int y) const;
 242     String readyState() const;
 243
 244     String defaultCharset() const;
 245
 246     // Synonyms backing similar DOM attributes. Use Document::encoding() to avoid virtual dispatch.
 247     String inputEncoding() const { return Document::encoding(); }
 248     String charset() const { return Document::encoding(); }
 249     String characterSet() const { return Document::encoding(); }
 250
 251     void setCharset(const String&);
 252
 253     String contentLanguage() const { return m_contentLanguage; }
 254     void setContentLanguage(const String& lang) { m_contentLanguage = lang; }
 255
 256     String xmlEncoding() const { return m_xmlEncoding; }
 257     String xmlVersion() const { return m_xmlVersion; }
 258     bool xmlStandalone() const { return m_xmlStandalone; }
 259
 260     void setXMLEncoding(const String& encoding) { m_xmlEncoding = encoding; } // read-only property, only to be set from XMLTokenizer
 261     void setXMLVersion(const String&, ExceptionCode&);
 262     void setXMLStandalone(bool, ExceptionCode&);
 263
 264     String documentURI() const { return m_documentURI; }
 265     void setDocumentURI(const String&);
 266
 267     virtual KURL baseURI() const;
 268
 269     PassRefPtr<Node> adoptNode(PassRefPtr<Node> source, ExceptionCode&);
 270
 271     PassRefPtr<HTMLCollection> images();
 272     PassRefPtr<HTMLCollection> embeds();
 273     PassRefPtr<HTMLCollection> plugins(); // an alias for embeds() required for the JS DOM bindings.
 274     PassRefPtr<HTMLCollection> applets();
 275     PassRefPtr<HTMLCollection> links();
 276     PassRefPtr<HTMLCollection> forms();
 277     PassRefPtr<HTMLCollection> anchors();
 278     PassRefPtr<HTMLCollection> all();
 279     PassRefPtr<HTMLCollection> objects();
 280     PassRefPtr<HTMLCollection> scripts();
 281     PassRefPtr<HTMLCollection> windowNamedItems(const String& name);
 282     PassRefPtr<HTMLCollection> documentNamedItems(const String& name);
 283
 284     // Find first anchor with the given name.
 285     // First searches for an element with the given ID, but if that fails, then looks
 286     // for an anchor with the given name. ID matching is always case sensitive, but
 287     // Anchor name matching is case sensitive in strict mode and not case sensitive in
 288     // quirks mode for historical compatibility reasons.
 289     Element* findAnchor(const String& name);
 290
 291     HTMLCollection::CollectionInfo* collectionInfo(HTMLCollection::Type type)
 292     {
 293         ASSERT(type >= HTMLCollection::FirstUnnamedDocumentCachedType);
 294         unsigned index = type - HTMLCollection::FirstUnnamedDocumentCachedType;
 295         ASSERT(index < HTMLCollection::NumUnnamedDocumentCachedTypes);
 296         return &m_collectionInfo[index];
 297     }
 298
 299     HTMLCollection::CollectionInfo* nameCollectionInfo(HTMLCollection::Type, const AtomicString& name);
 300
 301     // DOM methods overridden from  parent classes
 302
 303     virtual String nodeName() const;
 304     virtual NodeType nodeType() const;
 305
 306     // Other methods (not part of DOM)
 307     virtual bool isHTMLDocument() const { return false; }
 308     virtual bool isImageDocument() const { return false; }
 309 #if ENABLE(SVG)
 310     virtual bool isSVGDocument() const { return false; }
 311 #endif
 312     virtual bool isPluginDocument() const { return false; }
 313     virtual bool isMediaDocument() const { return false; }
 314 #if ENABLE(WML)
 315     virtual bool isWMLDocument() const { return false; }
 316 #endif
 317     virtual bool isFrameSet() const { return false; }
 318
 319     CSSStyleSelector* styleSelector() const { return m_styleSelector; }
 320
 321     Element* getElementByAccessKey(const String& key) const;
 322
 323     /**
 324      * Updates the pending sheet count and then calls updateStyleSelector.
 325      */
 326     void removePendingSheet();
 327
 328     /**
 329      * This method returns true if all top-level stylesheets have loaded (including
 330      * any @imports that they may be loading).
 331      */
 332     bool haveStylesheetsLoaded() const
 333     {
 334         return m_pendingStylesheets <= 0 || m_ignorePendingStylesheets;
 335     }
 336
 337     /**
 338      * Increments the number of pending sheets.  The <link> elements
 339      * invoke this to add themselves to the loading list.
 340      */
 341     void addPendingSheet() { m_pendingStylesheets++; }
 342
 343     void addStyleSheetCandidateNode(Node*, bool createdByParser);
 344     void removeStyleSheetCandidateNode(Node*);
 345
 346     bool gotoAnchorNeededAfterStylesheetsLoad() { return m_gotoAnchorNeededAfterStylesheetsLoad; }
 347     void setGotoAnchorNeededAfterStylesheetsLoad(bool b) { m_gotoAnchorNeededAfterStylesheetsLoad = b; }
 348
 349     /**
 350      * Called when one or more stylesheets in the document may have been added, removed or changed.
 351      *
 352      * Creates a new style selector and assign it to this document. This is done by iterating through all nodes in
 353      * document (or those before <BODY> in a HTML document), searching for stylesheets. Stylesheets can be contained in
 354      * <LINK>, <STYLE> or <BODY> elements, as well as processing instructions (XML documents only). A list is
 355      * constructed from these which is used to create the a new style selector which collates all of the stylesheets
 356      * found and is used to calculate the derived styles for all rendering objects.
 357      */
 358     void updateStyleSelector();
 359
 360     void recalcStyleSelector();
 361
 362     bool usesDescendantRules() const { return m_usesDescendantRules; }
 363     void setUsesDescendantRules(bool b) { m_usesDescendantRules = b; }
 364     bool usesSiblingRules() const { return m_usesSiblingRules; }
 365     void setUsesSiblingRules(bool b) { m_usesSiblingRules = b; }
 366     bool usesFirstLineRules() const { return m_usesFirstLineRules; }
 367     void setUsesFirstLineRules(bool b) { m_usesFirstLineRules = b; }
 368     bool usesFirstLetterRules() const { return m_usesFirstLetterRules; }
 369     void setUsesFirstLetterRules(bool b) { m_usesFirstLetterRules = b; }
 370     bool usesBeforeAfterRules() const { return m_usesBeforeAfterRules; }
 371     void setUsesBeforeAfterRules(bool b) { m_usesBeforeAfterRules = b; }
 372
 373     // Machinery for saving and restoring state when you leave and then go back to a page.
 374     void registerFormElementWithState(FormControlElementWithState* e) { m_formElementsWithState.add(e); }
 375     void unregisterFormElementWithState(FormControlElementWithState* e) { m_formElementsWithState.remove(e); }
 376     Vector<String> formElementsState() const;
 377     void setStateForNewFormElements(const Vector<String>&);
 378     bool hasStateForNewFormElements() const;
 379     bool takeStateForFormElement(AtomicStringImpl* name, AtomicStringImpl* type, String& state);
 380
 381     FrameView* view() const; // can be NULL
 382     Frame* frame() const { return m_frame; } // can be NULL
 383     Page* page() const; // can be NULL
 384     Settings* settings() const; // can be NULL
 385
 386     PassRefPtr<Range> createRange();
 387
 388     PassRefPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow,
 389         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
 390
 391     PassRefPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow,
 392         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
 393
 394     // Special support for editing
 395     PassRefPtr<CSSStyleDeclaration> createCSSStyleDeclaration();
 396     PassRefPtr<EditingText> createEditingTextNode(const String&);
 397
 398     virtual void recalcStyle( StyleChange = NoChange );
 399     virtual void updateRendering();
 400     void updateLayout();
 401     void updateLayoutIgnorePendingStylesheets();
 402     static void updateDocumentsRendering();
 403     DocLoader* docLoader() { return m_docLoader; }
 404
 405     virtual void attach();
 406     virtual void detach();
 407
 408     RenderArena* renderArena() { return m_renderArena; }
 409
 410     RenderView* renderView() const;
 411
 412     void clearAXObjectCache();
 413     AXObjectCache* axObjectCache() const;
 414
 415     // to get visually ordered hebrew and arabic pages right
 416     void setVisuallyOrdered();
 417
 418     void open(Document* ownerDocument = 0);
 419     void implicitOpen();
 420     void close();
 421     void implicitClose();
 422     void cancelParsing();
 423
 424     void write(const SegmentedString& text, Document* ownerDocument = 0);
 425     void write(const String& text, Document* ownerDocument = 0);
 426     void writeln(const String& text, Document* ownerDocument = 0);
 427     void finishParsing();
 428     void clear();
 429
 430     bool wellFormed() const { return m_wellFormed; }
 431
 432     const KURL& url() const { return m_url; }
 433     void setURL(const KURL&);
 434
 435     const KURL& baseURL() const { return m_baseURL; }
 436     // Setting the BaseElementURL will change the baseURL.
 437     void setBaseElementURL(const KURL&);
 438
 439     const String& baseTarget() const { return m_baseTarget; }
 440     // Setting the BaseElementTarget will change the baseTarget.
 441     void setBaseElementTarget(const String& baseTarget) { m_baseTarget = baseTarget; }
 442
 443     KURL completeURL(const String&) const;
 444
 445     virtual String userAgent(const KURL&) const;
 446
 447     // from cachedObjectClient
 448     virtual void setCSSStyleSheet(const String& url, const String& charset, const CachedCSSStyleSheet*);
 449
 450 #if FRAME_LOADS_USER_STYLESHEET
 451     void setUserStyleSheet(const String& sheet);
 452 #endif
 453
 454     String userStyleSheet() const;
 455
 456     CSSStyleSheet* elementSheet();
 457     CSSStyleSheet* mappedElementSheet();
 458     virtual Tokenizer* createTokenizer();
 459     Tokenizer* tokenizer() { return m_tokenizer; }
 460
 461     bool printing() const { return m_printing; }
 462     void setPrinting(bool p) { m_printing = p; }
 463
 464     enum ParseMode { Compat, AlmostStrict, Strict };
 465
 466 private:
 467     virtual void determineParseMode() {}
 468
 469 public:
 470     void setParseMode(ParseMode m) { m_parseMode = m; }
 471     ParseMode parseMode() const { return m_parseMode; }
 472
 473     bool inCompatMode() const { return m_parseMode == Compat; }
 474     bool inAlmostStrictMode() const { return m_parseMode == AlmostStrict; }
 475     bool inStrictMode() const { return m_parseMode == Strict; }
 476
 477     void setParsing(bool);
 478     bool parsing() const { return m_bParsing; }
 479     int minimumLayoutDelay();
 480     bool shouldScheduleLayout();
 481     int elapsedTime() const;
 482
 483     void setTextColor(const Color& color) { m_textColor = color; }
 484     Color textColor() const { return m_textColor; }
 485
 486     const Color& linkColor() const { return m_linkColor; }
 487     const Color& visitedLinkColor() const { return m_visitedLinkColor; }
 488     const Color& activeLinkColor() const { return m_activeLinkColor; }
 489     void setLinkColor(const Color& c) { m_linkColor = c; }
 490     void setVisitedLinkColor(const Color& c) { m_visitedLinkColor = c; }
 491     void setActiveLinkColor(const Color& c) { m_activeLinkColor = c; }
 492     void resetLinkColor();
 493     void resetVisitedLinkColor();
 494     void resetActiveLinkColor();
 495
 496     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const IntPoint&, const PlatformMouseEvent&);
 497
 498     virtual bool childTypeAllowed(NodeType);
 499     virtual PassRefPtr<Node> cloneNode(bool deep);
 500
 501     virtual bool canReplaceChild(Node* newChild, Node* oldChild);
 502
 503     StyleSheetList* styleSheets();
 504
 505     /* Newly proposed CSS3 mechanism for selecting alternate
 506        stylesheets using the DOM. May be subject to change as
 507        spec matures. - dwh
 508     */
 509     String preferredStylesheetSet() const;
 510     String selectedStylesheetSet() const;
 511     void setSelectedStylesheetSet(const String&);
 512
 513     bool setFocusedNode(PassRefPtr<Node>);
 514     Node* focusedNode() const { return m_focusedNode.get(); }
 515
 516     // The m_ignoreAutofocus flag specifies whether or not the document has been changed by the user enough
 517     // for WebCore to ignore the autofocus attribute on any form controls
 518     bool ignoreAutofocus() const { return m_ignoreAutofocus; };
 519     void setIgnoreAutofocus(bool shouldIgnore = true) { m_ignoreAutofocus = shouldIgnore; };
 520
 521     void setHoverNode(PassRefPtr<Node>);
 522     Node* hoverNode() const { return m_hoverNode.get(); }
 523
 524     void setActiveNode(PassRefPtr<Node>);
 525     Node* activeNode() const { return m_activeNode.get(); }
 526
 527     void focusedNodeRemoved();
 528     void removeFocusedNodeOfSubtree(Node*, bool amongChildrenOnly = false);
 529     void hoveredNodeDetached(Node*);
 530     void activeChainNodeDetached(Node*);
 531
 532     // Updates for :target (CSS3 selector).
 533     void setCSSTarget(Element*);
 534     Element* cssTarget() const { return m_cssTarget; }
 535
 536     void setDocumentChanged(bool);
 537
 538     void attachNodeIterator(NodeIterator*);
 539     void detachNodeIterator(NodeIterator*);
 540
 541     void attachRange(Range*);
 542     void detachRange(Range*);
 543
 544     void nodeChildrenChanged(ContainerNode*);
 545     void nodeWillBeRemoved(Node*);
 546
 547     void textInserted(Node*, unsigned offset, unsigned length);
 548     void textRemoved(Node*, unsigned offset, unsigned length);
 549     void textNodesMerged(Text* oldNode, unsigned offset);
 550     void textNodeSplit(Text* oldNode);
 551
 552     DOMWindow* defaultView() const { return domWindow(); }
 553     DOMWindow* domWindow() const;
 554
 555     PassRefPtr<Event> createEvent(const String& eventType, ExceptionCode&);
 556
 557     // keep track of what types of event listeners are registered, so we don't
 558     // dispatch events unnecessarily
 559     enum ListenerType {
 560         DOMSUBTREEMODIFIED_LISTENER          = 0x01,
 561         DOMNODEINSERTED_LISTENER             = 0x02,
 562         DOMNODEREMOVED_LISTENER              = 0x04,
 563         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 0x08,
 564         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 0x10,
 565         DOMATTRMODIFIED_LISTENER             = 0x20,
 566         DOMCHARACTERDATAMODIFIED_LISTENER    = 0x40,
 567         OVERFLOWCHANGED_LISTENER             = 0x80,
 568         ANIMATIONEND_LISTENER                = 0x100,
 569         ANIMATIONSTART_LISTENER              = 0x200,
 570         ANIMATIONITERATION_LISTENER          = 0x400,
 571         TRANSITIONEND_LISTENER               = 0x800
 572     };
 573
 574     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
 575     void addListenerType(ListenerType listenerType) { m_listenerTypes = m_listenerTypes | listenerType; }
 576     void addListenerTypeIfNeeded(const AtomicString& eventType);
 577
 578     CSSStyleDeclaration* getOverrideStyle(Element*, const String& pseudoElt);
 579
 580     void handleWindowEvent(Event*, bool useCapture);
 581     void setWindowInlineEventListenerForType(const AtomicString& eventType, PassRefPtr<EventListener>);
 582     EventListener* windowInlineEventListenerForType(const AtomicString& eventType);
 583     void removeWindowInlineEventListenerForType(const AtomicString& eventType);
 584
 585     void setWindowInlineEventListenerForTypeAndAttribute(const AtomicString& eventType, Attribute*);
 586
 587     void addWindowEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
 588     void removeWindowEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
 589     bool hasWindowEventListener(const AtomicString& eventType);
 590
 591     void addPendingFrameUnloadEventCount();
 592     void removePendingFrameUnloadEventCount();
 593     void addPendingFrameBeforeUnloadEventCount();
 594     void removePendingFrameBeforeUnloadEventCount();
 595
 596     PassRefPtr<EventListener> createEventListener(const String& functionName, const String& code, Node*);
 597
 598     /**
 599      * Searches through the document, starting from fromNode, for the next selectable element that comes after fromNode.
 600      * The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab indexes
 601      * first (from lowest to highest), and then elements without tab indexes (in document order).
 602      *
 603      * @param fromNode The node from which to start searching. The node after this will be focused. May be null.
 604      *
 605      * @return The focus node that comes after fromNode
 606      *
 607      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
 608      */
 609     Node* nextFocusableNode(Node* start, KeyboardEvent*);
 610
 611     /**
 612      * Searches through the document, starting from fromNode, for the previous selectable element (that comes _before_)
 613      * fromNode. The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab
 614      * indexes first (from lowest to highest), and then elements without tab indexes (in document order).
 615      *
 616      * @param fromNode The node from which to start searching. The node before this will be focused. May be null.
 617      *
 618      * @return The focus node that comes before fromNode
 619      *
 620      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
 621      */
 622     Node* previousFocusableNode(Node* start, KeyboardEvent*);
 623
 624     int nodeAbsIndex(Node*);
 625     Node* nodeWithAbsIndex(int absIndex);
 626
 627     /**
 628      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
 629      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
 630      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
 631      * specified in a HTML file.
 632      *
 633      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
 634      * @param content The header value (value of the meta tag's "content" attribute)
 635      */
 636     void processHttpEquiv(const String& equiv, const String& content);
 637
 638     // Returns the owning element in the parent document.
 639     // Returns 0 if this is the top level document.
 640     Element* ownerElement() const;
 641
 642     String title() const { return m_title; }
 643     void setTitle(const String&, Element* titleElement = 0);
 644     void removeTitle(Element* titleElement);
 645
 646     String cookie() const;
 647     void setCookie(const String&);
 648
 649     String referrer() const;
 650
 651     String domain() const;
 652     void setDomain(const String& newDomain);
 653
 654     String lastModified() const;
 655
 656     const KURL& cookieURL() const { return m_cookieURL; }
 657
 658     const KURL& policyBaseURL() const { return m_policyBaseURL; }
 659     void setPolicyBaseURL(const KURL& url) { m_policyBaseURL = url; }
 660
 661     // The following implements the rule from HTML 4 for what valid names are.
 662     // To get this right for all the XML cases, we probably have to improve this or move it
 663     // and make it sensitive to the type of document.
 664     static bool isValidName(const String&);
 665
 666     // The following breaks a qualified name into a prefix and a local name.
 667     // It also does a validity check, and returns false if the qualified name
 668     // is invalid.  It also sets ExceptionCode when name is invalid.
 669     static bool parseQualifiedName(const String& qualifiedName, String& prefix, String& localName, ExceptionCode&);
 670
 671     // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
 672     static bool hasPrefixNamespaceMismatch(const QualifiedName&);
 673
 674     void addElementById(const AtomicString& elementId, Element *element);
 675     void removeElementById(const AtomicString& elementId, Element *element);
 676
 677     void addImageMap(HTMLMapElement*);
 678     void removeImageMap(HTMLMapElement*);
 679     HTMLMapElement* getImageMap(const String& url) const;
 680
 681     HTMLElement* body() const;
 682     void setBody(PassRefPtr<HTMLElement>, ExceptionCode&);
 683
 684     HTMLHeadElement* head();
 685
 686     bool execCommand(const String& command, bool userInterface = false, const String& value = String());
 687     bool queryCommandEnabled(const String& command);
 688     bool queryCommandIndeterm(const String& command);
 689     bool queryCommandState(const String& command);
 690     bool queryCommandSupported(const String& command);
 691     String queryCommandValue(const String& command);
 692
 693     void addMarker(Range*, DocumentMarker::MarkerType, String description = String());
 694     void addMarker(Node*, DocumentMarker);
 695     void copyMarkers(Node *srcNode, unsigned startOffset, int length, Node *dstNode, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 696     void removeMarkers(Range*, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 697     void removeMarkers(Node*, unsigned startOffset, int length, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 698     void removeMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 699     void removeMarkers(Node*);
 700     void repaintMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 701     void setRenderedRectForMarker(Node*, DocumentMarker, const IntRect&);
 702     void invalidateRenderedRectsForMarkersInRect(const IntRect&);
 703     void shiftMarkers(Node*, unsigned startOffset, int delta, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 704
 705     DocumentMarker* markerContainingPoint(const IntPoint&, DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 706     Vector<DocumentMarker> markersForNode(Node*);
 707     Vector<IntRect> renderedRectsForMarkers(DocumentMarker::MarkerType = DocumentMarker::AllMarkers);
 708
 709     // designMode support
 710     enum InheritedBool { off = false, on = true, inherit };
 711     void setDesignMode(InheritedBool value);
 712     InheritedBool getDesignMode() const;
 713     bool inDesignMode() const;
 714
 715     Document* parentDocument() const;
 716     Document* topDocument() const;
 717
 718     int docID() const { return m_docID; }
 719
 720 #if ENABLE(XSLT)
 721     void applyXSLTransform(ProcessingInstruction* pi);
 722     void setTransformSource(void* doc);
 723     const void* transformSource() { return m_transformSource; }
 724     PassRefPtr<Document> transformSourceDocument() { return m_transformSourceDocument; }
 725     void setTransformSourceDocument(Document* doc) { m_transformSourceDocument = doc; }
 726 #endif
 727
 728 #if ENABLE(XBL)
 729     // XBL methods
 730     XBLBindingManager* bindingManager() const { return m_bindingManager; }
 731 #endif
 732
 733     void incDOMTreeVersion() { ++m_domtree_version; }
 734     unsigned domTreeVersion() const { return m_domtree_version; }
 735
 736     void setDocType(PassRefPtr<DocumentType>);
 737
 738     virtual void finishedParsing();
 739
 740 #if ENABLE(XPATH)
 741     // XPathEvaluator methods
 742     PassRefPtr<XPathExpression> createExpression(const String& expression,
 743                                                  XPathNSResolver* resolver,
 744                                                  ExceptionCode& ec);
 745     PassRefPtr<XPathNSResolver> createNSResolver(Node *nodeResolver);
 746     PassRefPtr<XPathResult> evaluate(const String& expression,
 747                                      Node* contextNode,
 748                                      XPathNSResolver* resolver,
 749                                      unsigned short type,
 750                                      XPathResult* result,
 751                                      ExceptionCode& ec);
 752 #endif // ENABLE(XPATH)
 753
 754     enum PendingSheetLayout { NoLayoutWithPendingSheets, DidLayoutWithPendingSheets, IgnoreLayoutWithPendingSheets };
 755
 756     bool didLayoutWithPendingStylesheets() const { return m_pendingSheetLayout == DidLayoutWithPendingSheets; }
 757
 758     void setHasNodesWithPlaceholderStyle() { m_hasNodesWithPlaceholderStyle = true; }
 759
 760     const String& iconURL() const { return m_iconURL; }
 761     void setIconURL(const String& iconURL, const String& type);
 762
 763     void setUseSecureKeyboardEntryWhenActive(bool);
 764     bool useSecureKeyboardEntryWhenActive() const;
 765
 766     void addNodeListCache() { ++m_numNodeListCaches; }
 767     void removeNodeListCache() { ASSERT(m_numNodeListCaches > 0); --m_numNodeListCaches; }
 768     bool hasNodeListCaches() const { return m_numNodeListCaches; }
 769
 770     void updateFocusAppearanceSoon();
 771     void cancelFocusAppearanceUpdate();
 772
 773     // FF method for accessing the selection added for compatability.
 774     DOMSelection* getSelection() const;
 775
 776     // Extension for manipulating canvas drawing contexts for use in CSS
 777     CanvasRenderingContext2D* getCSSCanvasContext(const String& type, const String& name, int width, int height);
 778     HTMLCanvasElement* getCSSCanvasElement(const String& name);
 779
 780     bool isDNSPrefetchEnabled() const { return m_isDNSPrefetchEnabled; }
 781     void initDNSPrefetch();
 782     void parseDNSPrefetchControlHeader(const String&);
 783
 784     virtual void reportException(const String& errorMessage, int lineNumber, const String& sourceURL);
 785     virtual void addMessage(MessageDestination, MessageSource, MessageLevel, const String& message, unsigned lineNumber, const String& sourceURL);
 786     virtual void resourceRetrievedByXMLHttpRequest(unsigned long identifier, const ScriptString& sourceString);
 787     virtual void scriptImported(unsigned long, const String&);
 788     virtual void postTask(PassRefPtr<Task>); // Executes the task on context's thread asynchronously.
 789
 790 protected:
 791     Document(Frame*, bool isXHTML);
 792
 793 private:
 794     virtual void refScriptExecutionContext() { ref(); }
 795     virtual void derefScriptExecutionContext() { deref(); }
 796
 797     virtual const KURL& virtualURL() const; // Same as url(), but needed for ScriptExecutionContext to implement it without a performance loss for direct calls.
 798     virtual KURL virtualCompleteURL(const String&) const; // Same as completeURL() for the same reason as above.
 799
 800     String encoding() const;
 801
 802     CSSStyleSelector* m_styleSelector;
 803     bool m_didCalculateStyleSelector;
 804
 805     Frame* m_frame;
 806     DocLoader* m_docLoader;
 807     Tokenizer* m_tokenizer;
 808     bool m_wellFormed;
 809
 810     // Document URLs.
 811     KURL m_url;  // Document.URL: The URL from which this document was retrieved.
 812     KURL m_baseURL;  // Node.baseURI: The URL to use when resolving relative URLs.
 813     KURL m_baseElementURL;  // The URL set by the <base> element.
 814     KURL m_cookieURL;  // The URL to use for cookie access.
 815     KURL m_policyBaseURL;  // The policy URL for third-party cookie blocking.
 816
 817     // Document.documentURI:
 818     // Although URL-like, Document.documentURI can actually be set to any
 819     // string by content.  Document.documentURI affects m_baseURL unless the
 820     // document contains a <base> element, in which case the <base> element
 821     // takes precedence.
 822     String m_documentURI;
 823
 824     String m_baseTarget;
 825
 826     RefPtr<DocumentType> m_docType;
 827     mutable RefPtr<DOMImplementation> m_implementation;
 828
 829     RefPtr<StyleSheet> m_sheet;
 830 #if FRAME_LOADS_USER_STYLESHEET
 831     String m_usersheet;
 832 #endif
 833
 834     // Track the number of currently loading top-level stylesheets.  Sheets
 835     // loaded using the @import directive are not included in this count.
 836     // We use this count of pending sheets to detect when we can begin attaching
 837     // elements.
 838     int m_pendingStylesheets;
 839
 840     // But sometimes you need to ignore pending stylesheet count to
 841     // force an immediate layout when requested by JS.
 842     bool m_ignorePendingStylesheets;
 843
 844     // If we do ignore the pending stylesheet count, then we need to add a boolean
 845     // to track that this happened so that we can do a full repaint when the stylesheets
 846     // do eventually load.
 847     PendingSheetLayout m_pendingSheetLayout;
 848
 849     bool m_hasNodesWithPlaceholderStyle;
 850
 851     RefPtr<CSSStyleSheet> m_elemSheet;
 852     RefPtr<CSSStyleSheet> m_mappedElementSheet;
 853
 854     bool m_printing;
 855
 856     bool m_ignoreAutofocus;
 857
 858     ParseMode m_parseMode;
 859
 860     Color m_textColor;
 861
 862     RefPtr<Node> m_focusedNode;
 863     RefPtr<Node> m_hoverNode;
 864     RefPtr<Node> m_activeNode;
 865     mutable RefPtr<Element> m_documentElement;
 866
 867     unsigned m_domtree_version;
 868
 869     HashSet<NodeIterator*> m_nodeIterators;
 870     HashSet<Range*> m_ranges;
 871
 872     unsigned short m_listenerTypes;
 873
 874     RefPtr<StyleSheetList> m_styleSheets; // All of the stylesheets that are currently in effect for our media type and stylesheet set.
 875     ListHashSet<Node*> m_styleSheetCandidateNodes; // All of the nodes that could potentially provide stylesheets to the document (<link>, <style>, <?xml-stylesheet>)
 876
 877     RegisteredEventListenerVector m_windowEventListeners;
 878
 879     typedef HashMap<FormElementKey, Vector<String>, FormElementKeyHash, FormElementKeyHashTraits> FormElementStateMap;
 880     ListHashSet<FormControlElementWithState*> m_formElementsWithState;
 881     FormElementStateMap m_stateForNewFormElements;
 882
 883     Color m_linkColor;
 884     Color m_visitedLinkColor;
 885     Color m_activeLinkColor;
 886
 887     String m_preferredStylesheetSet;
 888     String m_selectedStylesheetSet;
 889
 890     bool m_loadingSheet;
 891     bool visuallyOrdered;
 892     bool m_bParsing;
 893     bool m_docChanged;
 894     bool m_inStyleRecalc;
 895     bool m_closeAfterStyleRecalc;
 896     bool m_usesDescendantRules;
 897     bool m_usesSiblingRules;
 898     bool m_usesFirstLineRules;
 899     bool m_usesFirstLetterRules;
 900     bool m_usesBeforeAfterRules;
 901     bool m_gotoAnchorNeededAfterStylesheetsLoad;
 902     bool m_isDNSPrefetchEnabled;
 903     bool m_haveExplicitlyDisabledDNSPrefetch;
 904     bool m_frameElementsShouldIgnoreScrolling;
 905
 906     String m_title;
 907     bool m_titleSetExplicitly;
 908     RefPtr<Element> m_titleElement;
 909
 910     RenderArena* m_renderArena;
 911
 912     typedef std::pair<Vector<DocumentMarker>, Vector<IntRect> > MarkerMapVectorPair;
 913     typedef HashMap<RefPtr<Node>, MarkerMapVectorPair*> MarkerMap;
 914     MarkerMap m_markers;
 915
 916     mutable AXObjectCache* m_axObjectCache;
 917
 918     Timer<Document> m_updateFocusAppearanceTimer;
 919
 920     Element* m_cssTarget;
 921
 922     bool m_processingLoadEvent;
 923     double m_startTime;
 924     bool m_overMinimumLayoutThreshold;
 925
 926 #if ENABLE(XSLT)
 927     void* m_transformSource;
 928     RefPtr<Document> m_transformSourceDocument;
 929 #endif
 930
 931 #if ENABLE(XBL)
 932     XBLBindingManager* m_bindingManager; // The access point through which documents and elements communicate with XBL.
 933 #endif
 934
 935     typedef HashMap<AtomicStringImpl*, HTMLMapElement*> ImageMapsByName;
 936     ImageMapsByName m_imageMapsByName;
 937
 938     HashSet<Node*> m_disconnectedNodesWithEventListeners;
 939
 940     int m_docID; // A unique document identifier used for things like document-specific mapped attributes.
 941
 942     String m_xmlEncoding;
 943     String m_xmlVersion;
 944     bool m_xmlStandalone;
 945
 946     String m_contentLanguage;
 947
 948 public:
 949     bool inPageCache() const { return m_inPageCache; }
 950     void setInPageCache(bool flag);
 951
 952     // Elements can register themselves for the "documentWillBecomeInactive()" and
 953     // "documentDidBecomeActive()" callbacks
 954     void registerForDocumentActivationCallbacks(Element*);
 955     void unregisterForDocumentActivationCallbacks(Element*);
 956     void documentWillBecomeInactive();
 957     void documentDidBecomeActive();
 958
 959     void registerForMediaVolumeCallbacks(Element*);
 960     void unregisterForMediaVolumeCallbacks(Element*);
 961     void mediaVolumeDidChange();
 962
 963     void setShouldCreateRenderers(bool);
 964     bool shouldCreateRenderers();
 965
 966     void setDecoder(PassRefPtr<TextResourceDecoder>);
 967     TextResourceDecoder* decoder() const { return m_decoder.get(); }
 968
 969     String displayStringModifiedByEncoding(const String&) const;
 970     PassRefPtr<StringImpl> displayStringModifiedByEncoding(PassRefPtr<StringImpl>) const;
 971     void displayBufferModifiedByEncoding(UChar* buffer, unsigned len) const;
 972
 973     // Quirk for the benefit of Apple's Dictionary application.
 974     void setFrameElementsShouldIgnoreScrolling(bool ignore) { m_frameElementsShouldIgnoreScrolling = ignore; }
 975     bool frameElementsShouldIgnoreScrolling() const { return m_frameElementsShouldIgnoreScrolling; }
 976
 977 #if ENABLE(DASHBOARD_SUPPORT)
 978     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
 979     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
 980     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
 981     void setHasDashboardRegions (bool f) { m_hasDashboardRegions = f; }
 982     const Vector<DashboardRegionValue>& dashboardRegions() const;
 983     void setDashboardRegions(const Vector<DashboardRegionValue>&);
 984 #endif
 985
 986     void removeAllEventListenersFromAllNodes();
 987
 988     void registerDisconnectedNodeWithEventListeners(Node*);
 989     void unregisterDisconnectedNodeWithEventListeners(Node*);
 990
 991     HTMLFormElement::CheckedRadioButtons& checkedRadioButtons() { return m_checkedRadioButtons; }
 992
 993 #if ENABLE(SVG)
 994     const SVGDocumentExtensions* svgExtensions();
 995     SVGDocumentExtensions* accessSVGExtensions();
 996 #endif
 997
 998     void initSecurityContext();
 999
1000     // Explicitly override the security origin for this document.
1001     // Note: It is dangerous to change the security origin of a document
1002     //       that already contains content.
1003     void setSecurityOrigin(SecurityOrigin*);
1004
1005     bool processingLoadEvent() const { return m_processingLoadEvent; }
1006
1007 #if ENABLE(DATABASE)
1008     void addOpenDatabase(Database*);
1009     void removeOpenDatabase(Database*);
1010     DatabaseThread* databaseThread();   // Creates the thread as needed, but not if it has been already terminated.
1011     void setHasOpenDatabases() { m_hasOpenDatabases = true; }
1012     bool hasOpenDatabases() { return m_hasOpenDatabases; }
1013     void stopDatabases();
1014 #endif
1015
1016     void setUsingGeolocation(bool f) { m_usingGeolocation = f; }
1017     bool usingGeolocation() const { return m_usingGeolocation; };
1018
1019 #if ENABLE(WML)
1020     void resetWMLPageState();
1021 #endif
1022
1023 protected:
1024     void clearXMLVersion() { m_xmlVersion = String(); }
1025
1026 private:
1027     void updateTitle();
1028     void removeAllDisconnectedNodeEventListeners();
1029     void updateFocusAppearanceTimerFired(Timer<Document>*);
1030     void updateBaseURL();
1031
1032     void cacheDocumentElement() const;
1033
1034     RenderObject* m_savedRenderer;
1035     int m_secureForms;
1036
1037     RefPtr<TextResourceDecoder> m_decoder;
1038
1039     // We maintain the invariant that m_duplicateIds is the count of all elements with a given ID
1040     // excluding the one referenced in m_elementsById, if any. This means it one less than the total count
1041     // when the first node with a given ID is cached, otherwise the same as the total count.
1042     mutable HashMap<AtomicStringImpl*, Element*> m_elementsById;
1043     mutable HashCountedSet<AtomicStringImpl*> m_duplicateIds;
1044
1045     mutable HashMap<StringImpl*, Element*, CaseFoldingHash> m_elementsByAccessKey;
1046
1047     InheritedBool m_designMode;
1048
1049     int m_selfOnlyRefCount;
1050
1051     HTMLFormElement::CheckedRadioButtons m_checkedRadioButtons;
1052
1053     typedef HashMap<AtomicStringImpl*, HTMLCollection::CollectionInfo*> NamedCollectionMap;
1054     HTMLCollection::CollectionInfo m_collectionInfo[HTMLCollection::NumUnnamedDocumentCachedTypes];
1055     NamedCollectionMap m_nameCollectionInfo[HTMLCollection::NumNamedDocumentCachedTypes];
1056
1057 #if ENABLE(XPATH)
1058     RefPtr<XPathEvaluator> m_xpathEvaluator;
1059 #endif
1060
1061 #if ENABLE(SVG)
1062     OwnPtr<SVGDocumentExtensions> m_svgExtensions;
1063 #endif
1064
1065 #if ENABLE(DASHBOARD_SUPPORT)
1066     Vector<DashboardRegionValue> m_dashboardRegions;
1067     bool m_hasDashboardRegions;
1068     bool m_dashboardRegionsDirty;
1069 #endif
1070
1071     HashMap<String, RefPtr<HTMLCanvasElement> > m_cssCanvasElements;
1072
1073     mutable bool m_accessKeyMapValid;
1074     bool m_createRenderers;
1075     bool m_inPageCache;
1076     String m_iconURL;
1077
1078     HashSet<Element*> m_documentActivationCallbackElements;
1079     HashSet<Element*> m_mediaVolumeCallbackElements;
1080
1081     bool m_useSecureKeyboardEntryWhenActive;
1082
1083     bool m_isXHTML;
1084
1085     unsigned m_numNodeListCaches;
1086
1087 public:
1088     typedef HashMap<WebCore::Node*, JSNode*> JSWrapperCache;
1089     JSWrapperCache& wrapperCache() { return m_wrapperCache; }
1090 private:
1091     JSWrapperCache m_wrapperCache;
1092
1093 #if ENABLE(DATABASE)
1094     RefPtr<DatabaseThread> m_databaseThread;
1095     bool m_hasOpenDatabases;    // This never changes back to false, even as the database thread is closed.
1096     typedef HashSet<Database*> DatabaseSet;
1097     OwnPtr<DatabaseSet> m_openDatabaseSet;
1098 #endif
1099
1100     bool m_usingGeolocation;
1101 };
1102
1103 inline bool Document::hasElementWithId(AtomicStringImpl* id) const
1104 {
1105     ASSERT(id);
1106     return m_elementsById.contains(id) || m_duplicateIds.contains(id);
1107 }
1108
1109 inline bool Node::isDocumentNode() const
1110 {
1111     return this == m_document.get();
1112 }
1113
1114 } // namespace WebCore
1115
1116 #endif // Document_h