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