https://bugs.webkit.org/show_bug.cgi?id=44788, implement HTML5-compliant doctype...
[WebKit-https.git] / 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, 2010 Apple Inc. All rights reserved.
7  * Copyright (C) 2008, 2009 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 "CachedResourceHandle.h"
30 #include "CheckedRadioButtons.h"
31 #include "CollectionCache.h"
32 #include "CollectionType.h"
33 #include "Color.h"
34 #include "ContainerNode.h"
35 #include "DocumentMarkerController.h"
36 #include "QualifiedName.h"
37 #include "ScriptExecutionContext.h"
38 #include "Timer.h"
39 #include <wtf/FixedArray.h>
40 #include <wtf/HashCountedSet.h>
41 #include <wtf/OwnPtr.h>
42 #include <wtf/PassOwnPtr.h>
43
44 #if USE(JSC)
45 #include <runtime/WeakGCMap.h>
46 #endif
47
48 namespace WebCore {
49
50 class AsyncScriptRunner;
51 class Attr;
52 class AXObjectCache;
53 class CDATASection;
54 class CachedCSSStyleSheet;
55 class CachedScript;
56 class CanvasRenderingContext;
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 DocumentWeakReference;
71 class EditingText;
72 class Element;
73 class EntityReference;
74 class Event;
75 class EventListener;
76 class Frame;
77 class FrameView;
78 class HTMLCanvasElement;
79 class HTMLCollection;
80 class HTMLAllCollection;
81 class HTMLDocument;
82 class HTMLElement;
83 class HTMLFormElement;
84 class HTMLFrameOwnerElement;
85 class HTMLHeadElement;
86 class HTMLInputElement;
87 class HTMLMapElement;
88 class HistoryItem;
89 class HitTestRequest;
90 class HitTestResult;
91 class InspectorTimelineAgent;
92 class IntPoint;
93 class DOMWrapperWorld;
94 class JSNode;
95 class MediaCanStartListener;
96 class MouseEventWithHitTestResults;
97 class NodeFilter;
98 class NodeIterator;
99 class Page;
100 class PlatformMouseEvent;
101 class ProcessingInstruction;
102 class Range;
103 class RegisteredEventListener;
104 class RenderArena;
105 class RenderView;
106 class ScriptableDocumentParser;
107 class ScriptElementData;
108 class SecurityOrigin;
109 class SerializedScriptValue;
110 class SegmentedString;
111 class Settings;
112 class StyleSheet;
113 class StyleSheetList;
114 class Text;
115 class TextResourceDecoder;
116 class DocumentParser;
117 class TreeWalker;
118 class XMLHttpRequest;
119
120 #if ENABLE(SVG)
121 class SVGDocumentExtensions;
122 #endif
123
124 #if ENABLE(XSLT)
125 class TransformSource;
126 #endif
127
128 #if ENABLE(XPATH)
129 class XPathEvaluator;
130 class XPathExpression;
131 class XPathNSResolver;
132 class XPathResult;
133 #endif
134
135 #if ENABLE(DASHBOARD_SUPPORT)
136 struct DashboardRegionValue;
137 #endif
138
139 typedef int ExceptionCode;
140
141 class FormElementKey {
142 public:
143     FormElementKey(AtomicStringImpl* = 0, AtomicStringImpl* = 0);
144     ~FormElementKey();
145     FormElementKey(const FormElementKey&);
146     FormElementKey& operator=(const FormElementKey&);
147
148     AtomicStringImpl* name() const { return m_name; }
149     AtomicStringImpl* type() const { return m_type; }
150
151     // Hash table deleted values, which are only constructed and never copied or destroyed.
152     FormElementKey(WTF::HashTableDeletedValueType) : m_name(hashTableDeletedValue()) { }
153     bool isHashTableDeletedValue() const { return m_name == hashTableDeletedValue(); }
154
155 private:
156     void ref() const;
157     void deref() const;
158
159     static AtomicStringImpl* hashTableDeletedValue() { return reinterpret_cast<AtomicStringImpl*>(-1); }
160
161     AtomicStringImpl* m_name;
162     AtomicStringImpl* m_type;
163 };
164
165 inline bool operator==(const FormElementKey& a, const FormElementKey& b)
166 {
167     return a.name() == b.name() && a.type() == b.type();
168 }
169
170 struct FormElementKeyHash {
171     static unsigned hash(const FormElementKey&);
172     static bool equal(const FormElementKey& a, const FormElementKey& b) { return a == b; }
173     static const bool safeToCompareToEmptyOrDeleted = true;
174 };
175
176 struct FormElementKeyHashTraits : WTF::GenericHashTraits<FormElementKey> {
177     static void constructDeletedValue(FormElementKey& slot) { new (&slot) FormElementKey(WTF::HashTableDeletedValue); }
178     static bool isDeletedValue(const FormElementKey& value) { return value.isHashTableDeletedValue(); }
179 };
180
181 enum PageshowEventPersistence {
182     PageshowEventNotPersisted = 0,
183     PageshowEventPersisted = 1
184 };
185
186 enum StyleSelectorUpdateFlag { RecalcStyleImmediately, DeferRecalcStyle };
187
188 class Document : public ContainerNode, public ScriptExecutionContext {
189 public:
190     static PassRefPtr<Document> create(Frame* frame, const KURL& url)
191     {
192         return adoptRef(new Document(frame, url, false, false));
193     }
194     static PassRefPtr<Document> createXHTML(Frame* frame, const KURL& url)
195     {
196         return adoptRef(new Document(frame, url, true, false));
197     }
198     virtual ~Document();
199
200     using ContainerNode::ref;
201     using ContainerNode::deref;
202
203     // Nodes belonging to this document hold "self-only" references -
204     // these are enough to keep the document from being destroyed, but
205     // not enough to keep it from removing its children. This allows a
206     // node that outlives its document to still have a valid document
207     // pointer without introducing reference cycles
208
209     void selfOnlyRef()
210     {
211         ASSERT(!m_deletionHasBegun);
212         ++m_selfOnlyRefCount;
213     }
214     void selfOnlyDeref()
215     {
216         ASSERT(!m_deletionHasBegun);
217         --m_selfOnlyRefCount;
218         if (!m_selfOnlyRefCount && !refCount()) {
219 #ifndef NDEBUG
220             m_deletionHasBegun = true;
221 #endif
222             delete this;
223         }
224     }
225
226     // DOM methods & attributes for Document
227
228     DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
229     DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
230     DEFINE_ATTRIBUTE_EVENT_LISTENER(click);
231     DEFINE_ATTRIBUTE_EVENT_LISTENER(contextmenu);
232     DEFINE_ATTRIBUTE_EVENT_LISTENER(dblclick);
233     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragenter);
234     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragover);
235     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragleave);
236     DEFINE_ATTRIBUTE_EVENT_LISTENER(drop);
237     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragstart);
238     DEFINE_ATTRIBUTE_EVENT_LISTENER(drag);
239     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragend);
240     DEFINE_ATTRIBUTE_EVENT_LISTENER(input);
241     DEFINE_ATTRIBUTE_EVENT_LISTENER(invalid);
242     DEFINE_ATTRIBUTE_EVENT_LISTENER(keydown);
243     DEFINE_ATTRIBUTE_EVENT_LISTENER(keypress);
244     DEFINE_ATTRIBUTE_EVENT_LISTENER(keyup);
245     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousedown);
246     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousemove);
247     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseout);
248     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseover);
249     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseup);
250     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousewheel);
251     DEFINE_ATTRIBUTE_EVENT_LISTENER(scroll);
252     DEFINE_ATTRIBUTE_EVENT_LISTENER(select);
253     DEFINE_ATTRIBUTE_EVENT_LISTENER(submit);
254
255     DEFINE_ATTRIBUTE_EVENT_LISTENER(blur);
256     DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
257     DEFINE_ATTRIBUTE_EVENT_LISTENER(focus);
258     DEFINE_ATTRIBUTE_EVENT_LISTENER(load);
259
260     // WebKit extensions
261     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecut);
262     DEFINE_ATTRIBUTE_EVENT_LISTENER(cut);
263     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecopy);
264     DEFINE_ATTRIBUTE_EVENT_LISTENER(copy);
265     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforepaste);
266     DEFINE_ATTRIBUTE_EVENT_LISTENER(paste);
267     DEFINE_ATTRIBUTE_EVENT_LISTENER(reset);
268     DEFINE_ATTRIBUTE_EVENT_LISTENER(search);
269     DEFINE_ATTRIBUTE_EVENT_LISTENER(selectstart);
270 #if ENABLE(TOUCH_EVENTS)
271     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchstart);
272     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchmove);
273     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
274     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
275 #endif
276
277     DocumentType* doctype() const { return m_docType.get(); }
278
279     DOMImplementation* implementation() const;
280     
281     Element* documentElement() const
282     {
283         if (!m_documentElement)
284             cacheDocumentElement();
285         return m_documentElement.get();
286     }
287     
288     virtual PassRefPtr<Element> createElement(const AtomicString& tagName, ExceptionCode&);
289     PassRefPtr<DocumentFragment> createDocumentFragment();
290     PassRefPtr<Text> createTextNode(const String& data);
291     PassRefPtr<Comment> createComment(const String& data);
292     PassRefPtr<CDATASection> createCDATASection(const String& data, ExceptionCode&);
293     PassRefPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionCode&);
294     PassRefPtr<Attr> createAttribute(const String& name, ExceptionCode&);
295     PassRefPtr<Attr> createAttributeNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&, bool shouldIgnoreNamespaceChecks = false);
296     PassRefPtr<EntityReference> createEntityReference(const String& name, ExceptionCode&);
297     PassRefPtr<Node> importNode(Node* importedNode, bool deep, ExceptionCode&);
298     virtual PassRefPtr<Element> createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&);
299     PassRefPtr<Element> createElement(const QualifiedName&, bool createdByParser);
300     Element* getElementById(const AtomicString&) const;
301     bool hasElementWithId(AtomicStringImpl* id) const;
302     bool containsMultipleElementsWithId(const AtomicString& elementId) { return m_duplicateIds.contains(elementId.impl()); }
303
304     /**
305      * Retrieve all nodes that intersect a rect in the window's document, until it is fully enclosed by
306      * the boundaries of node.
307      *
308      * @param centerX x reference for the rectangle in CSS pixels
309      * @param centerY y reference for the rectangle in CSS pixels
310      * @param hPadding How much to expand the rectangle horizontally
311      * @param vPadding How much to expand the rectangle vertically
312      * @param ignoreClipping whether or not to ignore the root scroll frame when retrieving the element.
313      *        If false, this method returns null for coordinates outside of the viewport.
314      */
315     PassRefPtr<NodeList> nodesFromRect(int centerX, int centerY, unsigned hPadding, unsigned vPadding, bool ignoreClipping) const;
316     Element* elementFromPoint(int x, int y) const;
317     PassRefPtr<Range> caretRangeFromPoint(int x, int y);
318
319     String readyState() const;
320
321     String defaultCharset() const;
322     
323     // Synonyms backing similar DOM attributes. Use Document::encoding() to avoid virtual dispatch.
324     String inputEncoding() const { return Document::encoding(); }
325     String charset() const { return Document::encoding(); }
326     String characterSet() const { return Document::encoding(); }
327
328     void setCharset(const String&);
329
330     String contentLanguage() const { return m_contentLanguage; }
331     void setContentLanguage(const String& lang) { m_contentLanguage = lang; }
332
333     String xmlEncoding() const { return m_xmlEncoding; }
334     String xmlVersion() const { return m_xmlVersion; }
335     bool xmlStandalone() const { return m_xmlStandalone; }
336
337     void setXMLEncoding(const String& encoding) { m_xmlEncoding = encoding; } // read-only property, only to be set from XMLDocumentParser
338     void setXMLVersion(const String&, ExceptionCode&);
339     void setXMLStandalone(bool, ExceptionCode&);
340
341     String documentURI() const { return m_documentURI; }
342     void setDocumentURI(const String&);
343
344     virtual KURL baseURI() const;
345
346     PassRefPtr<Node> adoptNode(PassRefPtr<Node> source, ExceptionCode&);
347
348     PassRefPtr<HTMLCollection> images();
349     PassRefPtr<HTMLCollection> embeds();
350     PassRefPtr<HTMLCollection> plugins(); // an alias for embeds() required for the JS DOM bindings.
351     PassRefPtr<HTMLCollection> applets();
352     PassRefPtr<HTMLCollection> links();
353     PassRefPtr<HTMLCollection> forms();
354     PassRefPtr<HTMLCollection> anchors();
355     PassRefPtr<HTMLCollection> objects();
356     PassRefPtr<HTMLCollection> scripts();
357     PassRefPtr<HTMLCollection> windowNamedItems(const String& name);
358     PassRefPtr<HTMLCollection> documentNamedItems(const String& name);
359
360     PassRefPtr<HTMLAllCollection> all();
361
362     // Find first anchor with the given name.
363     // First searches for an element with the given ID, but if that fails, then looks
364     // for an anchor with the given name. ID matching is always case sensitive, but
365     // Anchor name matching is case sensitive in strict mode and not case sensitive in
366     // quirks mode for historical compatibility reasons.
367     Element* findAnchor(const String& name);
368
369     CollectionCache* collectionInfo(CollectionType type)
370     {
371         ASSERT(type >= FirstUnnamedDocumentCachedType);
372         unsigned index = type - FirstUnnamedDocumentCachedType;
373         ASSERT(index < NumUnnamedDocumentCachedTypes);
374         m_collectionInfo[index].checkConsistency();
375         return &m_collectionInfo[index]; 
376     }
377
378     CollectionCache* nameCollectionInfo(CollectionType, const AtomicString& name);
379
380     // Other methods (not part of DOM)
381     bool isHTMLDocument() const { return m_isHTML; }
382     bool isXHTMLDocument() const { return m_isXHTML; }
383     virtual bool isImageDocument() const { return false; }
384 #if ENABLE(SVG)
385     virtual bool isSVGDocument() const { return false; }
386 #else
387     static bool isSVGDocument() { return false; }
388 #endif
389     virtual bool isPluginDocument() const { return false; }
390     virtual bool isMediaDocument() const { return false; }
391 #if ENABLE(WML)
392     virtual bool isWMLDocument() const { return false; }
393 #endif
394 #if ENABLE(XHTMLMP)
395     bool isXHTMLMPDocument() const; 
396     bool shouldProcessNoscriptElement() const { return m_shouldProcessNoScriptElement; }
397     void setShouldProcessNoscriptElement(bool shouldDo) { m_shouldProcessNoScriptElement = shouldDo; }
398 #endif
399     virtual bool isFrameSet() const { return false; }
400     
401     CSSStyleSelector* styleSelector()
402     { 
403         if (!m_styleSelector)
404             createStyleSelector();
405         return m_styleSelector.get();
406     }
407
408     Element* getElementByAccessKey(const String& key) const;
409     
410     /**
411      * Updates the pending sheet count and then calls updateStyleSelector.
412      */
413     void removePendingSheet();
414
415     /**
416      * This method returns true if all top-level stylesheets have loaded (including
417      * any @imports that they may be loading).
418      */
419     bool haveStylesheetsLoaded() const
420     {
421         return m_pendingStylesheets <= 0 || m_ignorePendingStylesheets;
422     }
423
424     /**
425      * Increments the number of pending sheets.  The <link> elements
426      * invoke this to add themselves to the loading list.
427      */
428     void addPendingSheet() { m_pendingStylesheets++; }
429
430     void addStyleSheetCandidateNode(Node*, bool createdByParser);
431     void removeStyleSheetCandidateNode(Node*);
432
433     bool gotoAnchorNeededAfterStylesheetsLoad() { return m_gotoAnchorNeededAfterStylesheetsLoad; }
434     void setGotoAnchorNeededAfterStylesheetsLoad(bool b) { m_gotoAnchorNeededAfterStylesheetsLoad = b; }
435
436     /**
437      * Called when one or more stylesheets in the document may have been added, removed or changed.
438      *
439      * Creates a new style selector and assign it to this document. This is done by iterating through all nodes in
440      * document (or those before <BODY> in a HTML document), searching for stylesheets. Stylesheets can be contained in
441      * <LINK>, <STYLE> or <BODY> elements, as well as processing instructions (XML documents only). A list is
442      * constructed from these which is used to create the a new style selector which collates all of the stylesheets
443      * found and is used to calculate the derived styles for all rendering objects.
444      */
445     void styleSelectorChanged(StyleSelectorUpdateFlag);
446     void recalcStyleSelector();
447
448     bool usesDescendantRules() const { return m_usesDescendantRules; }
449     void setUsesDescendantRules(bool b) { m_usesDescendantRules = b; }
450     bool usesSiblingRules() const { return m_usesSiblingRules; }
451     void setUsesSiblingRules(bool b) { m_usesSiblingRules = b; }
452     bool usesFirstLineRules() const { return m_usesFirstLineRules; }
453     void setUsesFirstLineRules(bool b) { m_usesFirstLineRules = b; }
454     bool usesFirstLetterRules() const { return m_usesFirstLetterRules; }
455     void setUsesFirstLetterRules(bool b) { m_usesFirstLetterRules = b; }
456     bool usesBeforeAfterRules() const { return m_usesBeforeAfterRules; }
457     void setUsesBeforeAfterRules(bool b) { m_usesBeforeAfterRules = b; }
458     bool usesRemUnits() const { return m_usesRemUnits; }
459     void setUsesRemUnits(bool b) { m_usesRemUnits = b; }
460     bool usesLinkRules() const { return linkColor() != visitedLinkColor() || m_usesLinkRules; }
461     void setUsesLinkRules(bool b) { m_usesLinkRules = b; }
462
463     // Machinery for saving and restoring state when you leave and then go back to a page.
464     void registerFormElementWithState(Element* e) { m_formElementsWithState.add(e); }
465     void unregisterFormElementWithState(Element* e) { m_formElementsWithState.remove(e); }
466     Vector<String> formElementsState() const;
467     void setStateForNewFormElements(const Vector<String>&);
468     bool hasStateForNewFormElements() const;
469     bool takeStateForFormElement(AtomicStringImpl* name, AtomicStringImpl* type, String& state);
470
471     FrameView* view() const; // can be NULL
472     Frame* frame() const { return m_frame; } // can be NULL
473     Page* page() const; // can be NULL
474     Settings* settings() const; // can be NULL
475 #if ENABLE(INSPECTOR)
476     InspectorTimelineAgent* inspectorTimelineAgent() const; // can be NULL
477     virtual InspectorController* inspectorController() const; // can be NULL
478 #endif
479
480     PassRefPtr<Range> createRange();
481
482     PassRefPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow,
483         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
484
485     PassRefPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow, 
486         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
487
488     // Special support for editing
489     PassRefPtr<CSSStyleDeclaration> createCSSStyleDeclaration();
490     PassRefPtr<EditingText> createEditingTextNode(const String&);
491
492     virtual void recalcStyle(StyleChange = NoChange);
493     bool childNeedsAndNotInStyleRecalc();
494     virtual void updateStyleIfNeeded();
495     void updateLayout();
496     void updateLayoutIgnorePendingStylesheets();
497     PassRefPtr<RenderStyle> styleForElementIgnoringPendingStylesheets(Element*);
498     PassRefPtr<RenderStyle> styleForPage(int pageIndex);
499
500     // Returns true if page box (margin boxes and page borders) is visible.
501     bool isPageBoxVisible(int pageIndex);
502
503     // Returns the preferred page size and margins in pixels, assuming 96
504     // pixels per inch. pageSize, marginTop, marginRight, marginBottom,
505     // marginLeft must be initialized to the default values that are used if
506     // auto is specified.
507     void pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft);
508
509     static void updateStyleForAllDocuments(); // FIXME: Try to reduce the # of calls to this function.
510     DocLoader* docLoader() { return m_docLoader.get(); }
511
512     virtual void attach();
513     virtual void detach();
514
515     RenderArena* renderArena() { return m_renderArena.get(); }
516
517     RenderView* renderView() const;
518
519     void clearAXObjectCache();
520     AXObjectCache* axObjectCache() const;
521     
522     // to get visually ordered hebrew and arabic pages right
523     void setVisuallyOrdered();
524     bool visuallyOrdered() const { return m_visuallyOrdered; }
525
526     void open(Document* ownerDocument = 0);
527     void implicitOpen();
528     void close();
529     void implicitClose();
530     void cancelParsing();
531
532     void write(const SegmentedString& text, Document* ownerDocument = 0);
533     void write(const String& text, Document* ownerDocument = 0);
534     void writeln(const String& text, Document* ownerDocument = 0);
535     void finishParsing();
536
537     bool wellFormed() const { return m_wellFormed; }
538
539     const KURL& url() const { return m_url; }
540     void setURL(const KURL&);
541
542     const KURL& baseURL() const { return m_baseURL; }
543     // Setting the BaseElementURL will change the baseURL.
544     void setBaseElementURL(const KURL&);
545
546     const String& baseTarget() const { return m_baseTarget; }
547     // Setting the BaseElementTarget will change the baseTarget.
548     void setBaseElementTarget(const String& baseTarget) { m_baseTarget = baseTarget; }
549
550     KURL completeURL(const String&) const;
551
552     virtual String userAgent(const KURL&) const;
553
554     CSSStyleSheet* pageUserSheet();
555     void clearPageUserSheet();
556     void updatePageUserSheet();
557
558     const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets() const;
559     void clearPageGroupUserSheets();
560     void updatePageGroupUserSheets();
561
562     CSSStyleSheet* elementSheet();
563     CSSStyleSheet* mappedElementSheet();
564     
565     virtual PassRefPtr<DocumentParser> createParser();
566     DocumentParser* parser() const { return m_parser.get(); }
567     ScriptableDocumentParser* scriptableDocumentParser() const;
568     
569     bool printing() const { return m_printing; }
570     void setPrinting(bool p) { m_printing = p; }
571
572     bool paginatedForScreen() const { return m_paginatedForScreen; }
573     void setPaginatedForScreen(bool p) { m_paginatedForScreen = p; }
574     
575     bool paginated() const { return printing() || paginatedForScreen(); }
576
577     enum CompatibilityMode { QuirksMode, LimitedQuirksMode, NoQuirksMode };
578
579     virtual void setCompatibilityModeFromDoctype() { }
580     void setCompatibilityMode(CompatibilityMode m);
581     void lockCompatibilityMode() { m_compatibilityModeLocked = true; }
582     CompatibilityMode compatibilityMode() const { return m_compatibilityMode; }
583
584     bool inQuirksMode() const { return m_compatibilityMode == QuirksMode; }
585     bool inLimitedQuirksMode() const { return m_compatibilityMode == LimitedQuirksMode; }
586     bool inNoQuirksMode() const { return m_compatibilityMode == NoQuirksMode; }
587     
588     void setParsing(bool);
589     bool parsing() const { return m_bParsing; }
590     int minimumLayoutDelay();
591
592     // This method is used by Android.
593     void setExtraLayoutDelay(int delay) { m_extraLayoutDelay = delay; }
594
595     bool shouldScheduleLayout();
596     int elapsedTime() const;
597     
598     void setTextColor(const Color& color) { m_textColor = color; }
599     Color textColor() const { return m_textColor; }
600
601     const Color& linkColor() const { return m_linkColor; }
602     const Color& visitedLinkColor() const { return m_visitedLinkColor; }
603     const Color& activeLinkColor() const { return m_activeLinkColor; }
604     void setLinkColor(const Color& c) { m_linkColor = c; }
605     void setVisitedLinkColor(const Color& c) { m_visitedLinkColor = c; }
606     void setActiveLinkColor(const Color& c) { m_activeLinkColor = c; }
607     void resetLinkColor();
608     void resetVisitedLinkColor();
609     void resetActiveLinkColor();
610     
611     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const IntPoint&, const PlatformMouseEvent&);
612
613     StyleSheetList* styleSheets();
614
615     /* Newly proposed CSS3 mechanism for selecting alternate
616        stylesheets using the DOM. May be subject to change as
617        spec matures. - dwh
618     */
619     String preferredStylesheetSet() const;
620     String selectedStylesheetSet() const;
621     void setSelectedStylesheetSet(const String&);
622
623     bool setFocusedNode(PassRefPtr<Node>);
624     Node* focusedNode() const { return m_focusedNode.get(); }
625
626     void getFocusableNodes(Vector<RefPtr<Node> >&);
627     
628     // The m_ignoreAutofocus flag specifies whether or not the document has been changed by the user enough 
629     // for WebCore to ignore the autofocus attribute on any form controls
630     bool ignoreAutofocus() const { return m_ignoreAutofocus; };
631     void setIgnoreAutofocus(bool shouldIgnore = true) { m_ignoreAutofocus = shouldIgnore; };
632
633     void setHoverNode(PassRefPtr<Node>);
634     Node* hoverNode() const { return m_hoverNode.get(); }
635
636     void setActiveNode(PassRefPtr<Node>);
637     Node* activeNode() const { return m_activeNode.get(); }
638
639     void focusedNodeRemoved();
640     void removeFocusedNodeOfSubtree(Node*, bool amongChildrenOnly = false);
641     void hoveredNodeDetached(Node*);
642     void activeChainNodeDetached(Node*);
643
644     // Updates for :target (CSS3 selector).
645     void setCSSTarget(Element*);
646     Element* cssTarget() const { return m_cssTarget; }
647     
648     void scheduleForcedStyleRecalc();
649     void scheduleStyleRecalc();
650     void unscheduleStyleRecalc();
651     void styleRecalcTimerFired(Timer<Document>*);
652
653     void attachNodeIterator(NodeIterator*);
654     void detachNodeIterator(NodeIterator*);
655
656     void attachRange(Range*);
657     void detachRange(Range*);
658
659     void nodeChildrenChanged(ContainerNode*);
660     // nodeChildrenWillBeRemoved is used when removing all node children at once.
661     void nodeChildrenWillBeRemoved(ContainerNode*);
662     // nodeWillBeRemoved is only safe when removing one node at a time.
663     void nodeWillBeRemoved(Node*);
664
665     void textInserted(Node*, unsigned offset, unsigned length);
666     void textRemoved(Node*, unsigned offset, unsigned length);
667     void textNodesMerged(Text* oldNode, unsigned offset);
668     void textNodeSplit(Text* oldNode);
669
670     DOMWindow* defaultView() const { return domWindow(); } 
671     DOMWindow* domWindow() const;
672
673     // Helper functions for forwarding DOMWindow event related tasks to the DOMWindow if it exists.
674     void setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
675     EventListener* getWindowAttributeEventListener(const AtomicString& eventType);
676     void dispatchWindowEvent(PassRefPtr<Event>, PassRefPtr<EventTarget> = 0);
677     void dispatchWindowLoadEvent();
678
679     PassRefPtr<Event> createEvent(const String& eventType, ExceptionCode&);
680
681     // keep track of what types of event listeners are registered, so we don't
682     // dispatch events unnecessarily
683     enum ListenerType {
684         DOMSUBTREEMODIFIED_LISTENER          = 0x01,
685         DOMNODEINSERTED_LISTENER             = 0x02,
686         DOMNODEREMOVED_LISTENER              = 0x04,
687         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 0x08,
688         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 0x10,
689         DOMATTRMODIFIED_LISTENER             = 0x20,
690         DOMCHARACTERDATAMODIFIED_LISTENER    = 0x40,
691         OVERFLOWCHANGED_LISTENER             = 0x80,
692         ANIMATIONEND_LISTENER                = 0x100,
693         ANIMATIONSTART_LISTENER              = 0x200,
694         ANIMATIONITERATION_LISTENER          = 0x400,
695         TRANSITIONEND_LISTENER               = 0x800,
696         BEFORELOAD_LISTENER                  = 0x1000,
697         TOUCH_LISTENER                       = 0x2000,
698         BEFOREPROCESS_LISTENER               = 0x4000
699     };
700
701     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
702     void addListenerType(ListenerType listenerType) { m_listenerTypes = m_listenerTypes | listenerType; }
703     void addListenerTypeIfNeeded(const AtomicString& eventType);
704
705     CSSStyleDeclaration* getOverrideStyle(Element*, const String& pseudoElt);
706
707     /**
708      * Searches through the document, starting from fromNode, for the next selectable element that comes after fromNode.
709      * The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab indexes
710      * first (from lowest to highest), and then elements without tab indexes (in document order).
711      *
712      * @param fromNode The node from which to start searching. The node after this will be focused. May be null.
713      *
714      * @return The focus node that comes after fromNode
715      *
716      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
717      */
718     Node* nextFocusableNode(Node* start, KeyboardEvent*);
719
720     /**
721      * Searches through the document, starting from fromNode, for the previous selectable element (that comes _before_)
722      * fromNode. The order followed is as specified in section 17.11.1 of the HTML4 spec, which is elements with tab
723      * indexes first (from lowest to highest), and then elements without tab indexes (in document order).
724      *
725      * @param fromNode The node from which to start searching. The node before this will be focused. May be null.
726      *
727      * @return The focus node that comes before fromNode
728      *
729      * See http://www.w3.org/TR/html4/interact/forms.html#h-17.11.1
730      */
731     Node* previousFocusableNode(Node* start, KeyboardEvent*);
732
733     int nodeAbsIndex(Node*);
734     Node* nodeWithAbsIndex(int absIndex);
735
736     /**
737      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
738      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
739      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
740      * specified in a HTML file.
741      *
742      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
743      * @param content The header value (value of the meta tag's "content" attribute)
744      */
745     void processHttpEquiv(const String& equiv, const String& content);
746     void processViewport(const String& features);
747
748     // Returns the owning element in the parent document.
749     // Returns 0 if this is the top level document.
750     HTMLFrameOwnerElement* ownerElement() const;
751
752     String title() const { return m_title; }
753     void setTitle(const String&, Element* titleElement = 0);
754     void removeTitle(Element* titleElement);
755
756     String cookie(ExceptionCode&) const;
757     void setCookie(const String&, ExceptionCode&);
758
759     String referrer() const;
760
761     String domain() const;
762     void setDomain(const String& newDomain, ExceptionCode&);
763
764     String lastModified() const;
765
766     // The cookieURL is used to query the cookie database for this document's
767     // cookies. For example, if the cookie URL is http://example.com, we'll
768     // use the non-Secure cookies for example.com when computing
769     // document.cookie.
770     //
771     // Q: How is the cookieURL different from the document's URL?
772     // A: The two URLs are the same almost all the time.  However, if one
773     //    document inherits the security context of another document, it
774     //    inherits its cookieURL but not its URL.
775     //
776     const KURL& cookieURL() const { return m_cookieURL; }
777
778     // The firstPartyForCookies is used to compute whether this document
779     // appears in a "third-party" context for the purpose of third-party
780     // cookie blocking.  The document is in a third-party context if the
781     // cookieURL and the firstPartyForCookies are from different hosts.
782     //
783     // Note: Some ports (including possibly Apple's) only consider the
784     //       document in a third-party context if the cookieURL and the
785     //       firstPartyForCookies have a different registry-controlled
786     //       domain.
787     //
788     const KURL& firstPartyForCookies() const { return m_firstPartyForCookies; }
789     void setFirstPartyForCookies(const KURL& url) { m_firstPartyForCookies = url; }
790     
791     // The following implements the rule from HTML 4 for what valid names are.
792     // To get this right for all the XML cases, we probably have to improve this or move it
793     // and make it sensitive to the type of document.
794     static bool isValidName(const String&);
795
796     // The following breaks a qualified name into a prefix and a local name.
797     // It also does a validity check, and returns false if the qualified name
798     // is invalid.  It also sets ExceptionCode when name is invalid.
799     static bool parseQualifiedName(const String& qualifiedName, String& prefix, String& localName, ExceptionCode&);
800     
801     // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
802     static bool hasPrefixNamespaceMismatch(const QualifiedName&);
803     
804     void addElementById(const AtomicString& elementId, Element *element);
805     void removeElementById(const AtomicString& elementId, Element *element);
806
807     void addImageMap(HTMLMapElement*);
808     void removeImageMap(HTMLMapElement*);
809     HTMLMapElement* getImageMap(const String& url) const;
810
811     HTMLElement* body() const;
812     void setBody(PassRefPtr<HTMLElement>, ExceptionCode&);
813
814     HTMLHeadElement* head();
815
816     DocumentMarkerController* markers() const { return m_markers.get(); }
817
818     bool execCommand(const String& command, bool userInterface = false, const String& value = String());
819     bool queryCommandEnabled(const String& command);
820     bool queryCommandIndeterm(const String& command);
821     bool queryCommandState(const String& command);
822     bool queryCommandSupported(const String& command);
823     String queryCommandValue(const String& command);
824     
825     // designMode support
826     enum InheritedBool { off = false, on = true, inherit };    
827     void setDesignMode(InheritedBool value);
828     InheritedBool getDesignMode() const;
829     bool inDesignMode() const;
830
831     Document* parentDocument() const;
832     Document* topDocument() const;
833
834     int docID() const { return m_docID; }
835     
836     AsyncScriptRunner* asyncScriptRunner() { return m_asyncScriptRunner.get(); }
837
838 #if ENABLE(XSLT)
839     void applyXSLTransform(ProcessingInstruction* pi);
840     PassRefPtr<Document> transformSourceDocument() { return m_transformSourceDocument; }
841     void setTransformSourceDocument(Document* doc) { m_transformSourceDocument = doc; }
842
843     void setTransformSource(PassOwnPtr<TransformSource>);
844     TransformSource* transformSource() const { return m_transformSource.get(); }
845 #endif
846
847     void incDOMTreeVersion() { ++m_domTreeVersion; }
848     unsigned domTreeVersion() const { return m_domTreeVersion; }
849
850     void setDocType(PassRefPtr<DocumentType>);
851
852 #if ENABLE(XPATH)
853     // XPathEvaluator methods
854     PassRefPtr<XPathExpression> createExpression(const String& expression,
855                                                  XPathNSResolver* resolver,
856                                                  ExceptionCode& ec);
857     PassRefPtr<XPathNSResolver> createNSResolver(Node *nodeResolver);
858     PassRefPtr<XPathResult> evaluate(const String& expression,
859                                      Node* contextNode,
860                                      XPathNSResolver* resolver,
861                                      unsigned short type,
862                                      XPathResult* result,
863                                      ExceptionCode& ec);
864 #endif // ENABLE(XPATH)
865     
866     enum PendingSheetLayout { NoLayoutWithPendingSheets, DidLayoutWithPendingSheets, IgnoreLayoutWithPendingSheets };
867
868     bool didLayoutWithPendingStylesheets() const { return m_pendingSheetLayout == DidLayoutWithPendingSheets; }
869     
870     void setHasNodesWithPlaceholderStyle() { m_hasNodesWithPlaceholderStyle = true; }
871
872     const String& iconURL() const { return m_iconURL; }
873     void setIconURL(const String& iconURL, const String& type);
874
875     void setUseSecureKeyboardEntryWhenActive(bool);
876     bool useSecureKeyboardEntryWhenActive() const;
877
878     void addNodeListCache() { ++m_numNodeListCaches; }
879     void removeNodeListCache() { ASSERT(m_numNodeListCaches > 0); --m_numNodeListCaches; }
880     bool hasNodeListCaches() const { return m_numNodeListCaches; }
881
882     void updateFocusAppearanceSoon(bool restorePreviousSelection);
883     void cancelFocusAppearanceUpdate();
884         
885     // FF method for accessing the selection added for compatibility.
886     DOMSelection* getSelection() const;
887     
888     // Extension for manipulating canvas drawing contexts for use in CSS
889     CanvasRenderingContext* getCSSCanvasContext(const String& type, const String& name, int width, int height);
890     HTMLCanvasElement* getCSSCanvasElement(const String& name);
891
892     bool isDNSPrefetchEnabled() const { return m_isDNSPrefetchEnabled; }
893     void parseDNSPrefetchControlHeader(const String&);
894
895     virtual void reportException(const String& errorMessage, int lineNumber, const String& sourceURL);
896     virtual void addMessage(MessageSource, MessageType, MessageLevel, const String& message, unsigned lineNumber, const String& sourceURL);
897     virtual void postTask(PassOwnPtr<Task>); // Executes the task on context's thread asynchronously.
898
899 #if USE(JSC)
900     typedef JSC::WeakGCMap<WebCore::Node*, JSNode*> JSWrapperCache;
901     typedef HashMap<DOMWrapperWorld*, JSWrapperCache*> JSWrapperCacheMap;
902     JSWrapperCacheMap& wrapperCacheMap() { return m_wrapperCacheMap; }
903     JSWrapperCache* getWrapperCache(DOMWrapperWorld* world);
904     JSWrapperCache* createWrapperCache(DOMWrapperWorld*);
905     void destroyWrapperCache(DOMWrapperWorld*);
906     void destroyAllWrapperCaches();
907 #endif
908
909     virtual void finishedParsing();
910
911     bool inPageCache() const { return m_inPageCache; }
912     void setInPageCache(bool flag);
913     
914     // Elements can register themselves for the "documentWillBecomeInactive()" and  
915     // "documentDidBecomeActive()" callbacks
916     void registerForDocumentActivationCallbacks(Element*);
917     void unregisterForDocumentActivationCallbacks(Element*);
918     void documentWillBecomeInactive();
919     void documentDidBecomeActive();
920
921     void registerForMediaVolumeCallbacks(Element*);
922     void unregisterForMediaVolumeCallbacks(Element*);
923     void mediaVolumeDidChange();
924
925     void setShouldCreateRenderers(bool);
926     bool shouldCreateRenderers();
927
928     void setDecoder(PassRefPtr<TextResourceDecoder>);
929     TextResourceDecoder* decoder() const { return m_decoder.get(); }
930
931     String displayStringModifiedByEncoding(const String&) const;
932     PassRefPtr<StringImpl> displayStringModifiedByEncoding(PassRefPtr<StringImpl>) const;
933     void displayBufferModifiedByEncoding(UChar* buffer, unsigned len) const;
934
935     // Quirk for the benefit of Apple's Dictionary application.
936     void setFrameElementsShouldIgnoreScrolling(bool ignore) { m_frameElementsShouldIgnoreScrolling = ignore; }
937     bool frameElementsShouldIgnoreScrolling() const { return m_frameElementsShouldIgnoreScrolling; }
938
939 #if ENABLE(DASHBOARD_SUPPORT)
940     void setDashboardRegionsDirty(bool f) { m_dashboardRegionsDirty = f; }
941     bool dashboardRegionsDirty() const { return m_dashboardRegionsDirty; }
942     bool hasDashboardRegions () const { return m_hasDashboardRegions; }
943     void setHasDashboardRegions(bool f) { m_hasDashboardRegions = f; }
944     const Vector<DashboardRegionValue>& dashboardRegions() const;
945     void setDashboardRegions(const Vector<DashboardRegionValue>&);
946 #endif
947
948     virtual void removeAllEventListeners();
949
950     CheckedRadioButtons& checkedRadioButtons() { return m_checkedRadioButtons; }
951     
952 #if ENABLE(SVG)
953     const SVGDocumentExtensions* svgExtensions();
954     SVGDocumentExtensions* accessSVGExtensions();
955 #endif
956
957     void initSecurityContext();
958
959     // Explicitly override the security origin for this document.
960     // Note: It is dangerous to change the security origin of a document
961     //       that already contains content.
962     void setSecurityOrigin(SecurityOrigin*);
963
964     void updateURLForPushOrReplaceState(const KURL&);
965     void statePopped(SerializedScriptValue*);
966
967     bool processingLoadEvent() const { return m_processingLoadEvent; }
968
969 #if ENABLE(DATABASE)
970     virtual bool isDatabaseReadOnly() const;
971     virtual void databaseExceededQuota(const String& name);
972 #endif
973
974     virtual bool isContextThread() const;
975     virtual bool isJSExecutionTerminated() const { return false; }
976
977     void setUsingGeolocation(bool f) { m_usingGeolocation = f; }
978     bool usingGeolocation() const { return m_usingGeolocation; };
979
980 #if ENABLE(WML)
981     void setContainsWMLContent(bool value) { m_containsWMLContent = value; }
982     bool containsWMLContent() const { return m_containsWMLContent; }
983
984     void resetWMLPageState();
985     void initializeWMLPageState();
986 #endif
987     
988     bool containsValidityStyleRules() const { return m_containsValidityStyleRules; }
989     void setContainsValidityStyleRules() { m_containsValidityStyleRules = true; }
990
991     void enqueueEvent(PassRefPtr<Event>);
992     void enqueuePageshowEvent(PageshowEventPersistence);
993     void enqueueHashchangeEvent(const String& oldURL, const String& newURL);
994
995     void addMediaCanStartListener(MediaCanStartListener*);
996     void removeMediaCanStartListener(MediaCanStartListener*);
997     MediaCanStartListener* takeAnyMediaCanStartListener();
998
999     const QualifiedName& idAttributeName() const { return m_idAttributeName; }
1000
1001     bool writeDisabled() const { return m_writeDisabled; }
1002     void setWriteDisabled(bool flag) { m_writeDisabled = flag; }
1003
1004     // Used to allow element that loads data without going through a FrameLoader to delay the 'load' event.
1005     void incrementLoadEventDelayCount() { ++m_loadEventDelayCount; }
1006     void decrementLoadEventDelayCount();
1007     bool isDelayingLoadEvent() const { return m_loadEventDelayCount; }
1008
1009 protected:
1010     Document(Frame*, const KURL&, bool isXHTML, bool isHTML);
1011
1012     void clearXMLVersion() { m_xmlVersion = String(); }
1013
1014 private:
1015     void detachParser();
1016
1017     typedef void (*ArgumentsCallback)(const String& keyString, const String& valueString, Document*, void* data);
1018     void processArguments(const String& features, void* data, ArgumentsCallback);
1019
1020     virtual bool isDocument() const { return true; }
1021     virtual void removedLastRef();
1022
1023     virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
1024
1025     virtual String nodeName() const;
1026     virtual NodeType nodeType() const;
1027     virtual bool childTypeAllowed(NodeType);
1028     virtual PassRefPtr<Node> cloneNode(bool deep);
1029     virtual bool canReplaceChild(Node* newChild, Node* oldChild);
1030
1031     virtual void refScriptExecutionContext() { ref(); }
1032     virtual void derefScriptExecutionContext() { deref(); }
1033
1034     virtual const KURL& virtualURL() const; // Same as url(), but needed for ScriptExecutionContext to implement it without a performance loss for direct calls.
1035     virtual KURL virtualCompleteURL(const String&) const; // Same as completeURL() for the same reason as above.
1036
1037     void initDNSPrefetch();
1038
1039     String encoding() const;
1040
1041     void updateTitle();
1042     void updateFocusAppearanceTimerFired(Timer<Document>*);
1043     void updateBaseURL();
1044
1045     void cacheDocumentElement() const;
1046
1047     void createStyleSelector();
1048
1049     void enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject);
1050     void pendingEventTimerFired(Timer<Document>*);
1051
1052     PassRefPtr<NodeList> handleZeroPadding(const HitTestRequest&, HitTestResult&) const;
1053
1054     OwnPtr<CSSStyleSelector> m_styleSelector;
1055     bool m_didCalculateStyleSelector;
1056
1057     Frame* m_frame;
1058     OwnPtr<DocLoader> m_docLoader;
1059     RefPtr<DocumentParser> m_parser;
1060     bool m_wellFormed;
1061
1062     // Document URLs.
1063     KURL m_url; // Document.URL: The URL from which this document was retrieved.
1064     KURL m_baseURL; // Node.baseURI: The URL to use when resolving relative URLs.
1065     KURL m_baseElementURL; // The URL set by the <base> element.
1066     KURL m_cookieURL; // The URL to use for cookie access.
1067     KURL m_firstPartyForCookies; // The policy URL for third-party cookie blocking.
1068
1069     // Document.documentURI:
1070     // Although URL-like, Document.documentURI can actually be set to any
1071     // string by content.  Document.documentURI affects m_baseURL unless the
1072     // document contains a <base> element, in which case the <base> element
1073     // takes precedence.
1074     String m_documentURI;
1075
1076     String m_baseTarget;
1077
1078     RefPtr<DocumentType> m_docType;
1079     mutable RefPtr<DOMImplementation> m_implementation;
1080
1081     // Track the number of currently loading top-level stylesheets.  Sheets
1082     // loaded using the @import directive are not included in this count.
1083     // We use this count of pending sheets to detect when we can begin attaching
1084     // elements.
1085     int m_pendingStylesheets;
1086
1087     // But sometimes you need to ignore pending stylesheet count to
1088     // force an immediate layout when requested by JS.
1089     bool m_ignorePendingStylesheets;
1090
1091     // If we do ignore the pending stylesheet count, then we need to add a boolean
1092     // to track that this happened so that we can do a full repaint when the stylesheets
1093     // do eventually load.
1094     PendingSheetLayout m_pendingSheetLayout;
1095     
1096     bool m_hasNodesWithPlaceholderStyle;
1097
1098     RefPtr<CSSStyleSheet> m_elemSheet;
1099     RefPtr<CSSStyleSheet> m_mappedElementSheet;
1100     RefPtr<CSSStyleSheet> m_pageUserSheet;
1101     mutable OwnPtr<Vector<RefPtr<CSSStyleSheet> > > m_pageGroupUserSheets;
1102     mutable bool m_pageGroupUserSheetCacheValid;
1103
1104     bool m_printing;
1105     bool m_paginatedForScreen;
1106
1107     bool m_ignoreAutofocus;
1108
1109     CompatibilityMode m_compatibilityMode;
1110     bool m_compatibilityModeLocked; // This is cheaper than making setCompatibilityMode virtual.
1111
1112     Color m_textColor;
1113
1114     RefPtr<Node> m_focusedNode;
1115     RefPtr<Node> m_hoverNode;
1116     RefPtr<Node> m_activeNode;
1117     mutable RefPtr<Element> m_documentElement;
1118
1119     unsigned m_domTreeVersion;
1120     
1121     HashSet<NodeIterator*> m_nodeIterators;
1122     HashSet<Range*> m_ranges;
1123
1124     unsigned short m_listenerTypes;
1125
1126     RefPtr<StyleSheetList> m_styleSheets; // All of the stylesheets that are currently in effect for our media type and stylesheet set.
1127     
1128     typedef ListHashSet<Node*, 32> StyleSheetCandidateListHashSet;
1129     StyleSheetCandidateListHashSet m_styleSheetCandidateNodes; // All of the nodes that could potentially provide stylesheets to the document (<link>, <style>, <?xml-stylesheet>)
1130
1131     typedef ListHashSet<Element*, 64> FormElementListHashSet;
1132     FormElementListHashSet m_formElementsWithState;
1133
1134     typedef HashMap<FormElementKey, Vector<String>, FormElementKeyHash, FormElementKeyHashTraits> FormElementStateMap;
1135     FormElementStateMap m_stateForNewFormElements;
1136     
1137     Color m_linkColor;
1138     Color m_visitedLinkColor;
1139     Color m_activeLinkColor;
1140
1141     String m_preferredStylesheetSet;
1142     String m_selectedStylesheetSet;
1143
1144     bool m_loadingSheet;
1145     bool m_visuallyOrdered;
1146     bool m_bParsing;
1147     
1148     Timer<Document> m_styleRecalcTimer;
1149     bool m_pendingStyleRecalcShouldForce;
1150     bool m_inStyleRecalc;
1151     bool m_closeAfterStyleRecalc;
1152
1153     bool m_usesDescendantRules;
1154     bool m_usesSiblingRules;
1155     bool m_usesFirstLineRules;
1156     bool m_usesFirstLetterRules;
1157     bool m_usesBeforeAfterRules;
1158     bool m_usesRemUnits;
1159     bool m_usesLinkRules;
1160     bool m_gotoAnchorNeededAfterStylesheetsLoad;
1161     bool m_isDNSPrefetchEnabled;
1162     bool m_haveExplicitlyDisabledDNSPrefetch;
1163     bool m_frameElementsShouldIgnoreScrolling;
1164     bool m_containsValidityStyleRules;
1165     bool m_updateFocusAppearanceRestoresSelection;
1166
1167     // http://www.whatwg.org/specs/web-apps/current-work/#write-neutralised
1168     bool m_writeDisabled;
1169
1170     String m_title;
1171     String m_rawTitle;
1172     bool m_titleSetExplicitly;
1173     RefPtr<Element> m_titleElement;
1174
1175     OwnPtr<RenderArena> m_renderArena;
1176
1177     mutable AXObjectCache* m_axObjectCache;
1178     OwnPtr<DocumentMarkerController> m_markers;
1179     
1180     Timer<Document> m_updateFocusAppearanceTimer;
1181
1182     Element* m_cssTarget;
1183     
1184     bool m_processingLoadEvent;
1185     RefPtr<SerializedScriptValue> m_pendingStateObject;
1186     double m_startTime;
1187     bool m_overMinimumLayoutThreshold;
1188     // This is used to increase the minimum delay between re-layouts. It is set
1189     // using setExtraLayoutDelay to modify the minimum delay used at different
1190     // points during the lifetime of the Document.
1191     int m_extraLayoutDelay;
1192     
1193     OwnPtr<AsyncScriptRunner> m_asyncScriptRunner;
1194
1195 #if ENABLE(XSLT)
1196     OwnPtr<TransformSource> m_transformSource;
1197     RefPtr<Document> m_transformSourceDocument;
1198 #endif
1199
1200     typedef HashMap<AtomicStringImpl*, HTMLMapElement*> ImageMapsByName;
1201     ImageMapsByName m_imageMapsByName;
1202
1203     int m_docID; // A unique document identifier used for things like document-specific mapped attributes.
1204
1205     String m_xmlEncoding;
1206     String m_xmlVersion;
1207     bool m_xmlStandalone;
1208
1209     String m_contentLanguage;
1210
1211 #if ENABLE(XHTMLMP)
1212     bool m_shouldProcessNoScriptElement;
1213 #endif
1214
1215     RenderObject* m_savedRenderer;
1216     
1217     RefPtr<TextResourceDecoder> m_decoder;
1218
1219     // We maintain the invariant that m_duplicateIds is the count of all elements with a given ID
1220     // excluding the one referenced in m_elementsById, if any. This means it one less than the total count
1221     // when the first node with a given ID is cached, otherwise the same as the total count.
1222     mutable HashMap<AtomicStringImpl*, Element*> m_elementsById;
1223     mutable HashCountedSet<AtomicStringImpl*> m_duplicateIds;
1224     
1225     mutable HashMap<StringImpl*, Element*, CaseFoldingHash> m_elementsByAccessKey;
1226     
1227     InheritedBool m_designMode;
1228     
1229     int m_selfOnlyRefCount;
1230
1231     CheckedRadioButtons m_checkedRadioButtons;
1232
1233     typedef HashMap<AtomicStringImpl*, CollectionCache*> NamedCollectionMap;
1234     FixedArray<CollectionCache, NumUnnamedDocumentCachedTypes> m_collectionInfo;
1235     FixedArray<NamedCollectionMap, NumNamedDocumentCachedTypes> m_nameCollectionInfo;
1236
1237 #if ENABLE(XPATH)
1238     RefPtr<XPathEvaluator> m_xpathEvaluator;
1239 #endif
1240     
1241 #if ENABLE(SVG)
1242     OwnPtr<SVGDocumentExtensions> m_svgExtensions;
1243 #endif
1244     
1245 #if ENABLE(DASHBOARD_SUPPORT)
1246     Vector<DashboardRegionValue> m_dashboardRegions;
1247     bool m_hasDashboardRegions;
1248     bool m_dashboardRegionsDirty;
1249 #endif
1250
1251     HashMap<String, RefPtr<HTMLCanvasElement> > m_cssCanvasElements;
1252
1253     mutable bool m_accessKeyMapValid;
1254     bool m_createRenderers;
1255     bool m_inPageCache;
1256     String m_iconURL;
1257     
1258     HashSet<Element*> m_documentActivationCallbackElements;
1259     HashSet<Element*> m_mediaVolumeCallbackElements;
1260
1261     bool m_useSecureKeyboardEntryWhenActive;
1262
1263     bool m_isXHTML;
1264     bool m_isHTML;
1265
1266     unsigned m_numNodeListCaches;
1267
1268 #if USE(JSC)
1269     JSWrapperCacheMap m_wrapperCacheMap;
1270     JSWrapperCache* m_normalWorldWrapperCache;
1271 #endif
1272
1273     bool m_usingGeolocation;
1274
1275     Timer<Document> m_pendingEventTimer;
1276     Vector<RefPtr<Event> > m_pendingEventQueue;
1277
1278 #if ENABLE(WML)
1279     bool m_containsWMLContent;
1280 #endif
1281
1282     RefPtr<DocumentWeakReference> m_weakReference;
1283
1284     HashSet<MediaCanStartListener*> m_mediaCanStartListeners;
1285
1286     QualifiedName m_idAttributeName;
1287
1288     int m_loadEventDelayCount;
1289 };
1290
1291 inline bool Document::hasElementWithId(AtomicStringImpl* id) const
1292 {
1293     ASSERT(id);
1294     return m_elementsById.contains(id) || m_duplicateIds.contains(id);
1295 }
1296     
1297 inline bool Node::isDocumentNode() const
1298 {
1299     return this == m_document;
1300 }
1301
1302 // here because it uses a Document method but we really want to inline it
1303 inline Node::Node(Document* document, ConstructionType type)
1304     : TreeShared<ContainerNode>(initialRefCount(type))
1305     , m_document(document)
1306     , m_previous(0)
1307     , m_next(0)
1308     , m_renderer(0)
1309     , m_nodeFlags(type)
1310 {
1311     if (m_document)
1312         m_document->selfOnlyRef();
1313 #if !defined(NDEBUG) || (defined(DUMP_NODE_STATISTICS) && DUMP_NODE_STATISTICS)
1314     trackForDebugging();
1315 #endif
1316 }
1317
1318 } // namespace WebCore
1319
1320 #endif // Document_h