0b809e53752af4e69d6c0a899ee72e0a927001d6
[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, 2012 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  * Copyright (C) 2011 Google Inc. All rights reserved.
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Library General Public
13  * License as published by the Free Software Foundation; either
14  * version 2 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Library General Public License for more details.
20  *
21  * You should have received a copy of the GNU Library General Public License
22  * along with this library; see the file COPYING.LIB.  If not, write to
23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24  * Boston, MA 02110-1301, USA.
25  *
26  */
27
28 #ifndef Document_h
29 #define Document_h
30
31 #include "CollectionType.h"
32 #include "Color.h"
33 #include "ContainerNode.h"
34 #include "DOMTimeStamp.h"
35 #include "DocumentEventQueue.h"
36 #include "DocumentTiming.h"
37 #include "IconURL.h"
38 #include "InspectorCounters.h"
39 #include "IntRect.h"
40 #include "MutationObserver.h"
41 #include "PageVisibilityState.h"
42 #include "PlatformScreen.h"
43 #include "QualifiedName.h"
44 #include "ReferrerPolicy.h"
45 #include "ScriptExecutionContext.h"
46 #include "StringWithDirection.h"
47 #include "Timer.h"
48 #include "TreeScope.h"
49 #include "UserActionElementSet.h"
50 #include "ViewportArguments.h"
51 #include <wtf/Deque.h>
52 #include <wtf/FixedArray.h>
53 #include <wtf/OwnPtr.h>
54 #include <wtf/PassOwnPtr.h>
55 #include <wtf/PassRefPtr.h>
56
57 namespace WebCore {
58
59 class AXObjectCache;
60 class Attr;
61 class CDATASection;
62 class CSSStyleDeclaration;
63 class CSSStyleSheet;
64 class CachedCSSStyleSheet;
65 class CachedResourceLoader;
66 class CachedScript;
67 class CanvasRenderingContext;
68 class CharacterData;
69 class Comment;
70 class ContextFeatures;
71 class DOMImplementation;
72 class DOMNamedFlowCollection;
73 class DOMSelection;
74 class DOMWindow;
75 class Database;
76 class DatabaseThread;
77 class DocumentFragment;
78 class DocumentLoader;
79 class DocumentMarkerController;
80 class DocumentParser;
81 class DocumentSharedObjectPool;
82 class DocumentStyleSheetCollection;
83 class DocumentType;
84 class DocumentWeakReference;
85 class Element;
86 class EntityReference;
87 class Event;
88 class EventListener;
89 class FloatRect;
90 class FloatQuad;
91 class FormController;
92 class Frame;
93 class FrameView;
94 class HTMLCanvasElement;
95 class HTMLCollection;
96 class HTMLAllCollection;
97 class HTMLDocument;
98 class HTMLElement;
99 class HTMLFrameOwnerElement;
100 class HTMLHeadElement;
101 class HTMLIFrameElement;
102 class HTMLMapElement;
103 class HTMLNameCollection;
104 class HitTestRequest;
105 class HitTestResult;
106 class IntPoint;
107 class LayoutPoint;
108 class LayoutRect;
109 class LiveNodeListBase;
110 class DOMWrapperWorld;
111 class JSNode;
112 class Locale;
113 class MediaCanStartListener;
114 class MediaQueryList;
115 class MediaQueryMatcher;
116 class MouseEventWithHitTestResults;
117 class NamedFlowCollection;
118 class NodeFilter;
119 class NodeIterator;
120 class Page;
121 class PlatformMouseEvent;
122 class ProcessingInstruction;
123 class Range;
124 class RegisteredEventListener;
125 class RenderArena;
126 class RenderView;
127 class RenderFullScreen;
128 class ScriptableDocumentParser;
129 class ScriptElementData;
130 class ScriptRunner;
131 class SecurityOrigin;
132 class SelectorQueryCache;
133 class SerializedScriptValue;
134 class SegmentedString;
135 class Settings;
136 class StyleResolver;
137 class StyleSheet;
138 class StyleSheetContents;
139 class StyleSheetList;
140 class Text;
141 class TextResourceDecoder;
142 class TreeWalker;
143 class VisitedLinkState;
144 class WebKitNamedFlow;
145 class XMLHttpRequest;
146 class XPathEvaluator;
147 class XPathExpression;
148 class XPathNSResolver;
149 class XPathResult;
150
151 #if ENABLE(SVG)
152 class SVGDocumentExtensions;
153 #endif
154
155 #if ENABLE(XSLT)
156 class TransformSource;
157 #endif
158
159 #if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
160 struct AnnotatedRegionValue;
161 #endif
162
163 #if ENABLE(TOUCH_EVENTS)
164 class Touch;
165 class TouchList;
166 #endif
167
168 #if ENABLE(REQUEST_ANIMATION_FRAME)
169 class RequestAnimationFrameCallback;
170 class ScriptedAnimationController;
171 #endif
172
173 #if ENABLE(MICRODATA)
174 class MicroDataItemList;
175 #endif
176
177 #if ENABLE(LINK_PRERENDER)
178 class Prerenderer;
179 #endif
180
181 #if ENABLE(TEXT_AUTOSIZING)
182 class TextAutosizer;
183 #endif
184
185 #if ENABLE(CSP_NEXT)
186 class DOMSecurityPolicy;
187 #endif
188
189 typedef int ExceptionCode;
190
191 enum PageshowEventPersistence {
192     PageshowEventNotPersisted = 0,
193     PageshowEventPersisted = 1
194 };
195
196 enum StyleResolverUpdateFlag { RecalcStyleImmediately, DeferRecalcStyle, RecalcStyleIfNeeded };
197
198 enum NodeListInvalidationType {
199     DoNotInvalidateOnAttributeChanges = 0,
200     InvalidateOnClassAttrChange,
201     InvalidateOnIdNameAttrChange,
202     InvalidateOnNameAttrChange,
203     InvalidateOnForAttrChange,
204     InvalidateForFormControls,
205     InvalidateOnHRefAttrChange,
206     InvalidateOnItemAttrChange,
207     InvalidateOnAnyAttrChange,
208 };
209 const int numNodeListInvalidationTypes = InvalidateOnAnyAttrChange + 1;
210
211 typedef HashCountedSet<Node*> TouchEventTargetSet;
212
213 class Document : public ContainerNode, public TreeScope, public ScriptExecutionContext {
214 public:
215     static PassRefPtr<Document> create(Frame* frame, const KURL& url)
216     {
217         return adoptRef(new Document(frame, url, false, false));
218     }
219     static PassRefPtr<Document> createXHTML(Frame* frame, const KURL& url)
220     {
221         return adoptRef(new Document(frame, url, true, false));
222     }
223     virtual ~Document();
224
225     MediaQueryMatcher* mediaQueryMatcher();
226
227     using ContainerNode::ref;
228     using ContainerNode::deref;
229
230     // Nodes belonging to this document hold guard references -
231     // these are enough to keep the document from being destroyed, but
232     // not enough to keep it from removing its children. This allows a
233     // node that outlives its document to still have a valid document
234     // pointer without introducing reference cycles.
235     void guardRef()
236     {
237         ASSERT(!m_deletionHasBegun);
238         ++m_guardRefCount;
239     }
240
241     void guardDeref()
242     {
243         ASSERT(!m_deletionHasBegun);
244         --m_guardRefCount;
245         if (!m_guardRefCount && !refCount()) {
246 #ifndef NDEBUG
247             m_deletionHasBegun = true;
248 #endif
249             delete this;
250         }
251     }
252
253     Element* getElementById(const AtomicString& id) const;
254
255     virtual bool canContainRangeEndPoint() const { return true; }
256
257     Element* getElementByAccessKey(const String& key);
258     void invalidateAccessKeyMap();
259
260     SelectorQueryCache* selectorQueryCache();
261
262     // DOM methods & attributes for Document
263
264     DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
265     DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
266     DEFINE_ATTRIBUTE_EVENT_LISTENER(click);
267     DEFINE_ATTRIBUTE_EVENT_LISTENER(contextmenu);
268     DEFINE_ATTRIBUTE_EVENT_LISTENER(dblclick);
269     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragenter);
270     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragover);
271     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragleave);
272     DEFINE_ATTRIBUTE_EVENT_LISTENER(drop);
273     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragstart);
274     DEFINE_ATTRIBUTE_EVENT_LISTENER(drag);
275     DEFINE_ATTRIBUTE_EVENT_LISTENER(dragend);
276     DEFINE_ATTRIBUTE_EVENT_LISTENER(input);
277     DEFINE_ATTRIBUTE_EVENT_LISTENER(invalid);
278     DEFINE_ATTRIBUTE_EVENT_LISTENER(keydown);
279     DEFINE_ATTRIBUTE_EVENT_LISTENER(keypress);
280     DEFINE_ATTRIBUTE_EVENT_LISTENER(keyup);
281     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousedown);
282     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousemove);
283     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseout);
284     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseover);
285     DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseup);
286     DEFINE_ATTRIBUTE_EVENT_LISTENER(mousewheel);
287     DEFINE_ATTRIBUTE_EVENT_LISTENER(scroll);
288     DEFINE_ATTRIBUTE_EVENT_LISTENER(select);
289     DEFINE_ATTRIBUTE_EVENT_LISTENER(submit);
290
291     DEFINE_ATTRIBUTE_EVENT_LISTENER(blur);
292     DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
293     DEFINE_ATTRIBUTE_EVENT_LISTENER(focus);
294     DEFINE_ATTRIBUTE_EVENT_LISTENER(load);
295     DEFINE_ATTRIBUTE_EVENT_LISTENER(readystatechange);
296
297     // WebKit extensions
298     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecut);
299     DEFINE_ATTRIBUTE_EVENT_LISTENER(cut);
300     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforecopy);
301     DEFINE_ATTRIBUTE_EVENT_LISTENER(copy);
302     DEFINE_ATTRIBUTE_EVENT_LISTENER(beforepaste);
303     DEFINE_ATTRIBUTE_EVENT_LISTENER(paste);
304     DEFINE_ATTRIBUTE_EVENT_LISTENER(reset);
305     DEFINE_ATTRIBUTE_EVENT_LISTENER(search);
306     DEFINE_ATTRIBUTE_EVENT_LISTENER(selectstart);
307     DEFINE_ATTRIBUTE_EVENT_LISTENER(selectionchange);
308 #if ENABLE(TOUCH_EVENTS)
309     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchstart);
310     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchmove);
311     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
312     DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
313 #endif
314 #if ENABLE(FULLSCREEN_API)
315     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenchange);
316     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitfullscreenerror);
317 #endif
318 #if ENABLE(POINTER_LOCK)
319     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitpointerlockchange);
320     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitpointerlockerror);
321 #endif
322 #if ENABLE(PAGE_VISIBILITY_API)
323     DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitvisibilitychange);
324 #endif
325
326     void setViewportArguments(const ViewportArguments& viewportArguments) { m_viewportArguments = viewportArguments; }
327     ViewportArguments viewportArguments() const { return m_viewportArguments; }
328 #ifndef NDEBUG
329     bool didDispatchViewportPropertiesChanged() const { return m_didDispatchViewportPropertiesChanged; }
330 #endif
331
332     void setReferrerPolicy(ReferrerPolicy referrerPolicy) { m_referrerPolicy = referrerPolicy; }
333     ReferrerPolicy referrerPolicy() const { return m_referrerPolicy; }
334
335     DocumentType* doctype() const { return m_docType.get(); }
336
337     DOMImplementation* implementation();
338     
339     Element* documentElement() const
340     {
341         return m_documentElement.get();
342     }
343     
344     virtual PassRefPtr<Element> createElement(const AtomicString& tagName, ExceptionCode&);
345     PassRefPtr<DocumentFragment> createDocumentFragment();
346     PassRefPtr<Text> createTextNode(const String& data);
347     PassRefPtr<Comment> createComment(const String& data);
348     PassRefPtr<CDATASection> createCDATASection(const String& data, ExceptionCode&);
349     PassRefPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionCode&);
350     PassRefPtr<Attr> createAttribute(const String& name, ExceptionCode&);
351     PassRefPtr<Attr> createAttributeNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&, bool shouldIgnoreNamespaceChecks = false);
352     PassRefPtr<EntityReference> createEntityReference(const String& name, ExceptionCode&);
353     PassRefPtr<Node> importNode(Node* importedNode, ExceptionCode& ec) { return importNode(importedNode, true, ec); }
354     PassRefPtr<Node> importNode(Node* importedNode, bool deep, ExceptionCode&);
355     virtual PassRefPtr<Element> createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode&);
356     PassRefPtr<Element> createElement(const QualifiedName&, bool createdByParser);
357
358     bool cssStickyPositionEnabled() const;
359     bool cssRegionsEnabled() const;
360 #if ENABLE(CSS_REGIONS)
361     PassRefPtr<DOMNamedFlowCollection> webkitGetNamedFlows();
362 #endif
363
364     NamedFlowCollection* namedFlows();
365
366     bool regionBasedColumnsEnabled() const;
367
368     bool cssGridLayoutEnabled() const;
369
370     /**
371      * Retrieve all nodes that intersect a rect in the window's document, until it is fully enclosed by
372      * the boundaries of a node.
373      *
374      * @param centerX x reference for the rectangle in CSS pixels
375      * @param centerY y reference for the rectangle in CSS pixels
376      * @param topPadding How much to expand the top of the rectangle
377      * @param rightPadding How much to expand the right of the rectangle
378      * @param bottomPadding How much to expand the bottom of the rectangle
379      * @param leftPadding How much to expand the left of the rectangle
380      * @param ignoreClipping whether or not to ignore the root scroll frame when retrieving the element.
381      *        If false, this method returns null for coordinates outside of the viewport.
382      */
383     PassRefPtr<NodeList> nodesFromRect(int centerX, int centerY, unsigned topPadding, unsigned rightPadding,
384                                        unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping, bool allowShadowContent) const;
385     Element* elementFromPoint(int x, int y) const;
386     PassRefPtr<Range> caretRangeFromPoint(int x, int y);
387
388     String readyState() const;
389
390     String defaultCharset() const;
391
392     String inputEncoding() const { return Document::encoding(); }
393     String charset() const { return Document::encoding(); }
394     String characterSet() const { return Document::encoding(); }
395
396     String encoding() const;
397
398     void setCharset(const String&);
399
400     void setContent(const String&);
401
402     String suggestedMIMEType() const;
403
404     String contentLanguage() const { return m_contentLanguage; }
405     void setContentLanguage(const String&);
406
407     String xmlEncoding() const { return m_xmlEncoding; }
408     String xmlVersion() const { return m_xmlVersion; }
409     enum StandaloneStatus { StandaloneUnspecified, Standalone, NotStandalone };
410     bool xmlStandalone() const { return m_xmlStandalone == Standalone; }
411     StandaloneStatus xmlStandaloneStatus() const { return static_cast<StandaloneStatus>(m_xmlStandalone); }
412     bool hasXMLDeclaration() const { return m_hasXMLDeclaration; }
413
414     void setXMLEncoding(const String& encoding) { m_xmlEncoding = encoding; } // read-only property, only to be set from XMLDocumentParser
415     void setXMLVersion(const String&, ExceptionCode&);
416     void setXMLStandalone(bool, ExceptionCode&);
417     void setHasXMLDeclaration(bool hasXMLDeclaration) { m_hasXMLDeclaration = hasXMLDeclaration ? 1 : 0; }
418
419     String documentURI() const { return m_documentURI; }
420     void setDocumentURI(const String&);
421
422     virtual KURL baseURI() const;
423
424 #if ENABLE(PAGE_VISIBILITY_API)
425     String webkitVisibilityState() const;
426     bool webkitHidden() const;
427     void dispatchVisibilityStateChangeEvent();
428 #endif
429
430 #if ENABLE(CSP_NEXT)
431     DOMSecurityPolicy* securityPolicy();
432 #endif
433
434     PassRefPtr<Node> adoptNode(PassRefPtr<Node> source, ExceptionCode&);
435
436     PassRefPtr<HTMLCollection> images();
437     PassRefPtr<HTMLCollection> embeds();
438     PassRefPtr<HTMLCollection> plugins(); // an alias for embeds() required for the JS DOM bindings.
439     PassRefPtr<HTMLCollection> applets();
440     PassRefPtr<HTMLCollection> links();
441     PassRefPtr<HTMLCollection> forms();
442     PassRefPtr<HTMLCollection> anchors();
443     PassRefPtr<HTMLCollection> scripts();
444     PassRefPtr<HTMLCollection> all();
445
446     PassRefPtr<HTMLCollection> windowNamedItems(const AtomicString& name);
447     PassRefPtr<HTMLCollection> documentNamedItems(const AtomicString& name);
448
449     // Other methods (not part of DOM)
450     bool isHTMLDocument() const { return m_isHTML; }
451     bool isXHTMLDocument() const { return m_isXHTML; }
452     virtual bool isImageDocument() const { return false; }
453 #if ENABLE(SVG)
454     virtual bool isSVGDocument() const { return false; }
455     bool hasSVGRootNode() const;
456 #else
457     static bool isSVGDocument() { return false; }
458     static bool hasSVGRootNode() { return false; }
459 #endif
460     virtual bool isPluginDocument() const { return false; }
461     virtual bool isMediaDocument() const { return false; }
462     virtual bool isFrameSet() const { return false; }
463
464     bool isSrcdocDocument() const { return m_isSrcdocDocument; }
465
466     StyleResolver* styleResolverIfExists() const { return m_styleResolver.get(); }
467
468     bool isViewSource() const { return m_isViewSource; }
469     void setIsViewSource(bool);
470
471     bool sawElementsInKnownNamespaces() const { return m_sawElementsInKnownNamespaces; }
472
473     StyleResolver* styleResolver()
474     { 
475         if (!m_styleResolver)
476             createStyleResolver();
477         return m_styleResolver.get();
478     }
479
480     void notifyRemovePendingSheetIfNeeded();
481
482     bool haveStylesheetsLoaded() const;
483
484     // This is a DOM function.
485     StyleSheetList* styleSheets();
486
487     DocumentStyleSheetCollection* styleSheetCollection() { return m_styleSheetCollection.get(); }
488
489     bool gotoAnchorNeededAfterStylesheetsLoad() { return m_gotoAnchorNeededAfterStylesheetsLoad; }
490     void setGotoAnchorNeededAfterStylesheetsLoad(bool b) { m_gotoAnchorNeededAfterStylesheetsLoad = b; }
491
492     /**
493      * Called when one or more stylesheets in the document may have been added, removed or changed.
494      *
495      * Creates a new style resolver and assign it to this document. This is done by iterating through all nodes in
496      * document (or those before <BODY> in a HTML document), searching for stylesheets. Stylesheets can be contained in
497      * <LINK>, <STYLE> or <BODY> elements, as well as processing instructions (XML documents only). A list is
498      * constructed from these which is used to create the a new style selector which collates all of the stylesheets
499      * found and is used to calculate the derived styles for all rendering objects.
500      */
501     void styleResolverChanged(StyleResolverUpdateFlag);
502
503     void didAccessStyleResolver();
504
505     void evaluateMediaQueryList();
506
507     // Never returns 0.
508     FormController* formController();
509     Vector<String> formElementsState() const;
510     void setStateForNewFormElements(const Vector<String>&);
511
512     FrameView* view() const; // can be NULL
513     Frame* frame() const { return m_frame; } // can be NULL
514     Page* page() const; // can be NULL
515     Settings* settings() const; // can be NULL
516
517     PassRefPtr<Range> createRange();
518
519     PassRefPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow,
520         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
521
522     PassRefPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow,
523         PassRefPtr<NodeFilter>, bool expandEntityReferences, ExceptionCode&);
524
525     // Special support for editing
526     PassRefPtr<CSSStyleDeclaration> createCSSStyleDeclaration();
527     PassRefPtr<Text> createEditingTextNode(const String&);
528
529     void recalcStyle(StyleChange = NoChange);
530     bool childNeedsAndNotInStyleRecalc();
531     void updateStyleIfNeeded();
532     void updateLayout();
533     void updateLayoutIgnorePendingStylesheets();
534     PassRefPtr<RenderStyle> styleForElementIgnoringPendingStylesheets(Element*);
535     PassRefPtr<RenderStyle> styleForPage(int pageIndex);
536
537     // Returns true if page box (margin boxes and page borders) is visible.
538     bool isPageBoxVisible(int pageIndex);
539
540     // Returns the preferred page size and margins in pixels, assuming 96
541     // pixels per inch. pageSize, marginTop, marginRight, marginBottom,
542     // marginLeft must be initialized to the default values that are used if
543     // auto is specified.
544     void pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft);
545
546     static void updateStyleForAllDocuments(); // FIXME: Try to reduce the # of calls to this function.
547     CachedResourceLoader* cachedResourceLoader() { return m_cachedResourceLoader.get(); }
548
549     virtual void attach();
550     virtual void detach();
551     void prepareForDestruction();
552
553     // Override ScriptExecutionContext methods to do additional work
554     virtual void suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension) OVERRIDE;
555     virtual void resumeActiveDOMObjects() OVERRIDE;
556
557     RenderArena* renderArena() { return m_renderArena.get(); }
558
559     // Implemented in RenderView.h to avoid a cyclic header dependency this just
560     // returns renderer so callers can avoid verbose casts.
561     RenderView* renderView() const;
562
563     // Shadow the implementations on Node to provide faster access for documents.
564     RenderObject* renderer() const { return m_renderer; }
565     void setRenderer(RenderObject* renderer)
566     {
567         m_renderer = renderer;
568         Node::setRenderer(renderer);
569     }
570
571     void clearAXObjectCache();
572     AXObjectCache* axObjectCache() const;
573     bool axObjectCacheExists() const;
574     
575     // to get visually ordered hebrew and arabic pages right
576     void setVisuallyOrdered();
577     bool visuallyOrdered() const { return m_visuallyOrdered; }
578     
579     DocumentLoader* loader() const;
580
581     void open(Document* ownerDocument = 0);
582     void implicitOpen();
583
584     // close() is the DOM API document.close()
585     void close();
586     // In some situations (see the code), we ignore document.close().
587     // explicitClose() bypass these checks and actually tries to close the
588     // input stream.
589     void explicitClose();
590     // implicitClose() actually does the work of closing the input stream.
591     void implicitClose();
592
593     void cancelParsing();
594
595     void write(const SegmentedString& text, Document* ownerDocument = 0);
596     void write(const String& text, Document* ownerDocument = 0);
597     void writeln(const String& text, Document* ownerDocument = 0);
598
599     bool wellFormed() const { return m_wellFormed; }
600
601     const KURL& url() const { return m_url; }
602     void setURL(const KURL&);
603
604     // To understand how these concepts relate to one another, please see the
605     // comments surrounding their declaration.
606     const KURL& baseURL() const { return m_baseURL; }
607     void setBaseURLOverride(const KURL&);
608     const KURL& baseURLOverride() const { return m_baseURLOverride; }
609     const KURL& baseElementURL() const { return m_baseElementURL; }
610     const String& baseTarget() const { return m_baseTarget; }
611     void processBaseElement();
612
613     KURL completeURL(const String&) const;
614     KURL completeURL(const String&, const KURL& baseURLOverride) const;
615
616     virtual String userAgent(const KURL&) const;
617
618     virtual void disableEval(const String& errorMessage);
619
620     bool canNavigate(Frame* targetFrame);
621     Frame* findUnsafeParentScrollPropagationBoundary();
622
623     CSSStyleSheet* elementSheet();
624     
625     virtual PassRefPtr<DocumentParser> createParser();
626     DocumentParser* parser() const { return m_parser.get(); }
627     ScriptableDocumentParser* scriptableDocumentParser() const;
628     
629     bool printing() const { return m_printing; }
630     void setPrinting(bool p) { m_printing = p; }
631
632     bool paginatedForScreen() const { return m_paginatedForScreen; }
633     void setPaginatedForScreen(bool p) { m_paginatedForScreen = p; }
634     
635     bool paginated() const { return printing() || paginatedForScreen(); }
636
637     enum CompatibilityMode { QuirksMode, LimitedQuirksMode, NoQuirksMode };
638
639     void setCompatibilityMode(CompatibilityMode m);
640     void lockCompatibilityMode() { m_compatibilityModeLocked = true; }
641     CompatibilityMode compatibilityMode() const { return m_compatibilityMode; }
642
643     String compatMode() const;
644
645     bool inQuirksMode() const { return m_compatibilityMode == QuirksMode; }
646     bool inLimitedQuirksMode() const { return m_compatibilityMode == LimitedQuirksMode; }
647     bool inNoQuirksMode() const { return m_compatibilityMode == NoQuirksMode; }
648
649     enum ReadyState {
650         Loading,
651         Interactive,
652         Complete
653     };
654     void setReadyState(ReadyState);
655     void setParsing(bool);
656     bool parsing() const { return m_bParsing; }
657     int minimumLayoutDelay();
658
659     bool shouldScheduleLayout();
660     bool isLayoutTimerActive();
661     int elapsedTime() const;
662     
663     void setTextColor(const Color& color) { m_textColor = color; }
664     Color textColor() const { return m_textColor; }
665
666     const Color& linkColor() const { return m_linkColor; }
667     const Color& visitedLinkColor() const { return m_visitedLinkColor; }
668     const Color& activeLinkColor() const { return m_activeLinkColor; }
669     void setLinkColor(const Color& c) { m_linkColor = c; }
670     void setVisitedLinkColor(const Color& c) { m_visitedLinkColor = c; }
671     void setActiveLinkColor(const Color& c) { m_activeLinkColor = c; }
672     void resetLinkColor();
673     void resetVisitedLinkColor();
674     void resetActiveLinkColor();
675     VisitedLinkState* visitedLinkState() const { return m_visitedLinkState.get(); }
676
677     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const LayoutPoint&, const PlatformMouseEvent&);
678
679     /* Newly proposed CSS3 mechanism for selecting alternate
680        stylesheets using the DOM. May be subject to change as
681        spec matures. - dwh
682     */
683     String preferredStylesheetSet() const;
684     String selectedStylesheetSet() const;
685     void setSelectedStylesheetSet(const String&);
686
687     bool setFocusedNode(PassRefPtr<Node>);
688     Node* focusedNode() const { return m_focusedNode.get(); }
689     UserActionElementSet& userActionElements()  { return m_userActionElements; }
690     const UserActionElementSet& userActionElements() const { return m_userActionElements; }
691
692     void getFocusableNodes(Vector<RefPtr<Node> >&);
693     
694     // The m_ignoreAutofocus flag specifies whether or not the document has been changed by the user enough 
695     // for WebCore to ignore the autofocus attribute on any form controls
696     bool ignoreAutofocus() const { return m_ignoreAutofocus; };
697     void setIgnoreAutofocus(bool shouldIgnore = true) { m_ignoreAutofocus = shouldIgnore; };
698
699     void setHoverNode(PassRefPtr<Node>);
700     Node* hoverNode() const { return m_hoverNode.get(); }
701
702     void setActiveElement(PassRefPtr<Element>);
703     Element* activeElement() const { return m_activeElement.get(); }
704
705     void focusedNodeRemoved();
706     void removeFocusedNodeOfSubtree(Node*, bool amongChildrenOnly = false);
707     void hoveredNodeDetached(Node*);
708     void activeChainNodeDetached(Node*);
709
710     void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
711
712     // Updates for :target (CSS3 selector).
713     void setCSSTarget(Element*);
714     Element* cssTarget() const { return m_cssTarget; }
715     
716     void scheduleForcedStyleRecalc();
717     void scheduleStyleRecalc();
718     void unscheduleStyleRecalc();
719     bool hasPendingStyleRecalc() const;
720     bool hasPendingForcedStyleRecalc() const;
721     void styleRecalcTimerFired(Timer<Document>*);
722
723     void registerNodeList(LiveNodeListBase*);
724     void unregisterNodeList(LiveNodeListBase*);
725     bool shouldInvalidateNodeListCaches(const QualifiedName* attrName = 0) const;
726     void invalidateNodeListCaches(const QualifiedName* attrName);
727
728     void attachNodeIterator(NodeIterator*);
729     void detachNodeIterator(NodeIterator*);
730     void moveNodeIteratorsToNewDocument(Node*, Document*);
731
732     void attachRange(Range*);
733     void detachRange(Range*);
734
735     void updateRangesAfterChildrenChanged(ContainerNode*);
736     // nodeChildrenWillBeRemoved is used when removing all node children at once.
737     void nodeChildrenWillBeRemoved(ContainerNode*);
738     // nodeWillBeRemoved is only safe when removing one node at a time.
739     void nodeWillBeRemoved(Node*);
740     bool canReplaceChild(Node* newChild, Node* oldChild);
741
742     void textInserted(Node*, unsigned offset, unsigned length);
743     void textRemoved(Node*, unsigned offset, unsigned length);
744     void textNodesMerged(Text* oldNode, unsigned offset);
745     void textNodeSplit(Text* oldNode);
746
747     void createDOMWindow();
748     void takeDOMWindowFrom(Document*);
749
750     DOMWindow* domWindow() const { return m_domWindow.get(); }
751     // In DOM Level 2, the Document's DOMWindow is called the defaultView.
752     DOMWindow* defaultView() const { return domWindow(); } 
753
754     // Helper functions for forwarding DOMWindow event related tasks to the DOMWindow if it exists.
755     void setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
756     EventListener* getWindowAttributeEventListener(const AtomicString& eventType);
757     void dispatchWindowEvent(PassRefPtr<Event>, PassRefPtr<EventTarget> = 0);
758     void dispatchWindowLoadEvent();
759
760     PassRefPtr<Event> createEvent(const String& eventType, ExceptionCode&);
761
762     // keep track of what types of event listeners are registered, so we don't
763     // dispatch events unnecessarily
764     enum ListenerType {
765         DOMSUBTREEMODIFIED_LISTENER          = 1,
766         DOMNODEINSERTED_LISTENER             = 1 << 1,
767         DOMNODEREMOVED_LISTENER              = 1 << 2,
768         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 1 << 3,
769         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 1 << 4,
770         DOMCHARACTERDATAMODIFIED_LISTENER    = 1 << 5,
771         OVERFLOWCHANGED_LISTENER             = 1 << 6,
772         ANIMATIONEND_LISTENER                = 1 << 7,
773         ANIMATIONSTART_LISTENER              = 1 << 8,
774         ANIMATIONITERATION_LISTENER          = 1 << 9,
775         TRANSITIONEND_LISTENER               = 1 << 10,
776         BEFORELOAD_LISTENER                  = 1 << 11,
777         SCROLL_LISTENER                      = 1 << 12
778         // 3 bits remaining
779     };
780
781     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
782     void addListenerTypeIfNeeded(const AtomicString& eventType);
783
784     bool hasMutationObserversOfType(MutationObserver::MutationType type) const
785     {
786         return m_mutationObserverTypes & type;
787     }
788     bool hasMutationObservers() const { return m_mutationObserverTypes; }
789     void addMutationObserverTypes(MutationObserverOptions types) { m_mutationObserverTypes |= types; }
790
791     CSSStyleDeclaration* getOverrideStyle(Element*, const String& pseudoElt);
792
793     int nodeAbsIndex(Node*);
794     Node* nodeWithAbsIndex(int absIndex);
795
796     /**
797      * Handles a HTTP header equivalent set by a meta tag using <meta http-equiv="..." content="...">. This is called
798      * when a meta tag is encountered during document parsing, and also when a script dynamically changes or adds a meta
799      * tag. This enables scripts to use meta tags to perform refreshes and set expiry dates in addition to them being
800      * specified in a HTML file.
801      *
802      * @param equiv The http header name (value of the meta tag's "equiv" attribute)
803      * @param content The header value (value of the meta tag's "content" attribute)
804      */
805     void processHttpEquiv(const String& equiv, const String& content);
806     void processViewport(const String& features, ViewportArguments::Type origin);
807     void updateViewportArguments();
808     void processReferrerPolicy(const String& policy);
809
810     // Returns the owning element in the parent document.
811     // Returns 0 if this is the top level document.
812     HTMLFrameOwnerElement* ownerElement() const;
813
814     HTMLIFrameElement* seamlessParentIFrame() const;
815     bool shouldDisplaySeamlesslyWithParent() const;
816
817     // Used by DOM bindings; no direction known.
818     String title() const { return m_title.string(); }
819     void setTitle(const String&);
820
821     void setTitleElement(const StringWithDirection&, Element* titleElement);
822     void removeTitle(Element* titleElement);
823
824     String cookie(ExceptionCode&) const;
825     void setCookie(const String&, ExceptionCode&);
826
827     String referrer() const;
828
829     String domain() const;
830     void setDomain(const String& newDomain, ExceptionCode&);
831
832     String lastModified() const;
833
834     // The cookieURL is used to query the cookie database for this document's
835     // cookies. For example, if the cookie URL is http://example.com, we'll
836     // use the non-Secure cookies for example.com when computing
837     // document.cookie.
838     //
839     // Q: How is the cookieURL different from the document's URL?
840     // A: The two URLs are the same almost all the time.  However, if one
841     //    document inherits the security context of another document, it
842     //    inherits its cookieURL but not its URL.
843     //
844     const KURL& cookieURL() const { return m_cookieURL; }
845     void setCookieURL(const KURL& url) { m_cookieURL = url; }
846
847     // The firstPartyForCookies is used to compute whether this document
848     // appears in a "third-party" context for the purpose of third-party
849     // cookie blocking.  The document is in a third-party context if the
850     // cookieURL and the firstPartyForCookies are from different hosts.
851     //
852     // Note: Some ports (including possibly Apple's) only consider the
853     //       document in a third-party context if the cookieURL and the
854     //       firstPartyForCookies have a different registry-controlled
855     //       domain.
856     //
857     const KURL& firstPartyForCookies() const { return m_firstPartyForCookies; }
858     void setFirstPartyForCookies(const KURL& url) { m_firstPartyForCookies = url; }
859     
860     // The following implements the rule from HTML 4 for what valid names are.
861     // To get this right for all the XML cases, we probably have to improve this or move it
862     // and make it sensitive to the type of document.
863     static bool isValidName(const String&);
864
865     // The following breaks a qualified name into a prefix and a local name.
866     // It also does a validity check, and returns false if the qualified name
867     // is invalid.  It also sets ExceptionCode when name is invalid.
868     static bool parseQualifiedName(const String& qualifiedName, String& prefix, String& localName, ExceptionCode&);
869
870     // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
871     static bool hasValidNamespaceForElements(const QualifiedName&);
872     static bool hasValidNamespaceForAttributes(const QualifiedName&);
873
874     HTMLElement* body() const;
875     void setBody(PassRefPtr<HTMLElement>, ExceptionCode&);
876
877     HTMLHeadElement* head();
878
879     DocumentMarkerController* markers() const { return m_markers.get(); }
880
881     bool directionSetOnDocumentElement() const { return m_directionSetOnDocumentElement; }
882     bool writingModeSetOnDocumentElement() const { return m_writingModeSetOnDocumentElement; }
883     void setDirectionSetOnDocumentElement(bool b) { m_directionSetOnDocumentElement = b; }
884     void setWritingModeSetOnDocumentElement(bool b) { m_writingModeSetOnDocumentElement = b; }
885
886     bool execCommand(const String& command, bool userInterface = false, const String& value = String());
887     bool queryCommandEnabled(const String& command);
888     bool queryCommandIndeterm(const String& command);
889     bool queryCommandState(const String& command);
890     bool queryCommandSupported(const String& command);
891     String queryCommandValue(const String& command);
892
893     KURL openSearchDescriptionURL();
894
895     // designMode support
896     enum InheritedBool { off = false, on = true, inherit };    
897     void setDesignMode(InheritedBool value);
898     InheritedBool getDesignMode() const;
899     bool inDesignMode() const;
900
901     Document* parentDocument() const;
902     Document* topDocument() const;
903
904     int docID() const { return m_docID; }
905     
906     ScriptRunner* scriptRunner() { return m_scriptRunner.get(); }
907
908 #if ENABLE(XSLT)
909     void applyXSLTransform(ProcessingInstruction* pi);
910     PassRefPtr<Document> transformSourceDocument() { return m_transformSourceDocument; }
911     void setTransformSourceDocument(Document* doc) { m_transformSourceDocument = doc; }
912
913     void setTransformSource(PassOwnPtr<TransformSource>);
914     TransformSource* transformSource() const { return m_transformSource.get(); }
915 #endif
916
917     void incDOMTreeVersion() { m_domTreeVersion = ++s_globalTreeVersion; }
918     uint64_t domTreeVersion() const { return m_domTreeVersion; }
919
920     void setDocType(PassRefPtr<DocumentType>);
921
922     // XPathEvaluator methods
923     PassRefPtr<XPathExpression> createExpression(const String& expression,
924                                                  XPathNSResolver* resolver,
925                                                  ExceptionCode& ec);
926     PassRefPtr<XPathNSResolver> createNSResolver(Node *nodeResolver);
927     PassRefPtr<XPathResult> evaluate(const String& expression,
928                                      Node* contextNode,
929                                      XPathNSResolver* resolver,
930                                      unsigned short type,
931                                      XPathResult* result,
932                                      ExceptionCode& ec);
933
934     enum PendingSheetLayout { NoLayoutWithPendingSheets, DidLayoutWithPendingSheets, IgnoreLayoutWithPendingSheets };
935
936     bool didLayoutWithPendingStylesheets() const { return m_pendingSheetLayout == DidLayoutWithPendingSheets; }
937
938     bool hasNodesWithPlaceholderStyle() const { return m_hasNodesWithPlaceholderStyle; }
939     void setHasNodesWithPlaceholderStyle() { m_hasNodesWithPlaceholderStyle = true; }
940
941     const Vector<IconURL>& iconURLs();
942     void addIconURL(const String& url, const String& mimeType, const String& size, IconType);
943
944     void setUseSecureKeyboardEntryWhenActive(bool);
945     bool useSecureKeyboardEntryWhenActive() const;
946
947     void updateFocusAppearanceSoon(bool restorePreviousSelection);
948     void cancelFocusAppearanceUpdate();
949         
950     // Extension for manipulating canvas drawing contexts for use in CSS
951     CanvasRenderingContext* getCSSCanvasContext(const String& type, const String& name, int width, int height);
952     HTMLCanvasElement* getCSSCanvasElement(const String& name);
953
954     bool isDNSPrefetchEnabled() const { return m_isDNSPrefetchEnabled; }
955     void parseDNSPrefetchControlHeader(const String&);
956
957     virtual void postTask(PassOwnPtr<Task>); // Executes the task on context's thread asynchronously.
958
959     virtual void suspendScriptedAnimationControllerCallbacks();
960     virtual void resumeScriptedAnimationControllerCallbacks();
961     
962     void windowScreenDidChange(PlatformDisplayID);
963
964     virtual void finishedParsing();
965
966     bool inPageCache() const { return m_inPageCache; }
967     void setInPageCache(bool flag);
968
969     // Elements can register themselves for the "documentWillSuspendForPageCache()" and  
970     // "documentDidResumeFromPageCache()" callbacks
971     void registerForPageCacheSuspensionCallbacks(Element*);
972     void unregisterForPageCacheSuspensionCallbacks(Element*);
973
974     void documentWillBecomeInactive();
975     void documentWillSuspendForPageCache();
976     void documentDidResumeFromPageCache();
977
978     void registerForMediaVolumeCallbacks(Element*);
979     void unregisterForMediaVolumeCallbacks(Element*);
980     void mediaVolumeDidChange();
981
982     void registerForPrivateBrowsingStateChangedCallbacks(Element*);
983     void unregisterForPrivateBrowsingStateChangedCallbacks(Element*);
984     void storageBlockingStateDidChange();
985     void privateBrowsingStateDidChange();
986
987     void setShouldCreateRenderers(bool);
988     bool shouldCreateRenderers();
989
990     void setDecoder(PassRefPtr<TextResourceDecoder>);
991     TextResourceDecoder* decoder() const { return m_decoder.get(); }
992
993     String displayStringModifiedByEncoding(const String&) const;
994     PassRefPtr<StringImpl> displayStringModifiedByEncoding(PassRefPtr<StringImpl>) const;
995     void displayBufferModifiedByEncoding(LChar* buffer, unsigned len) const
996     {
997         displayBufferModifiedByEncodingInternal(buffer, len);
998     }
999     void displayBufferModifiedByEncoding(UChar* buffer, unsigned len) const
1000     {
1001         displayBufferModifiedByEncodingInternal(buffer, len);
1002     }
1003
1004     // Quirk for the benefit of Apple's Dictionary application.
1005     void setFrameElementsShouldIgnoreScrolling(bool ignore) { m_frameElementsShouldIgnoreScrolling = ignore; }
1006     bool frameElementsShouldIgnoreScrolling() const { return m_frameElementsShouldIgnoreScrolling; }
1007
1008 #if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
1009     void setAnnotatedRegionsDirty(bool f) { m_annotatedRegionsDirty = f; }
1010     bool annotatedRegionsDirty() const { return m_annotatedRegionsDirty; }
1011     bool hasAnnotatedRegions () const { return m_hasAnnotatedRegions; }
1012     void setHasAnnotatedRegions(bool f) { m_hasAnnotatedRegions = f; }
1013     const Vector<AnnotatedRegionValue>& annotatedRegions() const;
1014     void setAnnotatedRegions(const Vector<AnnotatedRegionValue>&);
1015 #endif
1016
1017     virtual void removeAllEventListeners();
1018
1019 #if ENABLE(SVG)
1020     const SVGDocumentExtensions* svgExtensions();
1021     SVGDocumentExtensions* accessSVGExtensions();
1022 #endif
1023
1024     void initSecurityContext();
1025     void initContentSecurityPolicy();
1026
1027     void updateURLForPushOrReplaceState(const KURL&);
1028     void statePopped(PassRefPtr<SerializedScriptValue>);
1029
1030     bool processingLoadEvent() const { return m_processingLoadEvent; }
1031     bool loadEventFinished() const { return m_loadEventFinished; }
1032
1033     virtual bool isContextThread() const;
1034     virtual bool isJSExecutionForbidden() const { return false; }
1035
1036     bool containsValidityStyleRules() const { return m_containsValidityStyleRules; }
1037     void setContainsValidityStyleRules() { m_containsValidityStyleRules = true; }
1038
1039     void enqueueWindowEvent(PassRefPtr<Event>);
1040     void enqueueDocumentEvent(PassRefPtr<Event>);
1041     void enqueuePageshowEvent(PageshowEventPersistence);
1042     void enqueueHashchangeEvent(const String& oldURL, const String& newURL);
1043     void enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject);
1044     virtual DocumentEventQueue* eventQueue() const { return m_eventQueue.get(); }
1045
1046     void addMediaCanStartListener(MediaCanStartListener*);
1047     void removeMediaCanStartListener(MediaCanStartListener*);
1048     MediaCanStartListener* takeAnyMediaCanStartListener();
1049
1050     const QualifiedName& idAttributeName() const { return m_idAttributeName; }
1051     
1052 #if ENABLE(FULLSCREEN_API)
1053     bool webkitIsFullScreen() const { return m_fullScreenElement.get(); }
1054     bool webkitFullScreenKeyboardInputAllowed() const { return m_fullScreenElement.get() && m_areKeysEnabledInFullScreen; }
1055     Element* webkitCurrentFullScreenElement() const { return m_fullScreenElement.get(); }
1056     
1057     enum FullScreenCheckType {
1058         EnforceIFrameAllowFullScreenRequirement,
1059         ExemptIFrameAllowFullScreenRequirement,
1060     };
1061
1062     void requestFullScreenForElement(Element*, unsigned short flags, FullScreenCheckType);
1063     void webkitCancelFullScreen();
1064     
1065     void webkitWillEnterFullScreenForElement(Element*);
1066     void webkitDidEnterFullScreenForElement(Element*);
1067     void webkitWillExitFullScreenForElement(Element*);
1068     void webkitDidExitFullScreenForElement(Element*);
1069     
1070     void setFullScreenRenderer(RenderFullScreen*);
1071     RenderFullScreen* fullScreenRenderer() const { return m_fullScreenRenderer; }
1072     void fullScreenRendererDestroyed();
1073     
1074     void setFullScreenRendererSize(const IntSize&);
1075     void setFullScreenRendererBackgroundColor(Color);
1076     
1077     void fullScreenChangeDelayTimerFired(Timer<Document>*);
1078     bool fullScreenIsAllowedForElement(Element*) const;
1079     void fullScreenElementRemoved();
1080     void removeFullScreenElementOfSubtree(Node*, bool amongChildrenOnly = false);
1081     bool isAnimatingFullScreen() const;
1082     void setAnimatingFullScreen(bool);
1083
1084     // W3C API
1085     bool webkitFullscreenEnabled() const;
1086     Element* webkitFullscreenElement() const { return !m_fullScreenElementStack.isEmpty() ? m_fullScreenElementStack.last().get() : 0; }
1087     void webkitExitFullscreen();
1088 #endif
1089
1090 #if ENABLE(POINTER_LOCK)
1091     void webkitExitPointerLock();
1092     Element* webkitPointerLockElement() const;
1093 #endif
1094
1095     // Used to allow element that loads data without going through a FrameLoader to delay the 'load' event.
1096     void incrementLoadEventDelayCount() { ++m_loadEventDelayCount; }
1097     void decrementLoadEventDelayCount();
1098     bool isDelayingLoadEvent() const { return m_loadEventDelayCount; }
1099
1100 #if ENABLE(TOUCH_EVENTS)
1101     PassRefPtr<Touch> createTouch(DOMWindow*, EventTarget*, int identifier, int pageX, int pageY, int screenX, int screenY, int radiusX, int radiusY, float rotationAngle, float force, ExceptionCode&) const;
1102 #endif
1103
1104     const DocumentTiming* timing() const { return &m_documentTiming; }
1105
1106 #if ENABLE(REQUEST_ANIMATION_FRAME)
1107     int requestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback>);
1108     void cancelAnimationFrame(int id);
1109     void serviceScriptedAnimations(double monotonicAnimationStartTime);
1110 #endif
1111
1112     virtual EventTarget* errorEventTarget();
1113     virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, PassRefPtr<ScriptCallStack>);
1114
1115     void initDNSPrefetch();
1116
1117     unsigned wheelEventHandlerCount() const { return m_wheelEventHandlerCount; }
1118     void didAddWheelEventHandler();
1119     void didRemoveWheelEventHandler();
1120
1121 #if ENABLE(TOUCH_EVENTS)
1122     bool hasTouchEventHandlers() const { return (m_touchEventTargets.get()) ? m_touchEventTargets->size() : false; }
1123 #else
1124     bool hasTouchEventHandlers() const { return false; }
1125 #endif
1126
1127     void didAddTouchEventHandler(Node*);
1128     void didRemoveTouchEventHandler(Node*);
1129
1130 #if ENABLE(TOUCH_EVENTS)
1131     void didRemoveEventTargetNode(Node*);
1132 #endif
1133
1134 #if ENABLE(TOUCH_EVENTS)
1135     const TouchEventTargetSet* touchEventTargets() const { return m_touchEventTargets.get(); }
1136 #else
1137     const TouchEventTargetSet* touchEventTargets() const { return 0; }
1138 #endif
1139
1140     bool visualUpdatesAllowed() const { return m_visualUpdatesAllowed; }
1141
1142 #if ENABLE(MICRODATA)
1143     PassRefPtr<NodeList> getItems(const String& typeNames);
1144 #endif
1145
1146     bool isInDocumentWrite() { return m_writeRecursionDepth > 0; }
1147
1148     void suspendScheduledTasks(ActiveDOMObject::ReasonForSuspension);
1149     void resumeScheduledTasks();
1150
1151     IntSize viewportSize() const;
1152
1153 #if ENABLE(CSS_DEVICE_ADAPTATION)
1154     IntSize initialViewportSize() const;
1155 #endif
1156
1157 #if ENABLE(LINK_PRERENDER)
1158     Prerenderer* prerenderer() { return m_prerenderer.get(); }
1159 #endif
1160
1161 #if ENABLE(TEXT_AUTOSIZING)
1162     TextAutosizer* textAutosizer() { return m_textAutosizer.get(); }
1163 #endif
1164
1165     void adjustFloatQuadsForScrollAndAbsoluteZoomAndFrameScale(Vector<FloatQuad>&, RenderObject*);
1166     void adjustFloatRectForScrollAndAbsoluteZoomAndFrameScale(FloatRect&, RenderObject*);
1167
1168     void setContextFeatures(PassRefPtr<ContextFeatures>);
1169     ContextFeatures* contextFeatures() { return m_contextFeatures.get(); }
1170
1171     virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
1172
1173     DocumentSharedObjectPool* sharedObjectPool() { return m_sharedObjectPool.get(); }
1174
1175     void didRemoveAllPendingStylesheet();
1176     void setNeedsNotifyRemoveAllPendingStylesheet() { m_needsNotifyRemoveAllPendingStylesheet = true; }
1177     void clearStyleResolver();
1178     void notifySeamlessChildDocumentsOfStylesheetUpdate() const;
1179
1180     bool inStyleRecalc() { return m_inStyleRecalc; }
1181
1182     // Return a Locale for the default locale if the argument is null or empty.
1183     Locale& getCachedLocale(const AtomicString& locale = nullAtom);
1184
1185 #if ENABLE(DIALOG_ELEMENT)
1186     void addToTopLayer(Element*);
1187     void removeFromTopLayer(Element*);
1188     const Vector<RefPtr<Element> >& topLayerElements() const { return m_topLayerElements; }
1189 #endif
1190
1191 #if ENABLE(TEMPLATE_ELEMENT)
1192     const Document* templateDocument() const;
1193     Document* ensureTemplateDocument();
1194     void setTemplateDocumentHost(Document* templateDocumentHost) { m_templateDocumentHost = templateDocumentHost; }
1195     Document* templateDocumentHost() { return m_templateDocumentHost; }
1196 #endif
1197
1198     virtual void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0);
1199
1200 protected:
1201     Document(Frame*, const KURL&, bool isXHTML, bool isHTML);
1202
1203     virtual void didUpdateSecurityOrigin() OVERRIDE;
1204
1205     void clearXMLVersion() { m_xmlVersion = String(); }
1206
1207 private:
1208     friend class Node;
1209     friend class IgnoreDestructiveWriteCountIncrementer;
1210
1211     void removedLastRef();
1212     
1213     void detachParser();
1214
1215     typedef void (*ArgumentsCallback)(const String& keyString, const String& valueString, Document*, void* data);
1216     void processArguments(const String& features, void* data, ArgumentsCallback);
1217
1218     virtual bool isDocument() const { return true; }
1219
1220     virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
1221
1222     virtual String nodeName() const;
1223     virtual NodeType nodeType() const;
1224     virtual bool childTypeAllowed(NodeType) const;
1225     virtual PassRefPtr<Node> cloneNode(bool deep);
1226
1227     virtual void refScriptExecutionContext() { ref(); }
1228     virtual void derefScriptExecutionContext() { deref(); }
1229
1230     virtual const KURL& virtualURL() const; // Same as url(), but needed for ScriptExecutionContext to implement it without a performance loss for direct calls.
1231     virtual KURL virtualCompleteURL(const String&) const; // Same as completeURL() for the same reason as above.
1232
1233     virtual void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack>, ScriptState* = 0, unsigned long requestIdentifier = 0);
1234
1235     virtual double minimumTimerInterval() const;
1236
1237     virtual double timerAlignmentInterval() const;
1238
1239     void updateTitle(const StringWithDirection&);
1240     void updateFocusAppearanceTimerFired(Timer<Document>*);
1241     void updateBaseURL();
1242
1243     void buildAccessKeyMap(TreeScope* root);
1244
1245     void createStyleResolver();
1246
1247     void seamlessParentUpdatedStylesheets();
1248
1249     PassRefPtr<NodeList> handleZeroPadding(const HitTestRequest&, HitTestResult&) const;
1250
1251     void loadEventDelayTimerFired(Timer<Document>*);
1252
1253     void pendingTasksTimerFired(Timer<Document>*);
1254
1255     static void didReceiveTask(void*);
1256     
1257     template <typename CharacterType>
1258     void displayBufferModifiedByEncodingInternal(CharacterType*, unsigned) const;
1259
1260 #if ENABLE(PAGE_VISIBILITY_API)
1261     PageVisibilityState visibilityState() const;
1262 #endif
1263
1264     PassRefPtr<HTMLCollection> ensureCachedCollection(CollectionType);
1265
1266 #if ENABLE(FULLSCREEN_API)
1267     void clearFullscreenElementStack();
1268     void popFullscreenElementStack();
1269     void pushFullscreenElementStack(Element*);
1270     void addDocumentToFullScreenChangeEventQueue(Document*);
1271 #endif
1272
1273     void setVisualUpdatesAllowed(ReadyState);
1274     void setVisualUpdatesAllowed(bool);
1275     void visualUpdatesSuppressionTimerFired(Timer<Document>*);
1276
1277     void addListenerType(ListenerType listenerType) { m_listenerTypes |= listenerType; }
1278     void addMutationEventListenerTypeIfEnabled(ListenerType);
1279
1280     int m_guardRefCount;
1281
1282     void styleResolverThrowawayTimerFired(Timer<Document>*);
1283     Timer<Document> m_styleResolverThrowawayTimer;
1284     double m_lastStyleResolverAccessTime;
1285
1286     OwnPtr<StyleResolver> m_styleResolver;
1287     bool m_didCalculateStyleResolver;
1288     bool m_hasDirtyStyleResolver;
1289     bool m_hasNodesWithPlaceholderStyle;
1290     bool m_needsNotifyRemoveAllPendingStylesheet;
1291     // But sometimes you need to ignore pending stylesheet count to
1292     // force an immediate layout when requested by JS.
1293     bool m_ignorePendingStylesheets;
1294
1295     // If we do ignore the pending stylesheet count, then we need to add a boolean
1296     // to track that this happened so that we can do a full repaint when the stylesheets
1297     // do eventually load.
1298     PendingSheetLayout m_pendingSheetLayout;
1299
1300     Frame* m_frame;
1301     RefPtr<DOMWindow> m_domWindow;
1302
1303     RefPtr<CachedResourceLoader> m_cachedResourceLoader;
1304     RefPtr<DocumentParser> m_parser;
1305     RefPtr<ContextFeatures> m_contextFeatures;
1306
1307     bool m_wellFormed;
1308
1309     // Document URLs.
1310     KURL m_url; // Document.URL: The URL from which this document was retrieved.
1311     KURL m_baseURL; // Node.baseURI: The URL to use when resolving relative URLs.
1312     KURL m_baseURLOverride; // An alternative base URL that takes precedence over m_baseURL (but not m_baseElementURL).
1313     KURL m_baseElementURL; // The URL set by the <base> element.
1314     KURL m_cookieURL; // The URL to use for cookie access.
1315     KURL m_firstPartyForCookies; // The policy URL for third-party cookie blocking.
1316
1317     // Document.documentURI:
1318     // Although URL-like, Document.documentURI can actually be set to any
1319     // string by content.  Document.documentURI affects m_baseURL unless the
1320     // document contains a <base> element, in which case the <base> element
1321     // takes precedence.
1322     //
1323     // This property is read-only from JavaScript, but writable from Objective C.
1324     String m_documentURI;
1325
1326     String m_baseTarget;
1327
1328     RefPtr<DocumentType> m_docType;
1329     OwnPtr<DOMImplementation> m_implementation;
1330
1331     RefPtr<CSSStyleSheet> m_elemSheet;
1332
1333     bool m_printing;
1334     bool m_paginatedForScreen;
1335
1336     bool m_ignoreAutofocus;
1337
1338     CompatibilityMode m_compatibilityMode;
1339     bool m_compatibilityModeLocked; // This is cheaper than making setCompatibilityMode virtual.
1340
1341     Color m_textColor;
1342
1343     RefPtr<Node> m_focusedNode;
1344     RefPtr<Node> m_hoverNode;
1345     RefPtr<Element> m_activeElement;
1346     RefPtr<Element> m_documentElement;
1347     UserActionElementSet m_userActionElements;
1348
1349     uint64_t m_domTreeVersion;
1350     static uint64_t s_globalTreeVersion;
1351     
1352     HashSet<NodeIterator*> m_nodeIterators;
1353     HashSet<Range*> m_ranges;
1354
1355     unsigned short m_listenerTypes;
1356
1357     MutationObserverOptions m_mutationObserverTypes;
1358
1359     OwnPtr<DocumentStyleSheetCollection> m_styleSheetCollection;
1360     RefPtr<StyleSheetList> m_styleSheetList;
1361
1362     OwnPtr<FormController> m_formController;
1363
1364     Color m_linkColor;
1365     Color m_visitedLinkColor;
1366     Color m_activeLinkColor;
1367     OwnPtr<VisitedLinkState> m_visitedLinkState;
1368
1369     bool m_loadingSheet;
1370     bool m_visuallyOrdered;
1371     ReadyState m_readyState;
1372     bool m_bParsing;
1373     
1374     Timer<Document> m_styleRecalcTimer;
1375     bool m_pendingStyleRecalcShouldForce;
1376     bool m_inStyleRecalc;
1377     bool m_closeAfterStyleRecalc;
1378
1379     bool m_gotoAnchorNeededAfterStylesheetsLoad;
1380     bool m_isDNSPrefetchEnabled;
1381     bool m_haveExplicitlyDisabledDNSPrefetch;
1382     bool m_frameElementsShouldIgnoreScrolling;
1383     bool m_containsValidityStyleRules;
1384     bool m_updateFocusAppearanceRestoresSelection;
1385
1386     // http://www.whatwg.org/specs/web-apps/current-work/#ignore-destructive-writes-counter
1387     unsigned m_ignoreDestructiveWriteCount;
1388
1389     StringWithDirection m_title;
1390     StringWithDirection m_rawTitle;
1391     bool m_titleSetExplicitly;
1392     RefPtr<Element> m_titleElement;
1393
1394     OwnPtr<RenderArena> m_renderArena;
1395
1396     OwnPtr<AXObjectCache> m_axObjectCache;
1397     OwnPtr<DocumentMarkerController> m_markers;
1398     
1399     Timer<Document> m_updateFocusAppearanceTimer;
1400
1401     Element* m_cssTarget;
1402
1403     // FIXME: Merge these 2 variables into an enum. Also, FrameLoader::m_didCallImplicitClose
1404     // is almost a duplication of this data, so that should probably get merged in too.
1405     // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadHandled are roughly the same
1406     // and should be merged.
1407     bool m_processingLoadEvent;
1408     bool m_loadEventFinished;
1409
1410     RefPtr<SerializedScriptValue> m_pendingStateObject;
1411     double m_startTime;
1412     bool m_overMinimumLayoutThreshold;
1413     
1414     OwnPtr<ScriptRunner> m_scriptRunner;
1415
1416 #if ENABLE(XSLT)
1417     OwnPtr<TransformSource> m_transformSource;
1418     RefPtr<Document> m_transformSourceDocument;
1419 #endif
1420
1421     int m_docID; // A unique document identifier used for things like document-specific mapped attributes.
1422
1423     String m_xmlEncoding;
1424     String m_xmlVersion;
1425     unsigned m_xmlStandalone : 2;
1426     unsigned m_hasXMLDeclaration : 1;
1427
1428     String m_contentLanguage;
1429
1430     RenderObject* m_savedRenderer;
1431     
1432     RefPtr<TextResourceDecoder> m_decoder;
1433
1434     InheritedBool m_designMode;
1435
1436     HashSet<LiveNodeListBase*> m_listsInvalidatedAtDocument;
1437     unsigned m_nodeListCounts[numNodeListInvalidationTypes];
1438
1439     RefPtr<XPathEvaluator> m_xpathEvaluator;
1440
1441 #if ENABLE(SVG)
1442     OwnPtr<SVGDocumentExtensions> m_svgExtensions;
1443 #endif
1444
1445 #if ENABLE(DASHBOARD_SUPPORT) || ENABLE(DRAGGABLE_REGION)
1446     Vector<AnnotatedRegionValue> m_annotatedRegions;
1447     bool m_hasAnnotatedRegions;
1448     bool m_annotatedRegionsDirty;
1449 #endif
1450
1451     HashMap<String, RefPtr<HTMLCanvasElement> > m_cssCanvasElements;
1452
1453     bool m_createRenderers;
1454     bool m_inPageCache;
1455     Vector<IconURL> m_iconURLs;
1456
1457     HashSet<Element*> m_documentSuspensionCallbackElements;
1458     HashSet<Element*> m_mediaVolumeCallbackElements;
1459     HashSet<Element*> m_privateBrowsingStateChangedElements;
1460
1461     HashMap<StringImpl*, Element*, CaseFoldingHash> m_elementsByAccessKey;    
1462     bool m_accessKeyMapValid;
1463
1464     OwnPtr<SelectorQueryCache> m_selectorQueryCache;
1465
1466     bool m_useSecureKeyboardEntryWhenActive;
1467
1468     bool m_isXHTML;
1469     bool m_isHTML;
1470
1471     bool m_isViewSource;
1472     bool m_sawElementsInKnownNamespaces;
1473     bool m_isSrcdocDocument;
1474
1475     RenderObject* m_renderer;
1476     RefPtr<DocumentEventQueue> m_eventQueue;
1477
1478     RefPtr<DocumentWeakReference> m_weakReference;
1479
1480     HashSet<MediaCanStartListener*> m_mediaCanStartListeners;
1481
1482     QualifiedName m_idAttributeName;
1483
1484 #if ENABLE(FULLSCREEN_API)
1485     bool m_areKeysEnabledInFullScreen;
1486     RefPtr<Element> m_fullScreenElement;
1487     Vector<RefPtr<Element> > m_fullScreenElementStack;
1488     RenderFullScreen* m_fullScreenRenderer;
1489     Timer<Document> m_fullScreenChangeDelayTimer;
1490     Deque<RefPtr<Node> > m_fullScreenChangeEventTargetQueue;
1491     Deque<RefPtr<Node> > m_fullScreenErrorEventTargetQueue;
1492     bool m_isAnimatingFullScreen;
1493     LayoutRect m_savedPlaceholderFrameRect;
1494     RefPtr<RenderStyle> m_savedPlaceholderRenderStyle;
1495 #endif
1496
1497 #if ENABLE(DIALOG_ELEMENT)
1498     Vector<RefPtr<Element> > m_topLayerElements;
1499 #endif
1500
1501     int m_loadEventDelayCount;
1502     Timer<Document> m_loadEventDelayTimer;
1503
1504     ViewportArguments m_viewportArguments;
1505
1506     ReferrerPolicy m_referrerPolicy;
1507
1508     bool m_directionSetOnDocumentElement;
1509     bool m_writingModeSetOnDocumentElement;
1510
1511     DocumentTiming m_documentTiming;
1512     RefPtr<MediaQueryMatcher> m_mediaQueryMatcher;
1513     bool m_writeRecursionIsTooDeep;
1514     unsigned m_writeRecursionDepth;
1515     
1516     unsigned m_wheelEventHandlerCount;
1517 #if ENABLE(TOUCH_EVENTS)
1518     OwnPtr<TouchEventTargetSet> m_touchEventTargets;
1519 #endif
1520
1521 #if ENABLE(REQUEST_ANIMATION_FRAME)
1522     RefPtr<ScriptedAnimationController> m_scriptedAnimationController;
1523 #endif
1524
1525     Timer<Document> m_pendingTasksTimer;
1526     Vector<OwnPtr<Task> > m_pendingTasks;
1527
1528 #if ENABLE(LINK_PRERENDER)
1529     OwnPtr<Prerenderer> m_prerenderer;
1530 #endif
1531
1532 #if ENABLE(TEXT_AUTOSIZING)
1533     OwnPtr<TextAutosizer> m_textAutosizer;
1534 #endif
1535
1536     bool m_scheduledTasksAreSuspended;
1537     
1538     bool m_visualUpdatesAllowed;
1539     Timer<Document> m_visualUpdatesSuppressionTimer;
1540
1541     RefPtr<NamedFlowCollection> m_namedFlows;
1542
1543 #if ENABLE(CSP_NEXT)
1544     RefPtr<DOMSecurityPolicy> m_domSecurityPolicy;
1545 #endif
1546
1547     void sharedObjectPoolClearTimerFired(Timer<Document>*);
1548     Timer<Document> m_sharedObjectPoolClearTimer;
1549
1550     OwnPtr<DocumentSharedObjectPool> m_sharedObjectPool;
1551
1552 #ifndef NDEBUG
1553     bool m_didDispatchViewportPropertiesChanged;
1554 #endif
1555
1556     typedef HashMap<AtomicString, OwnPtr<Locale> > LocaleIdentifierToLocaleMap;
1557     LocaleIdentifierToLocaleMap m_localeCache;
1558
1559 #if ENABLE(TEMPLATE_ELEMENT)
1560     RefPtr<Document> m_templateDocument;
1561     Document* m_templateDocumentHost; // Manually managed weakref (backpointer from m_templateDocument).
1562 #endif
1563 };
1564
1565 inline void Document::notifyRemovePendingSheetIfNeeded()
1566 {
1567     if (m_needsNotifyRemoveAllPendingStylesheet)
1568         didRemoveAllPendingStylesheet();
1569 }
1570
1571 #if ENABLE(TEMPLATE_ELEMENT)
1572 inline const Document* Document::templateDocument() const
1573 {
1574     // If DOCUMENT does not have a browsing context, Let TEMPLATE CONTENTS OWNER be DOCUMENT and abort these steps.
1575     if (!m_frame)
1576         return this;
1577
1578     return m_templateDocument.get();
1579 }
1580 #endif
1581
1582 // Put these methods here, because they require the Document definition, but we really want to inline them.
1583
1584 inline bool Node::isDocumentNode() const
1585 {
1586     return this == documentInternal();
1587 }
1588
1589 inline Node::Node(Document* document, ConstructionType type)
1590     : m_nodeFlags(type)
1591     , m_parentOrHostNode(0)
1592     , m_treeScope(document)
1593     , m_previous(0)
1594     , m_next(0)
1595 {
1596     if (document)
1597         document->guardRef();
1598     else
1599         m_treeScope = TreeScope::noDocumentInstance();
1600
1601 #if !defined(NDEBUG) || (defined(DUMP_NODE_STATISTICS) && DUMP_NODE_STATISTICS)
1602     trackForDebugging();
1603 #endif
1604     InspectorCounters::incrementCounter(InspectorCounters::NodeCounter);
1605 }
1606
1607 Node* eventTargetNodeForDocument(Document*);
1608
1609 } // namespace WebCore
1610
1611 #endif // Document_h