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