f23c2e632b75ac1fce0d143a395de55a91549c12
[WebKit-https.git] / Source / WebCore / dom / Document.cpp
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, 2011 Apple Inc. All rights reserved.
7  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  * Copyright (C) 2008, 2009, 2011 Google Inc. All rights reserved.
9  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
10  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
11  *
12  * This library is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Library General Public
14  * License as published by the Free Software Foundation; either
15  * version 2 of the License, or (at your option) any later version.
16  *
17  * This library is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Library General Public License for more details.
21  *
22  * You should have received a copy of the GNU Library General Public License
23  * along with this library; see the file COPYING.LIB.  If not, write to
24  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25  * Boston, MA 02110-1301, USA.
26  */
27
28 #include "config.h"
29 #include "Document.h"
30
31 #include "AXObjectCache.h"
32 #include "AnimationController.h"
33 #include "Attr.h"
34 #include "Attribute.h"
35 #include "CDATASection.h"
36 #include "CSSStyleSelector.h"
37 #include "CSSStyleSheet.h"
38 #include "CSSValueKeywords.h"
39 #include "CSSValuePool.h"
40 #include "CachedCSSStyleSheet.h"
41 #include "CachedResourceLoader.h"
42 #include "Chrome.h"
43 #include "ChromeClient.h"
44 #include "Comment.h"
45 #include "Console.h"
46 #include "ContentSecurityPolicy.h"
47 #include "CookieJar.h"
48 #include "DOMImplementation.h"
49 #include "DOMWindow.h"
50 #include "DateComponents.h"
51 #include "DeviceMotionController.h"
52 #include "DeviceMotionEvent.h"
53 #include "DeviceOrientationController.h"
54 #include "DeviceOrientationEvent.h"
55 #include "DocumentEventQueue.h"
56 #include "DocumentFragment.h"
57 #include "DocumentLoader.h"
58 #include "DocumentMarkerController.h"
59 #include "DocumentType.h"
60 #include "EditingText.h"
61 #include "Editor.h"
62 #include "Element.h"
63 #include "EntityReference.h"
64 #include "Event.h"
65 #include "EventFactory.h"
66 #include "EventHandler.h"
67 #include "EventListener.h"
68 #include "EventNames.h"
69 #include "ExceptionCode.h"
70 #include "FocusController.h"
71 #include "FormAssociatedElement.h"
72 #include "Frame.h"
73 #include "FrameLoader.h"
74 #include "FrameLoaderClient.h"
75 #include "FrameSelection.h"
76 #include "FrameTree.h"
77 #include "FrameView.h"
78 #include "GeolocationController.h"
79 #include "HashChangeEvent.h"
80 #include "HTMLAllCollection.h"
81 #include "HTMLAnchorElement.h"
82 #include "HTMLBodyElement.h"
83 #include "HTMLCanvasElement.h"
84 #include "HTMLCollection.h"
85 #include "HTMLDocument.h"
86 #include "HTMLElementFactory.h"
87 #include "HTMLFrameOwnerElement.h"
88 #include "HTMLHeadElement.h"
89 #include "HTMLIFrameElement.h"
90 #include "HTMLInputElement.h"
91 #include "HTMLLinkElement.h"
92 #include "HTMLMapElement.h"
93 #include "HTMLNameCollection.h"
94 #include "HTMLNames.h"
95 #include "HTMLParserIdioms.h"
96 #include "HTMLStyleElement.h"
97 #include "HTMLTitleElement.h"
98 #include "HTTPParsers.h"
99 #include "HitTestRequest.h"
100 #include "HitTestResult.h"
101 #include "ImageLoader.h"
102 #include "InspectorInstrumentation.h"
103 #include "Logging.h"
104 #include "MediaQueryList.h"
105 #include "MediaQueryMatcher.h"
106 #include "MouseEventWithHitTestResults.h"
107 #include "NameNodeList.h"
108 #include "NestingLevelIncrementer.h"
109 #include "NewXMLDocumentParser.h"
110 #include "NodeFilter.h"
111 #include "NodeIterator.h"
112 #include "NodeWithIndex.h"
113 #include "Page.h"
114 #include "PageGroup.h"
115 #include "PageTransitionEvent.h"
116 #include "PlatformKeyboardEvent.h"
117 #include "PopStateEvent.h"
118 #include "ProcessingInstruction.h"
119 #include "RegisteredEventListener.h"
120 #include "RenderArena.h"
121 #include "RenderLayer.h"
122 #include "RenderLayerBacking.h"
123 #include "RenderTextControl.h"
124 #include "RenderView.h"
125 #include "RenderWidget.h"
126 #include "SchemeRegistry.h"
127 #include "ScopedEventQueue.h"
128 #include "ScriptCallStack.h"
129 #include "ScriptController.h"
130 #include "ScriptElement.h"
131 #include "ScriptEventListener.h"
132 #include "ScriptRunner.h"
133 #include "SecurityOrigin.h"
134 #include "SecurityPolicy.h"
135 #include "SegmentedString.h"
136 #include "Settings.h"
137 #include "ShadowRoot.h"
138 #include "StaticHashSetNodeList.h"
139 #include "StyleSheetList.h"
140 #include "TextResourceDecoder.h"
141 #include "Timer.h"
142 #include "TransformSource.h"
143 #include "TreeWalker.h"
144 #include "UserContentURLPattern.h"
145 #include "XMLDocumentParser.h"
146 #include "XMLHttpRequest.h"
147 #include "XMLNSNames.h"
148 #include "XMLNames.h"
149 #include "XPathEvaluator.h"
150 #include "XPathExpression.h"
151 #include "XPathNSResolver.h"
152 #include "XPathResult.h"
153 #include "htmlediting.h"
154 #include <wtf/CurrentTime.h>
155 #include <wtf/HashFunctions.h>
156 #include <wtf/MainThread.h>
157 #include <wtf/PassRefPtr.h>
158 #include <wtf/StdLibExtras.h>
159 #include <wtf/text/StringBuffer.h>
160
161 #if PLATFORM(CHROMIUM)
162 #include "PlatformSupport.h"
163 #endif
164
165 #if ENABLE(SHARED_WORKERS)
166 #include "SharedWorkerRepository.h"
167 #endif
168
169 #if ENABLE(XSLT)
170 #include "XSLTProcessor.h"
171 #endif
172
173 #if ENABLE(SVG)
174 #include "SVGDocumentExtensions.h"
175 #include "SVGElementFactory.h"
176 #include "SVGNames.h"
177 #include "SVGStyleElement.h"
178 #endif
179
180 #if ENABLE(TOUCH_EVENTS)
181 #include "TouchList.h"
182 #endif
183
184 #if ENABLE(MATHML)
185 #include "MathMLElement.h"
186 #include "MathMLElementFactory.h"
187 #include "MathMLNames.h"
188 #endif
189
190 #if ENABLE(FULLSCREEN_API)
191 #include "RenderFullScreen.h"
192 #endif
193
194 #if ENABLE(REQUEST_ANIMATION_FRAME)
195 #include "RequestAnimationFrameCallback.h"
196 #include "ScriptedAnimationController.h"
197 #endif
198
199 #if ENABLE(MICRODATA)
200 #include "MicroDataItemList.h"
201 #include "NodeRareData.h"
202 #endif
203
204 using namespace std;
205 using namespace WTF;
206 using namespace Unicode;
207
208 namespace WebCore {
209
210 using namespace HTMLNames;
211
212 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
213
214 static const unsigned cMaxWriteRecursionDepth = 21;
215
216 // This amount of time must have elapsed before we will even consider scheduling a layout without a delay.
217 // FIXME: For faster machines this value can really be lowered to 200.  250 is adequate, but a little high
218 // for dual G5s. :)
219 static const int cLayoutScheduleThreshold = 250;
220
221 // DOM Level 2 says (letters added):
222 //
223 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
224 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
225 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
226 // d) Characters which have a font or compatibility decomposition (i.e. those with a "compatibility formatting tag" in field 5 of the database -- marked by field 5 beginning with a "<") are not allowed.
227 // e) The following characters are treated as name-start characters rather than name characters, because the property file classifies them as Alphabetic: [#x02BB-#x02C1], #x0559, #x06E5, #x06E6.
228 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
229 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
230 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
231 // i) Characters ':' and '_' are allowed as name-start characters.
232 // j) Characters '-' and '.' are allowed as name characters.
233 //
234 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
235
236 static inline bool isValidNameStart(UChar32 c)
237 {
238     // rule (e) above
239     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
240         return true;
241
242     // rule (i) above
243     if (c == ':' || c == '_')
244         return true;
245
246     // rules (a) and (f) above
247     const uint32_t nameStartMask = Letter_Lowercase | Letter_Uppercase | Letter_Other | Letter_Titlecase | Number_Letter;
248     if (!(Unicode::category(c) & nameStartMask))
249         return false;
250
251     // rule (c) above
252     if (c >= 0xF900 && c < 0xFFFE)
253         return false;
254
255     // rule (d) above
256     DecompositionType decompType = decompositionType(c);
257     if (decompType == DecompositionFont || decompType == DecompositionCompat)
258         return false;
259
260     return true;
261 }
262
263 static inline bool isValidNamePart(UChar32 c)
264 {
265     // rules (a), (e), and (i) above
266     if (isValidNameStart(c))
267         return true;
268
269     // rules (g) and (h) above
270     if (c == 0x00B7 || c == 0x0387)
271         return true;
272
273     // rule (j) above
274     if (c == '-' || c == '.')
275         return true;
276
277     // rules (b) and (f) above
278     const uint32_t otherNamePartMask = Mark_NonSpacing | Mark_Enclosing | Mark_SpacingCombining | Letter_Modifier | Number_DecimalDigit;
279     if (!(Unicode::category(c) & otherNamePartMask))
280         return false;
281
282     // rule (c) above
283     if (c >= 0xF900 && c < 0xFFFE)
284         return false;
285
286     // rule (d) above
287     DecompositionType decompType = decompositionType(c);
288     if (decompType == DecompositionFont || decompType == DecompositionCompat)
289         return false;
290
291     return true;
292 }
293
294 static bool shouldInheritSecurityOriginFromOwner(const KURL& url)
295 {
296     // http://www.whatwg.org/specs/web-apps/current-work/#origin-0
297     //
298     // If a Document has the address "about:blank"
299     //     The origin of the Document is the origin it was assigned when its browsing context was created.
300     //
301     // Note: We generalize this to all "about" URLs and invalid URLs because we
302     // treat all of these URLs as about:blank.
303     //
304     return !url.isValid() || url.protocolIs("about");
305 }
306
307 static Widget* widgetForNode(Node* focusedNode)
308 {
309     if (!focusedNode)
310         return 0;
311     RenderObject* renderer = focusedNode->renderer();
312     if (!renderer || !renderer->isWidget())
313         return 0;
314     return toRenderWidget(renderer)->widget();
315 }
316
317 static bool acceptsEditingFocus(Node* node)
318 {
319     ASSERT(node);
320     ASSERT(node->rendererIsEditable());
321
322     Node* root = node->rootEditableElement();
323     Frame* frame = node->document()->frame();
324     if (!frame || !root)
325         return false;
326
327     return frame->editor()->shouldBeginEditing(rangeOfContents(root).get());
328 }
329
330 static bool disableRangeMutation(Page* page)
331 {
332     // This check is made on super-hot code paths, so we only want this on Leopard.
333 #ifdef TARGETING_LEOPARD
334     // Disable Range mutation on document modifications in Leopard Mail.
335     // See <rdar://problem/5865171>
336     return page && page->settings()->needsLeopardMailQuirks();
337 #else
338     UNUSED_PARAM(page);
339     return false;
340 #endif
341 }
342
343 static HashSet<Document*>* documentsThatNeedStyleRecalc = 0;
344
345 class DocumentWeakReference : public ThreadSafeRefCounted<DocumentWeakReference> {
346 public:
347     static PassRefPtr<DocumentWeakReference> create(Document* document)
348     {
349         return adoptRef(new DocumentWeakReference(document));
350     }
351
352     Document* document()
353     {
354         ASSERT(isMainThread());
355         return m_document;
356     }
357
358     void clear()
359     {
360         ASSERT(isMainThread());
361         m_document = 0;
362     }
363
364 private:
365     DocumentWeakReference(Document* document)
366         : m_document(document)
367     {
368         ASSERT(isMainThread());
369     }
370
371     Document* m_document;
372 };
373
374 uint64_t Document::s_globalTreeVersion = 0;
375
376 Document::Document(Frame* frame, const KURL& url, bool isXHTML, bool isHTML)
377     : TreeScope(0)
378     , m_guardRefCount(0)
379     , m_compatibilityMode(NoQuirksMode)
380     , m_compatibilityModeLocked(false)
381     , m_domTreeVersion(++s_globalTreeVersion)
382 #if ENABLE(MUTATION_OBSERVERS)
383     , m_subtreeMutationObserverTypes(0)
384 #endif
385     , m_styleSheets(StyleSheetList::create(this))
386     , m_readyState(Complete)
387     , m_styleRecalcTimer(this, &Document::styleRecalcTimerFired)
388     , m_pendingStyleRecalcShouldForce(false)
389     , m_frameElementsShouldIgnoreScrolling(false)
390     , m_containsValidityStyleRules(false)
391     , m_updateFocusAppearanceRestoresSelection(false)
392     , m_ignoreDestructiveWriteCount(0)
393     , m_titleSetExplicitly(false)
394     , m_updateFocusAppearanceTimer(this, &Document::updateFocusAppearanceTimerFired)
395     , m_loadEventFinished(false)
396     , m_startTime(currentTime())
397     , m_overMinimumLayoutThreshold(false)
398     , m_scriptRunner(ScriptRunner::create(this))
399     , m_xmlVersion("1.0")
400     , m_xmlStandalone(false)
401     , m_savedRenderer(0)
402     , m_designMode(inherit)
403 #if ENABLE(DASHBOARD_SUPPORT)
404     , m_hasDashboardRegions(false)
405     , m_dashboardRegionsDirty(false)
406 #endif
407     , m_createRenderers(true)
408     , m_inPageCache(false)
409     , m_accessKeyMapValid(false)
410     , m_useSecureKeyboardEntryWhenActive(false)
411     , m_isXHTML(isXHTML)
412     , m_isHTML(isHTML)
413     , m_isViewSource(false)
414     , m_sawElementsInKnownNamespaces(false)
415     , m_usingGeolocation(false)
416     , m_eventQueue(DocumentEventQueue::create(this))
417     , m_weakReference(DocumentWeakReference::create(this))
418     , m_idAttributeName(idAttr)
419 #if ENABLE(FULLSCREEN_API)
420     , m_areKeysEnabledInFullScreen(0)
421     , m_fullScreenRenderer(0)
422     , m_fullScreenChangeDelayTimer(this, &Document::fullScreenChangeDelayTimerFired)
423     , m_isAnimatingFullScreen(false)
424 #endif
425     , m_loadEventDelayCount(0)
426     , m_loadEventDelayTimer(this, &Document::loadEventDelayTimerFired)
427     , m_referrerPolicy(SecurityPolicy::ReferrerPolicyDefault)
428     , m_directionSetOnDocumentElement(false)
429     , m_writingModeSetOnDocumentElement(false)
430     , m_writeRecursionIsTooDeep(false)
431     , m_writeRecursionDepth(0)
432     , m_wheelEventHandlerCount(0)
433     , m_pendingTasksTimer(this, &Document::pendingTasksTimerFired)
434 {
435     m_document = this;
436
437     m_pageGroupUserSheetCacheValid = false;
438
439     m_printing = false;
440     m_paginatedForScreen = false;
441
442     m_ignoreAutofocus = false;
443
444     m_frame = frame;
445
446     // We depend on the url getting immediately set in subframes, but we
447     // also depend on the url NOT getting immediately set in opened windows.
448     // See fast/dom/early-frame-url.html
449     // and fast/dom/location-new-window-no-crash.html, respectively.
450     // FIXME: Can/should we unify this behavior?
451     if ((frame && frame->ownerElement()) || !url.isEmpty())
452         setURL(url);
453
454     m_axObjectCache = 0;
455
456     m_markers = adoptPtr(new DocumentMarkerController);
457
458     m_cachedResourceLoader = adoptPtr(new CachedResourceLoader(this));
459
460     m_visuallyOrdered = false;
461     m_bParsing = false;
462     m_wellFormed = false;
463
464     m_textColor = Color::black;
465     m_listenerTypes = 0;
466     setInDocument();
467     m_inStyleRecalc = false;
468     m_closeAfterStyleRecalc = false;
469
470     m_usesSiblingRules = false;
471     m_usesSiblingRulesOverride = false;
472     m_usesFirstLineRules = false;
473     m_usesFirstLetterRules = false;
474     m_usesBeforeAfterRules = false;
475     m_usesBeforeAfterRulesOverride = false;
476     m_usesRemUnits = false;
477     m_usesLinkRules = false;
478
479     m_gotoAnchorNeededAfterStylesheetsLoad = false;
480
481     m_didCalculateStyleSelector = false;
482     m_hasDirtyStyleSelector = false;
483     m_pendingStylesheets = 0;
484     m_ignorePendingStylesheets = false;
485     m_hasNodesWithPlaceholderStyle = false;
486     m_pendingSheetLayout = NoLayoutWithPendingSheets;
487
488     m_cssTarget = 0;
489
490     resetLinkColor();
491     resetVisitedLinkColor();
492     resetActiveLinkColor();
493
494     m_processingLoadEvent = false;
495     
496     initSecurityContext();
497     initDNSPrefetch();
498
499     static int docID = 0;
500     m_docID = docID++;
501 }
502
503 #if PLATFORM(CHROMIUM)
504 static void histogramMutationEventUsage(const unsigned short& listenerTypes)
505 {
506     PlatformSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMSubtreeModified", static_cast<bool>(listenerTypes & Document::DOMSUBTREEMODIFIED_LISTENER), 2);
507     PlatformSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeInserted", static_cast<bool>(listenerTypes & Document::DOMNODEINSERTED_LISTENER), 2);
508     PlatformSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeRemoved", static_cast<bool>(listenerTypes & Document::DOMNODEREMOVED_LISTENER), 2);
509     PlatformSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeRemovedFromDocument", static_cast<bool>(listenerTypes & Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER), 2);
510     PlatformSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeInsertedIntoDocument", static_cast<bool>(listenerTypes & Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER), 2);
511     PlatformSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMCharacterDataModified", static_cast<bool>(listenerTypes & Document::DOMCHARACTERDATAMODIFIED_LISTENER), 2);
512 }
513 #endif
514
515 Document::~Document()
516 {
517     ASSERT(!renderer());
518     ASSERT(!m_inPageCache);
519     ASSERT(!m_savedRenderer);
520     ASSERT(m_ranges.isEmpty());
521     ASSERT(!m_styleRecalcTimer.isActive());
522     ASSERT(!m_parentTreeScope);
523     ASSERT(!m_guardRefCount);
524
525     m_scriptRunner.clear();
526
527 #if PLATFORM(CHROMIUM)
528     histogramMutationEventUsage(m_listenerTypes);
529 #endif
530
531     removeAllEventListeners();
532
533     // Currently we believe that Document can never outlive the parser.
534     // Although the Document may be replaced synchronously, DocumentParsers
535     // generally keep at least one reference to an Element which would in turn
536     // has a reference to the Document.  If you hit this ASSERT, then that
537     // assumption is wrong.  DocumentParser::detach() should ensure that even
538     // if the DocumentParser outlives the Document it won't cause badness.
539     ASSERT(!m_parser || m_parser->refCount() == 1);
540     detachParser();
541     m_document = 0;
542     m_cachedResourceLoader.clear();
543
544     m_renderArena.clear();
545
546     clearAXObjectCache();
547
548     m_decoder = 0;
549
550     for (size_t i = 0; i < m_nameCollectionInfo.size(); ++i)
551         deleteAllValues(m_nameCollectionInfo[i]);
552
553     if (m_styleSheets)
554         m_styleSheets->documentDestroyed();
555
556     if (m_elemSheet)
557         m_elemSheet->clearOwnerNode();
558     if (m_mappedElementSheet)
559         m_mappedElementSheet->clearOwnerNode();
560     if (m_pageUserSheet)
561         m_pageUserSheet->clearOwnerNode();
562     if (m_pageGroupUserSheets) {
563         for (size_t i = 0; i < m_pageGroupUserSheets->size(); ++i)
564             (*m_pageGroupUserSheets)[i]->clearOwnerNode();
565     }
566     if (m_userSheets) {
567         for (size_t i = 0; i < m_userSheets->size(); ++i)
568             (*m_userSheets)[i]->clearOwnerNode();
569     }
570
571     deleteCustomFonts();
572
573     m_weakReference->clear();
574
575     if (m_mediaQueryMatcher)
576         m_mediaQueryMatcher->documentDestroyed();
577 }
578
579 void Document::removedLastRef()
580 {
581     ASSERT(!m_deletionHasBegun);
582     if (m_guardRefCount) {
583         // If removing a child removes the last self-only ref, we don't
584         // want the scope to be destructed until after
585         // removeAllChildren returns, so we guard ourselves with an
586         // extra self-only ref.
587         guardRef();
588
589         // We must make sure not to be retaining any of our children through
590         // these extra pointers or we will create a reference cycle.
591         m_docType = 0;
592         m_focusedNode = 0;
593         m_hoverNode = 0;
594         m_activeNode = 0;
595         m_titleElement = 0;
596         m_documentElement = 0;
597 #if ENABLE(FULLSCREEN_API)
598         m_fullScreenElement = 0;
599 #endif
600
601         // removeAllChildren() doesn't always unregister IDs,
602         // so tear down scope information upfront to avoid having stale references in the map.
603         destroyTreeScopeData();
604         removeAllChildren();
605
606         m_markers->detach();
607
608         detachParser();
609
610         m_cssCanvasElements.clear();
611
612 #if ENABLE(REQUEST_ANIMATION_FRAME)
613         // FIXME: consider using ActiveDOMObject.
614         m_scriptedAnimationController = nullptr;
615 #endif
616
617 #ifndef NDEBUG
618         m_inRemovedLastRefFunction = false;
619 #endif
620
621         guardDeref();
622     } else {
623 #ifndef NDEBUG
624         m_deletionHasBegun = true;
625 #endif
626         delete this;
627     }
628 }
629
630 Element* Document::getElementById(const AtomicString& id) const
631 {
632     return TreeScope::getElementById(id);
633 }
634
635 Element* Document::getElementByAccessKey(const String& key)
636 {
637     if (key.isEmpty())
638         return 0;
639     if (!m_accessKeyMapValid) {
640         buildAccessKeyMap(this);
641         m_accessKeyMapValid = true;
642     }
643     return m_elementsByAccessKey.get(key.impl());
644 }
645
646 void Document::buildAccessKeyMap(TreeScope* root)
647 {
648      for (Node* n = root; n; n = n->traverseNextNode(root)) {
649         if (!n->isElementNode())
650             continue;
651         Element* element = static_cast<Element*>(n);
652         const AtomicString& accessKey = element->getAttribute(accesskeyAttr);
653         if (!accessKey.isEmpty())
654             m_elementsByAccessKey.set(accessKey.impl(), element);
655         buildAccessKeyMap(element->shadowRoot());
656     }
657 }
658
659 void Document::invalidateAccessKeyMap()
660 {
661     m_accessKeyMapValid = false;
662     m_elementsByAccessKey.clear();
663 }
664
665 MediaQueryMatcher* Document::mediaQueryMatcher()
666 {
667     if (!m_mediaQueryMatcher)
668         m_mediaQueryMatcher = MediaQueryMatcher::create(this);
669     return m_mediaQueryMatcher.get();
670 }
671
672 void Document::setCompatibilityMode(CompatibilityMode mode)
673 {
674     if (m_compatibilityModeLocked || mode == m_compatibilityMode)
675         return;
676     ASSERT(!m_styleSheets->length());
677     bool wasInQuirksMode = inQuirksMode();
678     m_compatibilityMode = mode;
679     if (inQuirksMode() != wasInQuirksMode) {
680         // All user stylesheets have to reparse using the different mode.
681         clearPageUserSheet();
682         clearPageGroupUserSheets();
683     }
684 }
685
686 String Document::compatMode() const
687 {
688     return inQuirksMode() ? "BackCompat" : "CSS1Compat";
689 }
690
691 void Document::resetLinkColor()
692 {
693     m_linkColor = Color(0, 0, 238);
694 }
695
696 void Document::resetVisitedLinkColor()
697 {
698     m_visitedLinkColor = Color(85, 26, 139);    
699 }
700
701 void Document::resetActiveLinkColor()
702 {
703     m_activeLinkColor.setNamedColor("red");
704 }
705
706 void Document::setDocType(PassRefPtr<DocumentType> docType)
707 {
708     // This should never be called more than once.
709     ASSERT(!m_docType || !docType);
710     m_docType = docType;
711     if (m_docType)
712         m_docType->setTreeScopeRecursively(this);
713 }
714
715 DOMImplementation* Document::implementation()
716 {
717     if (!m_implementation)
718         m_implementation = DOMImplementation::create(this);
719     return m_implementation.get();
720 }
721
722 void Document::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
723 {
724     TreeScope::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
725     
726     // Invalidate the document element we have cached in case it was replaced.
727     m_documentElement = 0;
728 }
729
730 void Document::cacheDocumentElement() const
731 {
732     ASSERT(!m_documentElement);
733     m_documentElement = firstElementChild(this);
734 }
735
736 PassRefPtr<Element> Document::createElement(const AtomicString& name, ExceptionCode& ec)
737 {
738     if (!isValidName(name)) {
739         ec = INVALID_CHARACTER_ERR;
740         return 0;
741     }
742
743     if (m_isXHTML)
744         return HTMLElementFactory::createHTMLElement(QualifiedName(nullAtom, name, xhtmlNamespaceURI), this, 0, false);
745
746     return createElement(QualifiedName(nullAtom, name, nullAtom), false);
747 }
748
749 PassRefPtr<DocumentFragment> Document::createDocumentFragment()
750 {
751     return DocumentFragment::create(document());
752 }
753
754 PassRefPtr<Text> Document::createTextNode(const String& data)
755 {
756     return Text::create(this, data);
757 }
758
759 PassRefPtr<Comment> Document::createComment(const String& data)
760 {
761     return Comment::create(this, data);
762 }
763
764 PassRefPtr<CDATASection> Document::createCDATASection(const String& data, ExceptionCode& ec)
765 {
766     if (isHTMLDocument()) {
767         ec = NOT_SUPPORTED_ERR;
768         return 0;
769     }
770     return CDATASection::create(this, data);
771 }
772
773 PassRefPtr<ProcessingInstruction> Document::createProcessingInstruction(const String& target, const String& data, ExceptionCode& ec)
774 {
775     if (!isValidName(target)) {
776         ec = INVALID_CHARACTER_ERR;
777         return 0;
778     }
779     if (isHTMLDocument()) {
780         ec = NOT_SUPPORTED_ERR;
781         return 0;
782     }
783     return ProcessingInstruction::create(this, target, data);
784 }
785
786 PassRefPtr<EntityReference> Document::createEntityReference(const String& name, ExceptionCode& ec)
787 {
788     if (!isValidName(name)) {
789         ec = INVALID_CHARACTER_ERR;
790         return 0;
791     }
792     if (isHTMLDocument()) {
793         ec = NOT_SUPPORTED_ERR;
794         return 0;
795     }
796     return EntityReference::create(this, name);
797 }
798
799 PassRefPtr<EditingText> Document::createEditingTextNode(const String& text)
800 {
801     return EditingText::create(this, text);
802 }
803
804 PassRefPtr<CSSStyleDeclaration> Document::createCSSStyleDeclaration()
805 {
806     return CSSMutableStyleDeclaration::create();
807 }
808
809 PassRefPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionCode& ec)
810 {
811     ec = 0;
812     
813     if (!importedNode
814 #if ENABLE(SVG) && ENABLE(DASHBOARD_SUPPORT)
815         || (importedNode->isSVGElement() && page() && page()->settings()->usesDashboardBackwardCompatibilityMode())
816 #endif
817         ) {
818         ec = NOT_SUPPORTED_ERR;
819         return 0;
820     }
821
822     switch (importedNode->nodeType()) {
823     case TEXT_NODE:
824         return createTextNode(importedNode->nodeValue());
825     case CDATA_SECTION_NODE:
826         return createCDATASection(importedNode->nodeValue(), ec);
827     case ENTITY_REFERENCE_NODE:
828         return createEntityReference(importedNode->nodeName(), ec);
829     case PROCESSING_INSTRUCTION_NODE:
830         return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), ec);
831     case COMMENT_NODE:
832         return createComment(importedNode->nodeValue());
833     case ELEMENT_NODE: {
834         Element* oldElement = static_cast<Element*>(importedNode);
835         RefPtr<Element> newElement = createElementNS(oldElement->namespaceURI(), oldElement->tagQName().toString(), ec);
836                     
837         if (ec)
838             return 0;
839
840         NamedNodeMap* attrs = oldElement->attributes(true);
841         if (attrs) {
842             unsigned length = attrs->length();
843             for (unsigned i = 0; i < length; i++) {
844                 Attribute* attr = attrs->attributeItem(i);
845                 newElement->setAttribute(attr->name(), attr->value().impl(), ec);
846                 if (ec)
847                     return 0;
848             }
849         }
850
851         newElement->copyNonAttributeProperties(oldElement);
852
853         if (deep) {
854             for (Node* oldChild = oldElement->firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
855                 RefPtr<Node> newChild = importNode(oldChild, true, ec);
856                 if (ec)
857                     return 0;
858                 newElement->appendChild(newChild.release(), ec);
859                 if (ec)
860                     return 0;
861             }
862         }
863
864         return newElement.release();
865     }
866     case ATTRIBUTE_NODE:
867         return Attr::create(0, this, static_cast<Attr*>(importedNode)->attr()->clone());
868     case DOCUMENT_FRAGMENT_NODE: {
869         DocumentFragment* oldFragment = static_cast<DocumentFragment*>(importedNode);
870         RefPtr<DocumentFragment> newFragment = createDocumentFragment();
871         if (deep) {
872             for (Node* oldChild = oldFragment->firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
873                 RefPtr<Node> newChild = importNode(oldChild, true, ec);
874                 if (ec)
875                     return 0;
876                 newFragment->appendChild(newChild.release(), ec);
877                 if (ec)
878                     return 0;
879             }
880         }
881         
882         return newFragment.release();
883     }
884     case ENTITY_NODE:
885     case NOTATION_NODE:
886         // FIXME: It should be possible to import these node types, however in DOM3 the DocumentType is readonly, so there isn't much sense in doing that.
887         // Ability to add these imported nodes to a DocumentType will be considered for addition to a future release of the DOM.
888     case DOCUMENT_NODE:
889     case DOCUMENT_TYPE_NODE:
890     case XPATH_NAMESPACE_NODE:
891     case SHADOW_ROOT_NODE:
892         // ShadowRoot nodes should not be explicitly importable.
893         // Either they are imported along with their host node, or created implicitly.
894         break;
895     }
896     ec = NOT_SUPPORTED_ERR;
897     return 0;
898 }
899
900
901 PassRefPtr<Node> Document::adoptNode(PassRefPtr<Node> source, ExceptionCode& ec)
902 {
903     if (!source) {
904         ec = NOT_SUPPORTED_ERR;
905         return 0;
906     }
907
908     if (source->isReadOnlyNode()) {
909         ec = NO_MODIFICATION_ALLOWED_ERR;
910         return 0;
911     }
912
913     EventQueueScope scope;
914
915     switch (source->nodeType()) {
916     case ENTITY_NODE:
917     case NOTATION_NODE:
918     case DOCUMENT_NODE:
919     case DOCUMENT_TYPE_NODE:
920     case XPATH_NAMESPACE_NODE:
921         ec = NOT_SUPPORTED_ERR;
922         return 0;            
923     case ATTRIBUTE_NODE: {                   
924         Attr* attr = static_cast<Attr*>(source.get());
925         if (attr->ownerElement())
926             attr->ownerElement()->removeAttributeNode(attr, ec);
927         attr->setSpecified(true);
928         break;
929     }       
930     default:
931         if (source->hasTagName(iframeTag)) {
932             HTMLIFrameElement* iframe = static_cast<HTMLIFrameElement*>(source.get());
933             if (frame() && frame()->tree()->isDescendantOf(iframe->contentFrame())) {
934                 ec = HIERARCHY_REQUEST_ERR;
935                 return 0;
936             }
937             iframe->setRemainsAliveOnRemovalFromTree(attached() && source->attached() && iframe->canRemainAliveOnRemovalFromTree());
938         }
939
940         if (source->parentNode())
941             source->parentNode()->removeChild(source.get(), ec);
942     }
943
944     source->setTreeScopeRecursively(this);
945
946     return source;
947 }
948
949 bool Document::hasPrefixNamespaceMismatch(const QualifiedName& qName)
950 {
951     // These checks are from DOM Core Level 2, createElementNS
952     // http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-DocCrElNS
953     if (!qName.prefix().isEmpty() && qName.namespaceURI().isNull()) // createElementNS(null, "html:div")
954         return true;
955     if (qName.prefix() == xmlAtom && qName.namespaceURI() != XMLNames::xmlNamespaceURI) // createElementNS("http://www.example.com", "xml:lang")
956         return true;
957
958     // Required by DOM Level 3 Core and unspecified by DOM Level 2 Core:
959     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
960     // createElementNS("http://www.w3.org/2000/xmlns/", "foo:bar"), createElementNS(null, "xmlns:bar")
961     if ((qName.prefix() == xmlnsAtom && qName.namespaceURI() != XMLNSNames::xmlnsNamespaceURI) || (qName.prefix() != xmlnsAtom && qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI))
962         return true;
963
964     return false;
965 }
966
967 // FIXME: This should really be in a possible ElementFactory class
968 PassRefPtr<Element> Document::createElement(const QualifiedName& qName, bool createdByParser)
969 {
970     RefPtr<Element> e;
971
972     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
973     if (qName.namespaceURI() == xhtmlNamespaceURI)
974         e = HTMLElementFactory::createHTMLElement(qName, this, 0, createdByParser);
975 #if ENABLE(SVG)
976     else if (qName.namespaceURI() == SVGNames::svgNamespaceURI)
977         e = SVGElementFactory::createSVGElement(qName, this, createdByParser);
978 #endif
979 #if ENABLE(MATHML)
980     else if (qName.namespaceURI() == MathMLNames::mathmlNamespaceURI)
981         e = MathMLElementFactory::createMathMLElement(qName, this, createdByParser);
982 #endif
983
984     if (e)
985         m_sawElementsInKnownNamespaces = true;
986     else
987         e = Element::create(qName, document());
988
989     // <image> uses imgTag so we need a special rule.
990     ASSERT((qName.matches(imageTag) && e->tagQName().matches(imgTag) && e->tagQName().prefix() == qName.prefix()) || qName == e->tagQName());
991
992     return e.release();
993 }
994
995 PassRefPtr<Element> Document::createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode& ec)
996 {
997     String prefix, localName;
998     if (!parseQualifiedName(qualifiedName, prefix, localName, ec))
999         return 0;
1000
1001     QualifiedName qName(prefix, localName, namespaceURI);
1002     if (hasPrefixNamespaceMismatch(qName)) {
1003         ec = NAMESPACE_ERR;
1004         return 0;
1005     }
1006
1007     return createElement(qName, false);
1008 }
1009
1010 String Document::readyState() const
1011 {
1012     DEFINE_STATIC_LOCAL(const String, loading, ("loading"));
1013     DEFINE_STATIC_LOCAL(const String, interactive, ("interactive"));
1014     DEFINE_STATIC_LOCAL(const String, complete, ("complete"));
1015
1016     switch (m_readyState) {
1017     case Loading:
1018         return loading;
1019     case Interactive:
1020         return interactive;
1021     case Complete:
1022         return complete;
1023     }
1024
1025     ASSERT_NOT_REACHED();
1026     return String();
1027 }
1028
1029 void Document::setReadyState(ReadyState readyState)
1030 {
1031     if (readyState == m_readyState)
1032         return;
1033
1034     switch (readyState) {
1035     case Loading:
1036         if (!m_documentTiming.domLoading)
1037             m_documentTiming.domLoading = currentTime();
1038         break;
1039     case Interactive:
1040         if (!m_documentTiming.domInteractive)
1041             m_documentTiming.domInteractive = currentTime();
1042         break;
1043     case Complete:
1044         if (!m_documentTiming.domComplete)
1045             m_documentTiming.domComplete = currentTime();
1046         break;
1047     }
1048
1049     m_readyState = readyState;
1050     dispatchEvent(Event::create(eventNames().readystatechangeEvent, false, false));
1051 }
1052
1053 String Document::encoding() const
1054 {
1055     if (TextResourceDecoder* d = decoder())
1056         return d->encoding().domName();
1057     return String();
1058 }
1059
1060 String Document::defaultCharset() const
1061 {
1062     if (Settings* settings = this->settings())
1063         return settings->defaultTextEncodingName();
1064     return String();
1065 }
1066
1067 void Document::setCharset(const String& charset)
1068 {
1069     if (!decoder())
1070         return;
1071     decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
1072 }
1073
1074 void Document::setXMLVersion(const String& version, ExceptionCode& ec)
1075 {
1076     if (!implementation()->hasFeature("XML", String())) {
1077         ec = NOT_SUPPORTED_ERR;
1078         return;
1079     }
1080
1081     if (!XMLDocumentParser::supportsXMLVersion(version)) {
1082         ec = NOT_SUPPORTED_ERR;
1083         return;
1084     }
1085
1086     m_xmlVersion = version;
1087 }
1088
1089 void Document::setXMLStandalone(bool standalone, ExceptionCode& ec)
1090 {
1091     if (!implementation()->hasFeature("XML", String())) {
1092         ec = NOT_SUPPORTED_ERR;
1093         return;
1094     }
1095
1096     m_xmlStandalone = standalone;
1097 }
1098
1099 void Document::setDocumentURI(const String& uri)
1100 {
1101     m_documentURI = uri;
1102     updateBaseURL();
1103 }
1104
1105 KURL Document::baseURI() const
1106 {
1107     return m_baseURL;
1108 }
1109
1110 void Document::setContent(const String& content)
1111 {
1112     open();
1113     m_parser->append(content);
1114     close();
1115 }
1116
1117 String Document::suggestedMIMEType() const
1118 {
1119     if (m_document->isXHTMLDocument())
1120         return "application/xhtml+xml";
1121     if (m_document->isSVGDocument())
1122         return "image/svg+xml";
1123     if (m_document->xmlStandalone())
1124         return "text/xml";
1125     if (m_document->isHTMLDocument())
1126         return "text/html";
1127
1128     if (DocumentLoader* documentLoader = loader())
1129         return documentLoader->responseMIMEType();
1130     return String();
1131 }
1132
1133 // FIXME: We need to discuss the DOM API here at some point. Ideas:
1134 // * making it receive a rect as parameter, i.e. nodesFromRect(x, y, w, h);
1135 // * making it receive the expading size of each direction separately,
1136 //   i.e. nodesFromRect(x, y, topSize, rightSize, bottomSize, leftSize);
1137 PassRefPtr<NodeList> Document::nodesFromRect(int centerX, int centerY, unsigned topPadding, unsigned rightPadding, unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping) const
1138 {
1139     // FIXME: Share code between this, elementFromPoint and caretRangeFromPoint.
1140     if (!renderer())
1141         return 0;
1142     Frame* frame = this->frame();
1143     if (!frame)
1144         return 0;
1145     FrameView* frameView = frame->view();
1146     if (!frameView)
1147         return 0;
1148
1149     float zoomFactor = frame->pageZoomFactor();
1150     LayoutPoint point = roundedLayoutPoint(FloatPoint(centerX * zoomFactor + view()->scrollX(), centerY * zoomFactor + view()->scrollY()));
1151
1152     int type = HitTestRequest::ReadOnly | HitTestRequest::Active;
1153
1154     // When ignoreClipping is false, this method returns null for coordinates outside of the viewport.
1155     if (ignoreClipping)
1156         type |= HitTestRequest::IgnoreClipping;
1157     else if (!frameView->visibleContentRect().intersects(HitTestResult::rectForPoint(point, topPadding, rightPadding, bottomPadding, leftPadding)))
1158         return 0;
1159
1160     HitTestRequest request(type);
1161
1162     // Passing a zero padding will trigger a rect hit test, however for the purposes of nodesFromRect,
1163     // we special handle this case in order to return a valid NodeList.
1164     if (!topPadding && !rightPadding && !bottomPadding && !leftPadding) {
1165         HitTestResult result(point);
1166         return handleZeroPadding(request, result);
1167     }
1168
1169     HitTestResult result(point, topPadding, rightPadding, bottomPadding, leftPadding);
1170     renderView()->layer()->hitTest(request, result);
1171
1172     return StaticHashSetNodeList::adopt(result.rectBasedTestResult());
1173 }
1174
1175 PassRefPtr<NodeList> Document::handleZeroPadding(const HitTestRequest& request, HitTestResult& result) const
1176 {
1177     renderView()->layer()->hitTest(request, result);
1178
1179     Node* node = result.innerNode();
1180     if (!node)
1181         return 0;
1182
1183     node = node->shadowAncestorNode();
1184     ListHashSet<RefPtr<Node> > list;
1185     list.add(node);
1186     return StaticHashSetNodeList::adopt(list);
1187 }
1188
1189 static Node* nodeFromPoint(Frame* frame, RenderView* renderView, int x, int y, LayoutPoint* localPoint = 0)
1190 {
1191     if (!frame)
1192         return 0;
1193     FrameView* frameView = frame->view();
1194     if (!frameView)
1195         return 0;
1196
1197     float zoomFactor = frame->pageZoomFactor();
1198     IntPoint point = roundedIntPoint(FloatPoint(x * zoomFactor  + frameView->scrollX(), y * zoomFactor + frameView->scrollY()));
1199
1200     if (!frameView->visibleContentRect().contains(point))
1201         return 0;
1202
1203     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
1204     HitTestResult result(point);
1205     renderView->layer()->hitTest(request, result);
1206
1207     if (localPoint)
1208         *localPoint = result.localPoint();
1209
1210     return result.innerNode();
1211 }
1212
1213 Element* Document::elementFromPoint(int x, int y) const
1214 {
1215     if (!renderer())
1216         return 0;
1217     Node* node = nodeFromPoint(frame(), renderView(), x, y);
1218     while (node && !node->isElementNode())
1219         node = node->parentNode();
1220     if (node)
1221         node = node->shadowAncestorNode();
1222     return static_cast<Element*>(node);
1223 }
1224
1225 PassRefPtr<Range> Document::caretRangeFromPoint(int x, int y)
1226 {
1227     if (!renderer())
1228         return 0;
1229     LayoutPoint localPoint;
1230     Node* node = nodeFromPoint(frame(), renderView(), x, y, &localPoint);
1231     if (!node)
1232         return 0;
1233
1234     Node* shadowAncestorNode = node->shadowAncestorNode();
1235     if (shadowAncestorNode != node) {
1236         unsigned offset = shadowAncestorNode->nodeIndex();
1237         ContainerNode* container = shadowAncestorNode->parentNode();
1238         return Range::create(this, container, offset, container, offset);
1239     }
1240
1241     RenderObject* renderer = node->renderer();
1242     if (!renderer)
1243         return 0;
1244     VisiblePosition visiblePosition = renderer->positionForPoint(localPoint);
1245     if (visiblePosition.isNull())
1246         return 0;
1247
1248     Position rangeCompliantPosition = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
1249     return Range::create(this, rangeCompliantPosition, rangeCompliantPosition);
1250 }
1251
1252 /*
1253  * Performs three operations:
1254  *  1. Convert control characters to spaces
1255  *  2. Trim leading and trailing spaces
1256  *  3. Collapse internal whitespace.
1257  */
1258 static inline StringWithDirection canonicalizedTitle(Document* document, const StringWithDirection& titleWithDirection)
1259 {
1260     const String& title = titleWithDirection.string();
1261     const UChar* characters = title.characters();
1262     unsigned length = title.length();
1263     unsigned i;
1264
1265     StringBuffer<UChar> buffer(length);
1266     unsigned builderIndex = 0;
1267
1268     // Skip leading spaces and leading characters that would convert to spaces
1269     for (i = 0; i < length; ++i) {
1270         UChar c = characters[i];
1271         if (!(c <= 0x20 || c == 0x7F))
1272             break;
1273     }
1274
1275     if (i == length)
1276         return StringWithDirection();
1277
1278     // Replace control characters with spaces, and backslashes with currency symbols, and collapse whitespace.
1279     bool previousCharWasWS = false;
1280     for (; i < length; ++i) {
1281         UChar c = characters[i];
1282         if (c <= 0x20 || c == 0x7F || (WTF::Unicode::category(c) & (WTF::Unicode::Separator_Line | WTF::Unicode::Separator_Paragraph))) {
1283             if (previousCharWasWS)
1284                 continue;
1285             buffer[builderIndex++] = ' ';
1286             previousCharWasWS = true;
1287         } else {
1288             buffer[builderIndex++] = c;
1289             previousCharWasWS = false;
1290         }
1291     }
1292
1293     // Strip trailing spaces
1294     while (builderIndex > 0) {
1295         --builderIndex;
1296         if (buffer[builderIndex] != ' ')
1297             break;
1298     }
1299
1300     if (!builderIndex && buffer[builderIndex] == ' ')
1301         return StringWithDirection();
1302
1303     buffer.shrink(builderIndex + 1);
1304
1305     // Replace the backslashes with currency symbols if the encoding requires it.
1306     document->displayBufferModifiedByEncoding(buffer.characters(), buffer.length());
1307     
1308     return StringWithDirection(String::adopt(buffer), titleWithDirection.direction());
1309 }
1310
1311 void Document::updateTitle(const StringWithDirection& title)
1312 {
1313     if (m_rawTitle == title)
1314         return;
1315
1316     m_rawTitle = title;
1317     m_title = canonicalizedTitle(this, m_rawTitle);
1318     if (Frame* f = frame())
1319         f->loader()->setTitle(m_title);
1320 }
1321
1322 void Document::setTitle(const String& title)
1323 {
1324     // Title set by JavaScript -- overrides any title elements.
1325     m_titleSetExplicitly = true;
1326     if (!isHTMLDocument() && !isXHTMLDocument())
1327         m_titleElement = 0;
1328     else if (!m_titleElement) {
1329         if (HTMLElement* headElement = head()) {
1330             m_titleElement = createElement(titleTag, false);
1331             ExceptionCode ec = 0;
1332             headElement->appendChild(m_titleElement, ec);
1333             ASSERT(!ec);
1334         }
1335     }
1336
1337     // The DOM API has no method of specifying direction, so assume LTR.
1338     updateTitle(StringWithDirection(title, LTR));
1339
1340     if (m_titleElement) {
1341         ASSERT(m_titleElement->hasTagName(titleTag));
1342         if (m_titleElement->hasTagName(titleTag))
1343             static_cast<HTMLTitleElement*>(m_titleElement.get())->setText(title);
1344     }
1345 }
1346
1347 void Document::setTitleElement(const StringWithDirection& title, Element* titleElement)
1348 {
1349     if (titleElement != m_titleElement) {
1350         if (m_titleElement || m_titleSetExplicitly)
1351             // Only allow the first title element to change the title -- others have no effect.
1352             return;
1353         m_titleElement = titleElement;
1354     }
1355
1356     updateTitle(title);
1357 }
1358
1359 void Document::removeTitle(Element* titleElement)
1360 {
1361     if (m_titleElement != titleElement)
1362         return;
1363
1364     m_titleElement = 0;
1365     m_titleSetExplicitly = false;
1366
1367     // Update title based on first title element in the head, if one exists.
1368     if (HTMLElement* headElement = head()) {
1369         for (Node* e = headElement->firstChild(); e; e = e->nextSibling())
1370             if (e->hasTagName(titleTag)) {
1371                 HTMLTitleElement* titleElement = static_cast<HTMLTitleElement*>(e);
1372                 setTitleElement(titleElement->textWithDirection(), titleElement);
1373                 break;
1374             }
1375     }
1376
1377     if (!m_titleElement)
1378         updateTitle(StringWithDirection());
1379 }
1380
1381 #if ENABLE(PAGE_VISIBILITY_API)
1382 PageVisibilityState Document::visibilityState() const
1383 {
1384     // The visibility of the document is inherited from the visibility of the
1385     // page. If there is no page associated with the document, we will assume
1386     // that the page is visible i.e. invisibility has to be explicitly
1387     // specified by the embedder.
1388     if (!m_frame || !m_frame->page())
1389         return PageVisibilityStateVisible;
1390     return m_frame->page()->visibilityState();
1391 }
1392
1393 String Document::webkitVisibilityState() const
1394 {
1395     return pageVisibilityStateString(visibilityState());
1396 }
1397
1398 bool Document::webkitHidden() const
1399 {
1400     return visibilityState() != PageVisibilityStateVisible;
1401 }
1402
1403 void Document::dispatchVisibilityStateChangeEvent()
1404 {
1405     dispatchEvent(Event::create(eventNames().webkitvisibilitychangeEvent, false, false));
1406 }
1407 #endif
1408
1409 String Document::nodeName() const
1410 {
1411     return "#document";
1412 }
1413
1414 Node::NodeType Document::nodeType() const
1415 {
1416     return DOCUMENT_NODE;
1417 }
1418
1419 FrameView* Document::view() const
1420 {
1421     return m_frame ? m_frame->view() : 0;
1422 }
1423
1424 Page* Document::page() const
1425 {
1426     return m_frame ? m_frame->page() : 0;    
1427 }
1428
1429 Settings* Document::settings() const
1430 {
1431     return m_frame ? m_frame->settings() : 0;
1432 }
1433
1434 PassRefPtr<Range> Document::createRange()
1435 {
1436     return Range::create(this);
1437 }
1438
1439 PassRefPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, 
1440     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
1441 {
1442     if (!root) {
1443         ec = NOT_SUPPORTED_ERR;
1444         return 0;
1445     }
1446     return NodeIterator::create(root, whatToShow, filter, expandEntityReferences);
1447 }
1448
1449 PassRefPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow, 
1450     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
1451 {
1452     if (!root) {
1453         ec = NOT_SUPPORTED_ERR;
1454         return 0;
1455     }
1456     return TreeWalker::create(root, whatToShow, filter, expandEntityReferences);
1457 }
1458
1459 void Document::scheduleForcedStyleRecalc()
1460 {
1461     m_pendingStyleRecalcShouldForce = true;
1462     scheduleStyleRecalc();
1463 }
1464
1465 void Document::scheduleStyleRecalc()
1466 {
1467     if (m_styleRecalcTimer.isActive() || inPageCache())
1468         return;
1469
1470     ASSERT(childNeedsStyleRecalc() || m_pendingStyleRecalcShouldForce);
1471
1472     if (!documentsThatNeedStyleRecalc)
1473         documentsThatNeedStyleRecalc = new HashSet<Document*>;
1474     documentsThatNeedStyleRecalc->add(this);
1475     
1476     // FIXME: Why on earth is this here? This is clearly misplaced.
1477     invalidateAccessKeyMap();
1478     
1479     m_styleRecalcTimer.startOneShot(0);
1480
1481     InspectorInstrumentation::didScheduleStyleRecalculation(this);
1482 }
1483
1484 void Document::unscheduleStyleRecalc()
1485 {
1486     ASSERT(!childNeedsStyleRecalc());
1487
1488     if (documentsThatNeedStyleRecalc)
1489         documentsThatNeedStyleRecalc->remove(this);
1490
1491     m_styleRecalcTimer.stop();
1492     m_pendingStyleRecalcShouldForce = false;
1493 }
1494
1495 bool Document::isPendingStyleRecalc() const
1496 {
1497     return m_styleRecalcTimer.isActive() && !m_inStyleRecalc;
1498 }
1499
1500 void Document::styleRecalcTimerFired(Timer<Document>*)
1501 {
1502     updateStyleIfNeeded();
1503 }
1504
1505 bool Document::childNeedsAndNotInStyleRecalc()
1506 {
1507     return childNeedsStyleRecalc() && !m_inStyleRecalc;
1508 }
1509
1510 void Document::recalcStyle(StyleChange change)
1511 {
1512     // we should not enter style recalc while painting
1513     if (view() && view()->isPainting()) {
1514         ASSERT(!view()->isPainting());
1515         return;
1516     }
1517     
1518     if (m_inStyleRecalc)
1519         return; // Guard against re-entrancy. -dwh
1520     
1521     if (m_hasDirtyStyleSelector)
1522         recalcStyleSelector();
1523
1524     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willRecalculateStyle(this);
1525
1526     m_inStyleRecalc = true;
1527     suspendPostAttachCallbacks();
1528     RenderWidget::suspendWidgetHierarchyUpdates();
1529     
1530     RefPtr<FrameView> frameView = view();
1531     if (frameView) {
1532         frameView->pauseScheduledEvents();
1533         frameView->beginDeferredRepaints();
1534     }
1535
1536     ASSERT(!renderer() || renderArena());
1537     if (!renderer() || !renderArena())
1538         goto bail_out;
1539
1540     if (m_pendingStyleRecalcShouldForce)
1541         change = Force;
1542
1543     if (change == Force) {
1544         // style selector may set this again during recalc
1545         m_hasNodesWithPlaceholderStyle = false;
1546         
1547         RefPtr<RenderStyle> documentStyle = CSSStyleSelector::styleForDocument(this);
1548         StyleChange ch = diff(documentStyle.get(), renderer()->style());
1549         if (ch != NoChange)
1550             renderer()->setStyle(documentStyle.release());
1551     }
1552
1553     for (Node* n = firstChild(); n; n = n->nextSibling()) {
1554         if (!n->isElementNode())
1555             continue;
1556         Element* element = static_cast<Element*>(n);
1557         if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc())
1558             element->recalcStyle(change);
1559     }
1560
1561 #if USE(ACCELERATED_COMPOSITING)
1562     if (view()) {
1563         bool layoutPending = view()->layoutPending() || renderer()->needsLayout();
1564         // If we didn't update compositing layers because of layout(), we need to do so here.
1565         if (!layoutPending)
1566             view()->updateCompositingLayers();
1567     }
1568 #endif
1569
1570 bail_out:
1571     clearNeedsStyleRecalc();
1572     clearChildNeedsStyleRecalc();
1573     unscheduleStyleRecalc();
1574
1575     m_inStyleRecalc = false;
1576     
1577     // Pseudo element removal and similar may only work with these flags still set. Reset them after the style recalc.
1578     if (m_styleSelector) {
1579         m_usesSiblingRules = m_styleSelector->usesSiblingRules();
1580         m_usesFirstLineRules = m_styleSelector->usesFirstLineRules();
1581         m_usesBeforeAfterRules = m_styleSelector->usesBeforeAfterRules();
1582         m_usesLinkRules = m_styleSelector->usesLinkRules();
1583     }
1584
1585     if (frameView) {
1586         frameView->resumeScheduledEvents();
1587         frameView->endDeferredRepaints();
1588     }
1589     RenderWidget::resumeWidgetHierarchyUpdates();
1590     resumePostAttachCallbacks();
1591
1592     // If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.
1593     if (m_closeAfterStyleRecalc) {
1594         m_closeAfterStyleRecalc = false;
1595         implicitClose();
1596     }
1597
1598     InspectorInstrumentation::didRecalculateStyle(cookie);
1599 }
1600
1601 void Document::updateStyleIfNeeded()
1602 {
1603     ASSERT(isMainThread());
1604     ASSERT(!view() || (!view()->isInLayout() && !view()->isPainting()));
1605     
1606     if ((!m_pendingStyleRecalcShouldForce && !childNeedsStyleRecalc()) || inPageCache())
1607         return;
1608
1609     if (m_frame)
1610         m_frame->animation()->beginAnimationUpdate();
1611         
1612     recalcStyle(NoChange);
1613
1614     // Tell the animation controller that updateStyleIfNeeded is finished and it can do any post-processing
1615     if (m_frame)
1616         m_frame->animation()->endAnimationUpdate();
1617 }
1618
1619 void Document::updateStyleForAllDocuments()
1620 {
1621     ASSERT(isMainThread());
1622     if (!documentsThatNeedStyleRecalc)
1623         return;
1624
1625     while (documentsThatNeedStyleRecalc->size()) {
1626         HashSet<Document*>::iterator it = documentsThatNeedStyleRecalc->begin();
1627         Document* doc = *it;
1628         documentsThatNeedStyleRecalc->remove(doc);
1629         doc->updateStyleIfNeeded();
1630     }
1631 }
1632
1633 void Document::updateLayout()
1634 {
1635     ASSERT(isMainThread());
1636     if (Element* oe = ownerElement())
1637         oe->document()->updateLayout();
1638
1639     updateStyleIfNeeded();
1640
1641     // Only do a layout if changes have occurred that make it necessary.      
1642     FrameView* v = view();
1643     if (v && renderer() && (v->layoutPending() || renderer()->needsLayout()))
1644         v->layout();
1645 }
1646
1647 // FIXME: This is a bad idea and needs to be removed eventually.
1648 // Other browsers load stylesheets before they continue parsing the web page.
1649 // Since we don't, we can run JavaScript code that needs answers before the
1650 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
1651 // lets us get reasonable answers. The long term solution to this problem is
1652 // to instead suspend JavaScript execution.
1653 void Document::updateLayoutIgnorePendingStylesheets()
1654 {
1655     bool oldIgnore = m_ignorePendingStylesheets;
1656     
1657     if (!haveStylesheetsLoaded()) {
1658         m_ignorePendingStylesheets = true;
1659         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.  Our assumption is that it would be
1660         // dangerous to try to stop it a second time, after page content has already been loaded and displayed
1661         // with accurate style information.  (Our suppression involves blanking the whole page at the
1662         // moment.  If it were more refined, we might be able to do something better.)
1663         // It's worth noting though that this entire method is a hack, since what we really want to do is
1664         // suspend JS instead of doing a layout with inaccurate information.
1665         if (body() && !body()->renderer() && m_pendingSheetLayout == NoLayoutWithPendingSheets) {
1666             m_pendingSheetLayout = DidLayoutWithPendingSheets;
1667             styleSelectorChanged(RecalcStyleImmediately);
1668         } else if (m_hasNodesWithPlaceholderStyle)
1669             // If new nodes have been added or style recalc has been done with style sheets still pending, some nodes 
1670             // may not have had their real style calculated yet. Normally this gets cleaned when style sheets arrive 
1671             // but here we need up-to-date style immediately.
1672             recalcStyle(Force);
1673     }
1674
1675     updateLayout();
1676
1677     m_ignorePendingStylesheets = oldIgnore;
1678 }
1679
1680 PassRefPtr<RenderStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
1681 {
1682     ASSERT_ARG(element, element->document() == this);
1683
1684     bool oldIgnore = m_ignorePendingStylesheets;
1685     m_ignorePendingStylesheets = true;
1686     RefPtr<RenderStyle> style = styleSelector()->styleForElement(element, element->parentNode() ? element->parentNode()->computedStyle() : 0);
1687     m_ignorePendingStylesheets = oldIgnore;
1688     return style.release();
1689 }
1690
1691 PassRefPtr<RenderStyle> Document::styleForPage(int pageIndex)
1692 {
1693     RefPtr<RenderStyle> style = styleSelector()->styleForPage(pageIndex);
1694     return style.release();
1695 }
1696
1697 void Document::registerCustomFont(FontData* fontData)
1698 {
1699     m_customFonts.append(adoptPtr(fontData));
1700 }
1701
1702 void Document::deleteCustomFonts()
1703 {
1704     size_t size = m_customFonts.size();
1705     for (size_t i = 0; i < size; ++i)
1706         GlyphPageTreeNode::pruneTreeCustomFontData(m_customFonts[i].get());
1707
1708     m_customFonts.clear();
1709 }
1710
1711 bool Document::isPageBoxVisible(int pageIndex)
1712 {
1713     RefPtr<RenderStyle> style = styleForPage(pageIndex);
1714     return style->visibility() != HIDDEN; // display property doesn't apply to @page.
1715 }
1716
1717 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
1718 {
1719     RefPtr<RenderStyle> style = styleForPage(pageIndex);
1720
1721     int width = pageSize.width();
1722     int height = pageSize.height();
1723     switch (style->pageSizeType()) {
1724     case PAGE_SIZE_AUTO:
1725         break;
1726     case PAGE_SIZE_AUTO_LANDSCAPE:
1727         if (width < height)
1728             std::swap(width, height);
1729         break;
1730     case PAGE_SIZE_AUTO_PORTRAIT:
1731         if (width > height)
1732             std::swap(width, height);
1733         break;
1734     case PAGE_SIZE_RESOLVED: {
1735         LengthSize size = style->pageSize();
1736         ASSERT(size.width().isFixed());
1737         ASSERT(size.height().isFixed());
1738         width = size.width().calcValue(0);
1739         height = size.height().calcValue(0);
1740         break;
1741     }
1742     default:
1743         ASSERT_NOT_REACHED();
1744     }
1745     pageSize = IntSize(width, height);
1746
1747     // The percentage is calculated with respect to the width even for margin top and bottom.
1748     // http://www.w3.org/TR/CSS2/box.html#margin-properties
1749     marginTop = style->marginTop().isAuto() ? marginTop : style->marginTop().calcValue(width);
1750     marginRight = style->marginRight().isAuto() ? marginRight : style->marginRight().calcValue(width);
1751     marginBottom = style->marginBottom().isAuto() ? marginBottom : style->marginBottom().calcValue(width);
1752     marginLeft = style->marginLeft().isAuto() ? marginLeft : style->marginLeft().calcValue(width);
1753 }
1754
1755 PassRefPtr<CSSValuePool> Document::cssValuePool() const
1756 {
1757     if (!m_cssValuePool)
1758         m_cssValuePool = CSSValuePool::create();
1759     return m_cssValuePool;
1760 }
1761
1762 void Document::setIsViewSource(bool isViewSource)
1763 {
1764     m_isViewSource = isViewSource;
1765     if (!m_isViewSource)
1766         return;
1767
1768     setSecurityOrigin(SecurityOrigin::createUnique());
1769 }
1770
1771 void Document::createStyleSelector()
1772 {
1773     bool matchAuthorAndUserStyles = true;
1774     if (Settings* docSettings = settings())
1775         matchAuthorAndUserStyles = docSettings->authorAndUserStylesEnabled();
1776     m_styleSelector = adoptPtr(new CSSStyleSelector(this, m_styleSheets.get(), m_mappedElementSheet.get(), pageUserSheet(), pageGroupUserSheets(), m_userSheets.get(),
1777                                                     !inQuirksMode(), matchAuthorAndUserStyles));
1778     // Delay resetting the flags until after next style recalc since unapplying the style may not work without these set (this is true at least with before/after).
1779     m_usesSiblingRules = m_usesSiblingRules || m_styleSelector->usesSiblingRules();
1780     m_usesFirstLineRules = m_usesFirstLineRules || m_styleSelector->usesFirstLineRules();
1781     m_usesBeforeAfterRules = m_usesBeforeAfterRules || m_styleSelector->usesBeforeAfterRules();
1782     m_usesLinkRules = m_usesLinkRules || m_styleSelector->usesLinkRules();
1783 }
1784
1785 void Document::attach()
1786 {
1787     ASSERT(!attached());
1788     ASSERT(!m_inPageCache);
1789     ASSERT(!m_axObjectCache || this != topDocument());
1790
1791     if (!m_renderArena)
1792         m_renderArena = adoptPtr(new RenderArena);
1793     
1794     // Create the rendering tree
1795     setRenderer(new (m_renderArena.get()) RenderView(this, view()));
1796 #if USE(ACCELERATED_COMPOSITING)
1797     renderView()->didMoveOnscreen();
1798 #endif
1799
1800     recalcStyle(Force);
1801
1802     RenderObject* render = renderer();
1803     setRenderer(0);
1804
1805     TreeScope::attach();
1806
1807     setRenderer(render);
1808 }
1809
1810 void Document::detach()
1811 {
1812     ASSERT(attached());
1813     ASSERT(!m_inPageCache);
1814
1815     if (this == topDocument())
1816         clearAXObjectCache();
1817
1818     stopActiveDOMObjects();
1819     m_eventQueue->close();
1820 #if ENABLE(FULLSCREEN_API)
1821     m_fullScreenChangeEventTargetQueue.clear();
1822 #endif
1823
1824 #if ENABLE(REQUEST_ANIMATION_FRAME)
1825     // FIXME: consider using ActiveDOMObject.
1826     m_scriptedAnimationController = nullptr;
1827 #endif
1828
1829     RenderObject* render = renderer();
1830
1831     // Send out documentWillBecomeInactive() notifications to registered elements,
1832     // in order to stop media elements
1833     documentWillBecomeInactive();
1834
1835 #if ENABLE(SHARED_WORKERS)
1836     SharedWorkerRepository::documentDetached(this);
1837 #endif
1838
1839     if (m_frame) {
1840         FrameView* view = m_frame->view();
1841         if (view)
1842             view->detachCustomScrollbars();
1843
1844     }
1845
1846     // indicate destruction mode,  i.e. attached() but renderer == 0
1847     setRenderer(0);
1848     
1849 #if ENABLE(FULLSCREEN_API)
1850     if (m_fullScreenRenderer)
1851         setFullScreenRenderer(0);
1852 #endif
1853
1854     m_hoverNode = 0;
1855     m_focusedNode = 0;
1856     m_activeNode = 0;
1857
1858     TreeScope::detach();
1859
1860     unscheduleStyleRecalc();
1861
1862     if (render)
1863         render->destroy();
1864     
1865     // This is required, as our Frame might delete itself as soon as it detaches
1866     // us. However, this violates Node::detach() semantics, as it's never
1867     // possible to re-attach. Eventually Document::detach() should be renamed,
1868     // or this setting of the frame to 0 could be made explicit in each of the
1869     // callers of Document::detach().
1870     m_frame = 0;
1871     m_renderArena.clear();
1872 }
1873
1874 void Document::removeAllEventListeners()
1875 {
1876     EventTarget::removeAllEventListeners();
1877
1878     if (DOMWindow* domWindow = this->domWindow())
1879         domWindow->removeAllEventListeners();
1880     for (Node* node = firstChild(); node; node = node->traverseNextNode())
1881         node->removeAllEventListeners();
1882 }
1883
1884 void Document::suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
1885 {
1886     ScriptExecutionContext::suspendActiveDOMObjects(why);
1887
1888 #if ENABLE(DEVICE_ORIENTATION)
1889     if (!page())
1890         return;
1891
1892     if (page()->deviceMotionController())
1893         page()->deviceMotionController()->suspendEventsForAllListeners(domWindow());
1894     if (page()->deviceOrientationController())
1895         page()->deviceOrientationController()->suspendEventsForAllListeners(domWindow());
1896 #endif
1897 }
1898
1899 void Document::resumeActiveDOMObjects()
1900 {
1901     ScriptExecutionContext::resumeActiveDOMObjects();
1902
1903 #if ENABLE(DEVICE_ORIENTATION)
1904     if (!page())
1905         return;
1906
1907     if (page()->deviceMotionController())
1908         page()->deviceMotionController()->resumeEventsForAllListeners(domWindow());
1909     if (page()->deviceOrientationController())
1910         page()->deviceOrientationController()->resumeEventsForAllListeners(domWindow());
1911 #endif
1912 }
1913
1914 RenderView* Document::renderView() const
1915 {
1916     return toRenderView(renderer());
1917 }
1918
1919 void Document::clearAXObjectCache()
1920 {
1921     // clear cache in top document
1922     if (m_axObjectCache) {
1923         // Clear the cache member variable before calling delete because attempts
1924         // are made to access it during destruction.
1925         AXObjectCache* axObjectCache = m_axObjectCache;
1926         m_axObjectCache = 0;
1927         delete axObjectCache;
1928         return;
1929     }
1930     
1931     // ask the top-level document to clear its cache
1932     Document* doc = topDocument();
1933     if (doc != this)
1934         doc->clearAXObjectCache();
1935 }
1936
1937 bool Document::axObjectCacheExists() const
1938 {
1939     if (m_axObjectCache)
1940         return true;
1941     
1942     Document* doc = topDocument();
1943     if (doc != this)
1944         return doc->axObjectCacheExists();
1945     
1946     return false;
1947 }
1948     
1949 AXObjectCache* Document::axObjectCache() const
1950 {
1951     // The only document that actually has a AXObjectCache is the top-level
1952     // document.  This is because we need to be able to get from any WebCoreAXObject
1953     // to any other WebCoreAXObject on the same page.  Using a single cache allows
1954     // lookups across nested webareas (i.e. multiple documents).
1955     
1956     if (m_axObjectCache) {
1957         // return already known top-level cache
1958         if (!ownerElement())
1959             return m_axObjectCache;
1960         
1961         // In some pages with frames, the cache is created before the sub-webarea is
1962         // inserted into the tree.  Here, we catch that case and just toss the old
1963         // cache and start over.
1964         // NOTE: This recovery may no longer be needed. I have been unable to trigger
1965         // it again. See rdar://5794454
1966         // FIXME: Can this be fixed when inserting the subframe instead of now?
1967         // FIXME: If this function was called to get the cache in order to remove
1968         // an AXObject, we are now deleting the cache as a whole and returning a
1969         // new empty cache that does not contain the AXObject! That should actually
1970         // be OK. I am concerned about other cases like this where accessing the
1971         // cache blows away the AXObject being operated on.
1972         delete m_axObjectCache;
1973         m_axObjectCache = 0;
1974     }
1975
1976     // ask the top-level document for its cache
1977     Document* doc = topDocument();
1978     if (doc != this)
1979         return doc->axObjectCache();
1980     
1981     // this is the top-level document, so install a new cache
1982     m_axObjectCache = new AXObjectCache(this);
1983     return m_axObjectCache;
1984 }
1985
1986 void Document::setVisuallyOrdered()
1987 {
1988     m_visuallyOrdered = true;
1989     if (renderer())
1990         renderer()->style()->setRTLOrdering(VisualOrder);
1991 }
1992
1993 PassRefPtr<DocumentParser> Document::createParser()
1994 {
1995     // FIXME: this should probably pass the frame instead
1996 #if ENABLE(NEW_XML)
1997     return NewXMLDocumentParser::create(this);
1998 #else
1999     return XMLDocumentParser::create(this, view());
2000 #endif
2001 }
2002
2003 ScriptableDocumentParser* Document::scriptableDocumentParser() const
2004 {
2005     return parser() ? parser()->asScriptableDocumentParser() : 0;
2006 }
2007
2008 void Document::open(Document* ownerDocument)
2009 {
2010     if (ownerDocument) {
2011         setURL(ownerDocument->url());
2012         m_cookieURL = ownerDocument->cookieURL();
2013         setSecurityOrigin(ownerDocument->securityOrigin());
2014     }
2015
2016     if (m_frame) {
2017         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
2018             if (parser->isParsing()) {
2019                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
2020                 if (parser->isExecutingScript())
2021                     return;
2022
2023                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
2024                     return;
2025             }
2026         }
2027
2028         if (m_frame->loader()->state() == FrameStateProvisional)
2029             m_frame->loader()->stopAllLoaders();
2030     }
2031
2032     removeAllEventListeners();
2033     implicitOpen();
2034     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2035         parser->setWasCreatedByScript(true);
2036
2037     if (DOMWindow* domWindow = this->domWindow())
2038         domWindow->removeAllEventListeners();
2039
2040     if (m_frame)
2041         m_frame->loader()->didExplicitOpen();
2042 }
2043
2044 void Document::detachParser()
2045 {
2046     if (!m_parser)
2047         return;
2048     m_parser->detach();
2049     m_parser.clear();
2050 }
2051
2052 void Document::cancelParsing()
2053 {
2054     if (!m_parser)
2055         return;
2056
2057     // We have to clear the parser to avoid possibly triggering
2058     // the onload handler when closing as a side effect of a cancel-style
2059     // change, such as opening a new document or closing the window while
2060     // still parsing
2061     detachParser();
2062     explicitClose();
2063 }
2064
2065 void Document::implicitOpen()
2066 {
2067     cancelParsing();
2068
2069     removeChildren();
2070
2071     setCompatibilityMode(NoQuirksMode);
2072
2073     m_parser = createParser();
2074     setParsing(true);
2075     setReadyState(Loading);
2076
2077     // If we reload, the animation controller sticks around and has
2078     // a stale animation time. We need to update it here.
2079     if (m_frame && m_frame->animation())
2080         m_frame->animation()->beginAnimationUpdate();
2081 }
2082
2083 HTMLElement* Document::body() const
2084 {
2085     Node* de = documentElement();
2086     if (!de)
2087         return 0;
2088     
2089     // try to prefer a FRAMESET element over BODY
2090     Node* body = 0;
2091     for (Node* i = de->firstChild(); i; i = i->nextSibling()) {
2092         if (i->hasTagName(framesetTag))
2093             return toHTMLElement(i);
2094         
2095         if (i->hasTagName(bodyTag) && !body)
2096             body = i;
2097     }
2098     return toHTMLElement(body);
2099 }
2100
2101 void Document::setBody(PassRefPtr<HTMLElement> prpNewBody, ExceptionCode& ec)
2102 {
2103     RefPtr<HTMLElement> newBody = prpNewBody;
2104
2105     if (!newBody || !documentElement() || !newBody->hasTagName(bodyTag)) { 
2106         ec = HIERARCHY_REQUEST_ERR;
2107         return;
2108     }
2109
2110     if (newBody->document() && newBody->document() != this) {
2111         ec = 0;
2112         RefPtr<Node> node = importNode(newBody.get(), true, ec);
2113         if (ec)
2114             return;
2115         
2116         newBody = toHTMLElement(node.get());
2117     }
2118
2119     HTMLElement* b = body();
2120     if (!b)
2121         documentElement()->appendChild(newBody.release(), ec);
2122     else
2123         documentElement()->replaceChild(newBody.release(), b, ec);
2124 }
2125
2126 HTMLHeadElement* Document::head()
2127 {
2128     Node* de = documentElement();
2129     if (!de)
2130         return 0;
2131
2132     for (Node* e = de->firstChild(); e; e = e->nextSibling())
2133         if (e->hasTagName(headTag))
2134             return static_cast<HTMLHeadElement*>(e);
2135
2136     return 0;
2137 }
2138
2139 void Document::close()
2140 {
2141     // FIXME: We should follow the specification more closely:
2142     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
2143
2144     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
2145         return;
2146
2147     explicitClose();
2148 }
2149
2150 void Document::explicitClose()
2151 {
2152     if (m_parser)
2153         m_parser->finish();
2154
2155     if (!m_frame) {
2156         // Because we have no frame, we don't know if all loading has completed,
2157         // so we just call implicitClose() immediately. FIXME: This might fire
2158         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
2159         implicitClose();
2160         return;
2161     }
2162
2163     m_frame->loader()->checkCompleted();
2164 }
2165
2166 void Document::implicitClose()
2167 {
2168     // If we're in the middle of recalcStyle, we need to defer the close until the style information is accurate and all elements are re-attached.
2169     if (m_inStyleRecalc) {
2170         m_closeAfterStyleRecalc = true;
2171         return;
2172     }
2173
2174     bool wasLocationChangePending = frame() && frame()->navigationScheduler()->locationChangePending();
2175     bool doload = !parsing() && m_parser && !m_processingLoadEvent && !wasLocationChangePending;
2176     
2177     if (!doload)
2178         return;
2179
2180     m_processingLoadEvent = true;
2181
2182     ScriptableDocumentParser* parser = scriptableDocumentParser();
2183     m_wellFormed = parser && parser->wellFormed();
2184
2185     // We have to clear the parser, in case someone document.write()s from the
2186     // onLoad event handler, as in Radar 3206524.
2187     detachParser();
2188
2189     // Parser should have picked up all preloads by now
2190     m_cachedResourceLoader->clearPreloads();
2191
2192     // FIXME: We kick off the icon loader when the Document is done parsing.
2193     // There are earlier opportunities we could start it:
2194     //  -When the <head> finishes parsing
2195     //  -When any new HTMLLinkElement is inserted into the document
2196     // But those add a dynamic component to the favicon that has UI 
2197     // ramifications, and we need to decide what is the Right Thing To Do(tm)
2198     Frame* f = frame();
2199     if (f) {
2200         f->loader()->icon()->startLoader();
2201         f->animation()->resumeAnimationsForDocument(this);
2202     }
2203
2204     ImageLoader::dispatchPendingBeforeLoadEvents();
2205     ImageLoader::dispatchPendingLoadEvents();
2206     dispatchWindowLoadEvent();
2207     enqueuePageshowEvent(PageshowEventNotPersisted);
2208     enqueuePopstateEvent(m_pendingStateObject ? m_pendingStateObject.release() : SerializedScriptValue::nullValue());
2209     
2210     if (f)
2211         f->loader()->handledOnloadEvents();
2212 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2213     if (!ownerElement())
2214         printf("onload fired at %d\n", elapsedTime());
2215 #endif
2216
2217     m_processingLoadEvent = false;
2218
2219     // An event handler may have removed the frame
2220     if (!frame())
2221         return;
2222
2223     // Make sure both the initial layout and reflow happen after the onload
2224     // fires. This will improve onload scores, and other browsers do it.
2225     // If they wanna cheat, we can too. -dwh
2226
2227     if (frame()->navigationScheduler()->locationChangePending() && elapsedTime() < cLayoutScheduleThreshold) {
2228         // Just bail out. Before or during the onload we were shifted to another page.
2229         // The old i-Bench suite does this. When this happens don't bother painting or laying out.        
2230         view()->unscheduleRelayout();
2231         return;
2232     }
2233
2234     frame()->loader()->checkCallImplicitClose();
2235     RenderObject* renderObject = renderer();
2236     
2237     // We used to force a synchronous display and flush here.  This really isn't
2238     // necessary and can in fact be actively harmful if pages are loading at a rate of > 60fps
2239     // (if your platform is syncing flushes and limiting them to 60fps).
2240     m_overMinimumLayoutThreshold = true;
2241     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
2242         updateStyleIfNeeded();
2243         
2244         // Always do a layout after loading if needed.
2245         if (view() && renderObject && (!renderObject->firstChild() || renderObject->needsLayout()))
2246             view()->layout();
2247     }
2248
2249     // If painting and compositing layer updates were suppressed pending the load event, do these actions now.
2250     if (renderer() && settings() && settings()->suppressIncrementalRendering()) {
2251 #if USE(ACCELERATED_COMPOSITING)
2252         view()->updateCompositingLayers();
2253 #endif
2254         renderer()->repaint();
2255     }
2256
2257 #if PLATFORM(MAC) || PLATFORM(CHROMIUM)
2258     if (f && renderObject && AXObjectCache::accessibilityEnabled()) {
2259         // The AX cache may have been cleared at this point, but we need to make sure it contains an
2260         // AX object to send the notification to. getOrCreate will make sure that an valid AX object
2261         // exists in the cache (we ignore the return value because we don't need it here). This is 
2262         // only safe to call when a layout is not in progress, so it can not be used in postNotification.    
2263         axObjectCache()->getOrCreate(renderObject);
2264         if (this == topDocument())
2265             axObjectCache()->postNotification(renderObject, AXObjectCache::AXLoadComplete, true);
2266         else {
2267             // AXLoadComplete can only be posted on the top document, so if it's a document
2268             // in an iframe that just finished loading, post a notification on the iframe
2269             // element instead.
2270             ScrollView* scrollView = frame()->view();
2271             if (scrollView && scrollView->isFrameView()) {
2272                 HTMLFrameOwnerElement* owner = static_cast<FrameView*>(scrollView)->frame()->ownerElement();
2273                 if (owner && owner->renderer()) {
2274                     AccessibilityObject* axIFrame = axObjectCache()->getOrCreate(owner->renderer());
2275                     axObjectCache()->postNotification(axIFrame, axIFrame->document(), AXObjectCache::AXLayoutComplete, true);
2276                 }
2277             }
2278         }
2279     }
2280 #endif
2281
2282 #if ENABLE(SVG)
2283     // FIXME: Officially, time 0 is when the outermost <svg> receives its
2284     // SVGLoad event, but we don't implement those yet.  This is close enough
2285     // for now.  In some cases we should have fired earlier.
2286     if (svgExtensions())
2287         accessSVGExtensions()->startAnimations();
2288 #endif
2289 }
2290
2291 void Document::setParsing(bool b)
2292 {
2293     m_bParsing = b;
2294     if (!m_bParsing && view())
2295         view()->scheduleRelayout();
2296
2297 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2298     if (!ownerElement() && !m_bParsing)
2299         printf("Parsing finished at %d\n", elapsedTime());
2300 #endif
2301 }
2302
2303 bool Document::shouldScheduleLayout()
2304 {
2305     // This function will only be called when FrameView thinks a layout is needed.
2306     // This enforces a couple extra rules.
2307     //
2308     //    (a) Only schedule a layout once the stylesheets are loaded.
2309     //    (b) Only schedule layout once we have a body element.
2310
2311     return (haveStylesheetsLoaded() && body())
2312         || (documentElement() && !documentElement()->hasTagName(htmlTag));
2313 }
2314     
2315 bool Document::isLayoutTimerActive()
2316 {
2317     return view() && view()->layoutPending() && !minimumLayoutDelay();
2318 }
2319
2320 int Document::minimumLayoutDelay()
2321 {
2322     if (m_overMinimumLayoutThreshold)
2323         return 0;
2324     
2325     int elapsed = elapsedTime();
2326     m_overMinimumLayoutThreshold = elapsed > cLayoutScheduleThreshold;
2327     
2328     // We'll want to schedule the timer to fire at the minimum layout threshold.
2329     return max(0, cLayoutScheduleThreshold - elapsed);
2330 }
2331
2332 int Document::elapsedTime() const
2333 {
2334     return static_cast<int>((currentTime() - m_startTime) * 1000);
2335 }
2336
2337 void Document::write(const SegmentedString& text, Document* ownerDocument)
2338 {
2339     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
2340
2341     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
2342     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
2343
2344     if (m_writeRecursionIsTooDeep)
2345        return;
2346
2347 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2348     if (!ownerElement())
2349         printf("Beginning a document.write at %d\n", elapsedTime());
2350 #endif
2351
2352     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
2353     if (!hasInsertionPoint && m_ignoreDestructiveWriteCount)
2354         return;
2355
2356     if (!hasInsertionPoint)
2357         open(ownerDocument);
2358
2359     ASSERT(m_parser);
2360     m_parser->insert(text);
2361
2362 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2363     if (!ownerElement())
2364         printf("Ending a document.write at %d\n", elapsedTime());
2365 #endif    
2366 }
2367
2368 void Document::write(const String& text, Document* ownerDocument)
2369 {
2370     write(SegmentedString(text), ownerDocument);
2371 }
2372
2373 void Document::writeln(const String& text, Document* ownerDocument)
2374 {
2375     write(text, ownerDocument);
2376     write("\n", ownerDocument);
2377 }
2378
2379 const KURL& Document::virtualURL() const
2380 {
2381     return m_url;
2382 }
2383
2384 KURL Document::virtualCompleteURL(const String& url) const
2385 {
2386     return completeURL(url);
2387 }
2388
2389 double Document::minimumTimerInterval() const
2390 {
2391     Page* p = page();
2392     if (!p)
2393         return ScriptExecutionContext::minimumTimerInterval();
2394     return p->settings()->minDOMTimerInterval();
2395 }
2396
2397 EventTarget* Document::errorEventTarget()
2398 {
2399     return domWindow();
2400 }
2401
2402 void Document::logExceptionToConsole(const String& errorMessage, int lineNumber, const String& sourceURL, PassRefPtr<ScriptCallStack> callStack)
2403 {
2404     addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, errorMessage, lineNumber, sourceURL, callStack);
2405 }
2406
2407 void Document::setURL(const KURL& url)
2408 {
2409     const KURL& newURL = url.isEmpty() ? blankURL() : url;
2410     if (newURL == m_url)
2411         return;
2412
2413     m_url = newURL;
2414     m_documentURI = m_url.string();
2415     updateBaseURL();
2416 }
2417
2418 void Document::updateBaseURL()
2419 {
2420     // DOM 3 Core: When the Document supports the feature "HTML" [DOM Level 2 HTML], the base URI is computed using
2421     // first the value of the href attribute of the HTML BASE element if any, and the value of the documentURI attribute
2422     // from the Document interface otherwise.
2423     if (!m_baseElementURL.isEmpty())
2424         m_baseURL = m_baseElementURL;
2425     else if (!m_baseURLOverride.isEmpty())
2426         m_baseURL = m_baseURLOverride;
2427     else {
2428         // The documentURI attribute is an arbitrary string. DOM 3 Core does not specify how it should be resolved,
2429         // so we use a null base URL.
2430         m_baseURL = KURL(KURL(), documentURI());
2431     }
2432
2433     if (!m_baseURL.isValid())
2434         m_baseURL = KURL();
2435
2436     if (m_elemSheet)
2437         m_elemSheet->setFinalURL(m_baseURL);
2438     if (m_mappedElementSheet)
2439         m_mappedElementSheet->setFinalURL(m_baseURL);
2440 }
2441
2442 void Document::setBaseURLOverride(const KURL& url)
2443 {
2444     m_baseURLOverride = url;
2445     updateBaseURL();
2446 }
2447
2448 void Document::processBaseElement()
2449 {
2450     // Find the first href attribute in a base element and the first target attribute in a base element.
2451     const AtomicString* href = 0;
2452     const AtomicString* target = 0;
2453     for (Node* node = document()->firstChild(); node && (!href || !target); node = node->traverseNextNode()) {
2454         if (node->hasTagName(baseTag)) {
2455             if (!href) {
2456                 const AtomicString& value = static_cast<Element*>(node)->fastGetAttribute(hrefAttr);
2457                 if (!value.isNull())
2458                     href = &value;
2459             }
2460             if (!target) {
2461                 const AtomicString& value = static_cast<Element*>(node)->fastGetAttribute(targetAttr);
2462                 if (!value.isNull())
2463                     target = &value;
2464             }
2465         }
2466     }
2467
2468     // FIXME: Since this doesn't share code with completeURL it may not handle encodings correctly.
2469     KURL baseElementURL;
2470     if (href) {
2471         String strippedHref = stripLeadingAndTrailingHTMLSpaces(*href);
2472         if (!strippedHref.isEmpty())
2473             baseElementURL = KURL(url(), strippedHref);
2474     }
2475     if (m_baseElementURL != baseElementURL) {
2476         m_baseElementURL = baseElementURL;
2477         updateBaseURL();
2478     }
2479
2480     m_baseTarget = target ? *target : nullAtom;
2481 }
2482
2483 String Document::userAgent(const KURL& url) const
2484 {
2485     return frame() ? frame()->loader()->userAgent(url) : String();
2486 }
2487
2488 void Document::disableEval()
2489 {
2490     if (!frame())
2491         return;
2492
2493     frame()->script()->disableEval();
2494 }
2495
2496 CSSStyleSheet* Document::pageUserSheet()
2497 {
2498     if (m_pageUserSheet)
2499         return m_pageUserSheet.get();
2500     
2501     Page* owningPage = page();
2502     if (!owningPage)
2503         return 0;
2504     
2505     String userSheetText = owningPage->userStyleSheet();
2506     if (userSheetText.isEmpty())
2507         return 0;
2508     
2509     // Parse the sheet and cache it.
2510     m_pageUserSheet = CSSStyleSheet::createInline(this, settings()->userStyleSheetLocation());
2511     m_pageUserSheet->setIsUserStyleSheet(true);
2512     m_pageUserSheet->parseString(userSheetText, !inQuirksMode());
2513     return m_pageUserSheet.get();
2514 }
2515
2516 void Document::clearPageUserSheet()
2517 {
2518     if (m_pageUserSheet) {
2519         m_pageUserSheet = 0;
2520         styleSelectorChanged(DeferRecalcStyle);
2521     }
2522 }
2523
2524 void Document::updatePageUserSheet()
2525 {
2526     clearPageUserSheet();
2527     if (pageUserSheet())
2528         styleSelectorChanged(RecalcStyleImmediately);
2529 }
2530
2531 const Vector<RefPtr<CSSStyleSheet> >* Document::pageGroupUserSheets() const
2532 {
2533     if (m_pageGroupUserSheetCacheValid)
2534         return m_pageGroupUserSheets.get();
2535     
2536     m_pageGroupUserSheetCacheValid = true;
2537     
2538     Page* owningPage = page();
2539     if (!owningPage)
2540         return 0;
2541         
2542     const PageGroup& pageGroup = owningPage->group();
2543     const UserStyleSheetMap* sheetsMap = pageGroup.userStyleSheets();
2544     if (!sheetsMap)
2545         return 0;
2546
2547     UserStyleSheetMap::const_iterator end = sheetsMap->end();
2548     for (UserStyleSheetMap::const_iterator it = sheetsMap->begin(); it != end; ++it) {
2549         const UserStyleSheetVector* sheets = it->second;
2550         for (unsigned i = 0; i < sheets->size(); ++i) {
2551             const UserStyleSheet* sheet = sheets->at(i).get();
2552             if (sheet->injectedFrames() == InjectInTopFrameOnly && ownerElement())
2553                 continue;
2554             if (!UserContentURLPattern::matchesPatterns(url(), sheet->whitelist(), sheet->blacklist()))
2555                 continue;
2556             RefPtr<CSSStyleSheet> parsedSheet = CSSStyleSheet::createInline(const_cast<Document*>(this), sheet->url());
2557             parsedSheet->setIsUserStyleSheet(sheet->level() == UserStyleUserLevel);
2558             parsedSheet->parseString(sheet->source(), !inQuirksMode());
2559             if (!m_pageGroupUserSheets)
2560                 m_pageGroupUserSheets = adoptPtr(new Vector<RefPtr<CSSStyleSheet> >);
2561             m_pageGroupUserSheets->append(parsedSheet.release());
2562         }
2563     }
2564
2565     return m_pageGroupUserSheets.get();
2566 }
2567
2568 void Document::clearPageGroupUserSheets()
2569 {
2570     m_pageGroupUserSheetCacheValid = false;
2571     if (m_pageGroupUserSheets && m_pageGroupUserSheets->size()) {
2572         m_pageGroupUserSheets->clear();
2573         styleSelectorChanged(DeferRecalcStyle);
2574     }
2575 }
2576
2577 void Document::updatePageGroupUserSheets()
2578 {
2579     clearPageGroupUserSheets();
2580     if (pageGroupUserSheets() && pageGroupUserSheets()->size())
2581         styleSelectorChanged(RecalcStyleImmediately);
2582 }
2583
2584 void Document::addUserSheet(PassRefPtr<CSSStyleSheet> userSheet)
2585 {
2586     if (!m_userSheets)
2587         m_userSheets = adoptPtr(new Vector<RefPtr<CSSStyleSheet> >);
2588     m_userSheets->append(userSheet);
2589     styleSelectorChanged(RecalcStyleImmediately);
2590 }
2591
2592 CSSStyleSheet* Document::elementSheet()
2593 {
2594     if (!m_elemSheet)
2595         m_elemSheet = CSSStyleSheet::createInline(this, m_baseURL);
2596     return m_elemSheet.get();
2597 }
2598
2599 CSSStyleSheet* Document::mappedElementSheet()
2600 {
2601     if (!m_mappedElementSheet)
2602         m_mappedElementSheet = CSSStyleSheet::createInline(this, m_baseURL);
2603     return m_mappedElementSheet.get();
2604 }
2605
2606 int Document::nodeAbsIndex(Node *node)
2607 {
2608     ASSERT(node->document() == this);
2609
2610     int absIndex = 0;
2611     for (Node* n = node; n && n != this; n = n->traversePreviousNode())
2612         absIndex++;
2613     return absIndex;
2614 }
2615
2616 Node* Document::nodeWithAbsIndex(int absIndex)
2617 {
2618     Node* n = this;
2619     for (int i = 0; n && (i < absIndex); i++)
2620         n = n->traverseNextNode();
2621     return n;
2622 }
2623
2624 void Document::processHttpEquiv(const String& equiv, const String& content)
2625 {
2626     ASSERT(!equiv.isNull() && !content.isNull());
2627
2628     Frame* frame = this->frame();
2629
2630     if (equalIgnoringCase(equiv, "default-style")) {
2631         // The preferred style set has been overridden as per section 
2632         // 14.3.2 of the HTML4.0 specification.  We need to update the
2633         // sheet used variable and then update our style selector. 
2634         // For more info, see the test at:
2635         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
2636         // -dwh
2637         m_selectedStylesheetSet = content;
2638         m_preferredStylesheetSet = content;
2639         styleSelectorChanged(DeferRecalcStyle);
2640     } else if (equalIgnoringCase(equiv, "refresh")) {
2641         double delay;
2642         String url;
2643         if (frame && parseHTTPRefresh(content, true, delay, url)) {
2644             if (url.isEmpty())
2645                 url = m_url.string();
2646             else
2647                 url = completeURL(url).string();
2648             frame->navigationScheduler()->scheduleRedirect(delay, url);
2649         }
2650     } else if (equalIgnoringCase(equiv, "set-cookie")) {
2651         // FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
2652         if (isHTMLDocument()) {
2653             ExceptionCode ec; // Exception (for sandboxed documents) ignored.
2654             static_cast<HTMLDocument*>(this)->setCookie(content, ec);
2655         }
2656     } else if (equalIgnoringCase(equiv, "content-language"))
2657         setContentLanguage(content);
2658     else if (equalIgnoringCase(equiv, "x-dns-prefetch-control"))
2659         parseDNSPrefetchControlHeader(content);
2660     else if (equalIgnoringCase(equiv, "x-frame-options")) {
2661         if (frame) {
2662             FrameLoader* frameLoader = frame->loader();
2663             if (frameLoader->shouldInterruptLoadForXFrameOptions(content, url())) {
2664                 frameLoader->stopAllLoaders();
2665                 frame->navigationScheduler()->scheduleLocationChange(securityOrigin(), blankURL(), String());
2666
2667                 DEFINE_STATIC_LOCAL(String, consoleMessage, ("Refused to display document because display forbidden by X-Frame-Options.\n"));
2668                 addConsoleMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, consoleMessage);
2669             }
2670         }
2671     } else if (equalIgnoringCase(equiv, "x-webkit-csp"))
2672         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::EnforcePolicy);
2673     else if (equalIgnoringCase(equiv, "x-webkit-csp-report-only"))
2674         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::ReportOnly);
2675 }
2676
2677 // Though isspace() considers \t and \v to be whitespace, Win IE doesn't.
2678 static bool isSeparator(UChar c)
2679 {
2680     return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '=' || c == ',' || c == '\0';
2681 }
2682
2683 void Document::processArguments(const String& features, void* data, ArgumentsCallback callback)
2684 {
2685     // Tread lightly in this code -- it was specifically designed to mimic Win IE's parsing behavior.
2686     int keyBegin, keyEnd;
2687     int valueBegin, valueEnd;
2688
2689     int i = 0;
2690     int length = features.length();
2691     String buffer = features.lower();
2692     while (i < length) {
2693         // skip to first non-separator, but don't skip past the end of the string
2694         while (isSeparator(buffer[i])) {
2695             if (i >= length)
2696                 break;
2697             i++;
2698         }
2699         keyBegin = i;
2700
2701         // skip to first separator
2702         while (!isSeparator(buffer[i]))
2703             i++;
2704         keyEnd = i;
2705
2706         // skip to first '=', but don't skip past a ',' or the end of the string
2707         while (buffer[i] != '=') {
2708             if (buffer[i] == ',' || i >= length)
2709                 break;
2710             i++;
2711         }
2712
2713         // skip to first non-separator, but don't skip past a ',' or the end of the string
2714         while (isSeparator(buffer[i])) {
2715             if (buffer[i] == ',' || i >= length)
2716                 break;
2717             i++;
2718         }
2719         valueBegin = i;
2720
2721         // skip to first separator
2722         while (!isSeparator(buffer[i]))
2723             i++;
2724         valueEnd = i;
2725
2726         ASSERT(i <= length);
2727
2728         String keyString = buffer.substring(keyBegin, keyEnd - keyBegin);
2729         String valueString = buffer.substring(valueBegin, valueEnd - valueBegin);
2730         callback(keyString, valueString, this, data);
2731     }
2732 }
2733
2734 void Document::processViewport(const String& features)
2735 {
2736     ASSERT(!features.isNull());
2737
2738     m_viewportArguments = ViewportArguments(ViewportArguments::ViewportMeta);
2739     processArguments(features, (void*)&m_viewportArguments, &setViewportFeature);
2740
2741     Frame* frame = this->frame();
2742     if (!frame || !frame->page())
2743         return;
2744
2745     frame->page()->updateViewportArguments();
2746 }
2747
2748 void Document::processReferrerPolicy(const String& policy)
2749 {
2750     ASSERT(!policy.isNull());
2751
2752     m_referrerPolicy = SecurityPolicy::ReferrerPolicyDefault;
2753
2754     if (equalIgnoringCase(policy, "never"))
2755         m_referrerPolicy = SecurityPolicy::ReferrerPolicyNever;
2756     else if (equalIgnoringCase(policy, "always"))
2757         m_referrerPolicy = SecurityPolicy::ReferrerPolicyAlways;
2758     else if (equalIgnoringCase(policy, "origin"))
2759         m_referrerPolicy = SecurityPolicy::ReferrerPolicyOrigin;
2760 }
2761
2762 MouseEventWithHitTestResults Document::prepareMouseEvent(const HitTestRequest& request, const LayoutPoint& documentPoint, const PlatformMouseEvent& event)
2763 {
2764     ASSERT(!renderer() || renderer()->isRenderView());
2765
2766     if (!renderer())
2767         return MouseEventWithHitTestResults(event, HitTestResult(LayoutPoint()));
2768
2769     HitTestResult result(documentPoint);
2770     renderView()->layer()->hitTest(request, result);
2771
2772     if (!request.readOnly())
2773         updateStyleIfNeeded();
2774
2775     return MouseEventWithHitTestResults(event, result);
2776 }
2777
2778 // DOM Section 1.1.1
2779 bool Document::childTypeAllowed(NodeType type) const
2780 {
2781     switch (type) {
2782     case ATTRIBUTE_NODE:
2783     case CDATA_SECTION_NODE:
2784     case DOCUMENT_FRAGMENT_NODE:
2785     case DOCUMENT_NODE:
2786     case ENTITY_NODE:
2787     case ENTITY_REFERENCE_NODE:
2788     case NOTATION_NODE:
2789     case TEXT_NODE:
2790     case XPATH_NAMESPACE_NODE:
2791     case SHADOW_ROOT_NODE:
2792         return false;
2793     case COMMENT_NODE:
2794     case PROCESSING_INSTRUCTION_NODE:
2795         return true;
2796     case DOCUMENT_TYPE_NODE:
2797     case ELEMENT_NODE:
2798         // Documents may contain no more than one of each of these.
2799         // (One Element and one DocumentType.)
2800         for (Node* c = firstChild(); c; c = c->nextSibling())
2801             if (c->nodeType() == type)
2802                 return false;
2803         return true;
2804     }
2805     return false;
2806 }
2807
2808 bool Document::canReplaceChild(Node* newChild, Node* oldChild)
2809 {
2810     if (!oldChild)
2811         // ContainerNode::replaceChild will raise a NOT_FOUND_ERR.
2812         return true;
2813
2814     if (oldChild->nodeType() == newChild->nodeType())
2815         return true;
2816
2817     int numDoctypes = 0;
2818     int numElements = 0;
2819
2820     // First, check how many doctypes and elements we have, not counting
2821     // the child we're about to remove.
2822     for (Node* c = firstChild(); c; c = c->nextSibling()) {
2823         if (c == oldChild)
2824             continue;
2825         
2826         switch (c->nodeType()) {
2827         case DOCUMENT_TYPE_NODE:
2828             numDoctypes++;
2829             break;
2830         case ELEMENT_NODE:
2831             numElements++;
2832             break;
2833         default:
2834             break;
2835         }
2836     }
2837     
2838     // Then, see how many doctypes and elements might be added by the new child.
2839     if (newChild->nodeType() == DOCUMENT_FRAGMENT_NODE) {
2840         for (Node* c = firstChild(); c; c = c->nextSibling()) {
2841             switch (c->nodeType()) {
2842             case ATTRIBUTE_NODE:
2843             case CDATA_SECTION_NODE:
2844             case DOCUMENT_FRAGMENT_NODE:
2845             case DOCUMENT_NODE:
2846             case ENTITY_NODE:
2847             case ENTITY_REFERENCE_NODE:
2848             case NOTATION_NODE:
2849             case TEXT_NODE:
2850             case XPATH_NAMESPACE_NODE:
2851                 return false;
2852             case COMMENT_NODE:
2853             case PROCESSING_INSTRUCTION_NODE:
2854                 break;
2855             case DOCUMENT_TYPE_NODE:
2856                 numDoctypes++;
2857                 break;
2858             case ELEMENT_NODE:
2859                 numElements++;
2860                 break;
2861             case SHADOW_ROOT_NODE:
2862                 ASSERT_NOT_REACHED();
2863                 return false;
2864             }
2865         }
2866     } else {
2867         switch (newChild->nodeType()) {
2868         case ATTRIBUTE_NODE:
2869         case CDATA_SECTION_NODE:
2870         case DOCUMENT_FRAGMENT_NODE:
2871         case DOCUMENT_NODE:
2872         case ENTITY_NODE:
2873         case ENTITY_REFERENCE_NODE:
2874         case NOTATION_NODE:
2875         case TEXT_NODE:
2876         case XPATH_NAMESPACE_NODE:
2877         case SHADOW_ROOT_NODE:
2878             return false;
2879         case COMMENT_NODE:
2880         case PROCESSING_INSTRUCTION_NODE:
2881             return true;
2882         case DOCUMENT_TYPE_NODE:
2883             numDoctypes++;
2884             break;
2885         case ELEMENT_NODE:
2886             numElements++;
2887             break;
2888         }                
2889     }
2890         
2891     if (numElements > 1 || numDoctypes > 1)
2892         return false;
2893     
2894     return true;
2895 }
2896
2897 PassRefPtr<Node> Document::cloneNode(bool /*deep*/)
2898 {
2899     // Spec says cloning Document nodes is "implementation dependent"
2900     // so we do not support it...
2901     return 0;
2902 }
2903
2904 StyleSheetList* Document::styleSheets()
2905 {
2906     return m_styleSheets.get();
2907 }
2908
2909 String Document::preferredStylesheetSet() const
2910 {
2911     return m_preferredStylesheetSet;
2912 }
2913
2914 String Document::selectedStylesheetSet() const
2915 {
2916     return m_selectedStylesheetSet;
2917 }
2918
2919 void Document::setSelectedStylesheetSet(const String& aString)
2920 {
2921     m_selectedStylesheetSet = aString;
2922     styleSelectorChanged(DeferRecalcStyle);
2923 }
2924
2925 // This method is called whenever a top-level stylesheet has finished loading.
2926 void Document::removePendingSheet()
2927 {
2928     // Make sure we knew this sheet was pending, and that our count isn't out of sync.
2929     ASSERT(m_pendingStylesheets > 0);
2930
2931     m_pendingStylesheets--;
2932     
2933 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2934     if (!ownerElement())
2935         printf("Stylesheet loaded at time %d. %d stylesheets still remain.\n", elapsedTime(), m_pendingStylesheets);
2936 #endif
2937
2938     if (m_pendingStylesheets)
2939         return;
2940
2941     styleSelectorChanged(RecalcStyleImmediately);
2942
2943     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2944         parser->executeScriptsWaitingForStylesheets();
2945
2946     if (m_gotoAnchorNeededAfterStylesheetsLoad && view())
2947         view()->scrollToFragment(m_url);
2948 }
2949
2950 void Document::styleSelectorChanged(StyleSelectorUpdateFlag updateFlag)
2951 {
2952     // Don't bother updating, since we haven't loaded all our style info yet
2953     // and haven't calculated the style selector for the first time.
2954     if (!attached() || (!m_didCalculateStyleSelector && !haveStylesheetsLoaded()))
2955         return;
2956
2957 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2958     if (!ownerElement())
2959         printf("Beginning update of style selector at time %d.\n", elapsedTime());
2960 #endif
2961
2962     recalcStyleSelector();
2963     
2964     if (updateFlag == DeferRecalcStyle) {
2965         scheduleForcedStyleRecalc();
2966         return;
2967     }
2968     
2969     if (didLayoutWithPendingStylesheets() && m_pendingStylesheets <= 0) {
2970         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
2971         if (renderer())
2972             renderer()->repaint();
2973     }
2974
2975     // This recalcStyle initiates a new recalc cycle. We need to bracket it to
2976     // make sure animations get the correct update time
2977     if (m_frame)
2978         m_frame->animation()->beginAnimationUpdate();
2979     recalcStyle(Force);
2980     if (m_frame)
2981         m_frame->animation()->endAnimationUpdate();
2982
2983 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2984     if (!ownerElement())
2985         printf("Finished update of style selector at time %d\n", elapsedTime());
2986 #endif
2987
2988     if (renderer()) {
2989         renderer()->setNeedsLayoutAndPrefWidthsRecalc();
2990         if (view())
2991             view()->scheduleRelayout();
2992     }
2993
2994     if (m_mediaQueryMatcher)
2995         m_mediaQueryMatcher->styleSelectorChanged();
2996 }
2997
2998 void Document::addStyleSheetCandidateNode(Node* node, bool createdByParser)
2999 {
3000     if (!node->inDocument())
3001         return;
3002     
3003     // Until the <body> exists, we have no choice but to compare document positions,
3004     // since styles outside of the body and head continue to be shunted into the head
3005     // (and thus can shift to end up before dynamically added DOM content that is also
3006     // outside the body).
3007     if ((createdByParser && body()) || m_styleSheetCandidateNodes.isEmpty()) {
3008         m_styleSheetCandidateNodes.add(node);
3009         return;
3010     }
3011
3012     // Determine an appropriate insertion point.
3013     StyleSheetCandidateListHashSet::iterator begin = m_styleSheetCandidateNodes.begin();
3014     StyleSheetCandidateListHashSet::iterator end = m_styleSheetCandidateNodes.end();
3015     StyleSheetCandidateListHashSet::iterator it = end;
3016     Node* followingNode = 0;
3017     do {
3018         --it;
3019         Node* n = *it;
3020         unsigned short position = n->compareDocumentPosition(node);
3021         if (position == DOCUMENT_POSITION_FOLLOWING) {
3022             m_styleSheetCandidateNodes.insertBefore(followingNode, node);
3023             return;
3024         }
3025         followingNode = n;
3026     } while (it != begin);
3027     
3028     m_styleSheetCandidateNodes.insertBefore(followingNode, node);
3029 }
3030
3031 void Document::removeStyleSheetCandidateNode(Node* node)
3032 {
3033     m_styleSheetCandidateNodes.remove(node);
3034 }
3035
3036 void Document::recalcStyleSelector()
3037 {
3038     if (m_inStyleRecalc) {
3039         // SVG <use> element may manage to invalidate style selector in the middle of a style recalc.
3040         // https://bugs.webkit.org/show_bug.cgi?id=54344
3041         // FIXME: This should be fixed in SVG and this code replaced with ASSERT(!m_inStyleRecalc).
3042         m_hasDirtyStyleSelector = true;
3043         scheduleForcedStyleRecalc();
3044         return;
3045     }
3046     if (!renderer() || !attached())
3047         return;
3048
3049     StyleSheetVector sheets;
3050
3051     bool matchAuthorAndUserStyles = true;
3052     if (Settings* settings = this->settings())
3053         matchAuthorAndUserStyles = settings->authorAndUserStylesEnabled();
3054
3055     StyleSheetCandidateListHashSet::iterator begin = m_styleSheetCandidateNodes.begin();
3056     StyleSheetCandidateListHashSet::iterator end = m_styleSheetCandidateNodes.end();
3057     if (!matchAuthorAndUserStyles)
3058         end = begin;
3059     for (StyleSheetCandidateListHashSet::iterator it = begin; it != end; ++it) {
3060         Node* n = *it;
3061
3062         StyleSheet* sheet = 0;
3063
3064         if (n->nodeType() == PROCESSING_INSTRUCTION_NODE) {
3065             // Processing instruction (XML documents only).
3066             // We don't support linking to embedded CSS stylesheets, see <https://bugs.webkit.org/show_bug.cgi?id=49281> for discussion.
3067             ProcessingInstruction* pi = static_cast<ProcessingInstruction*>(n);
3068             sheet = pi->sheet();
3069 #if ENABLE(XSLT)
3070             // Don't apply XSL transforms to already transformed documents -- <rdar://problem/4132806>
3071             if (pi->isXSL() && !transformSourceDocument()) {
3072                 // Don't apply XSL transforms until loading is finished.
3073                 if (!parsing())
3074                     applyXSLTransform(pi);
3075                 return;
3076             }
3077 #endif
3078         } else if ((n->isHTMLElement() && (n->hasTagName(linkTag) || n->hasTagName(styleTag)))
3079 #if ENABLE(SVG)
3080             ||  (n->isSVGElement() && n->hasTagName(SVGNames::styleTag))
3081 #endif
3082         ) {
3083             Element* e = static_cast<Element*>(n);
3084             AtomicString title = e->getAttribute(titleAttr);
3085             bool enabledViaScript = false;
3086             if (e->hasLocalName(linkTag)) {
3087                 // <LINK> element
3088                 HTMLLinkElement* linkElement = static_cast<HTMLLinkElement*>(n);
3089                 if (linkElement->isDisabled())
3090                     continue;
3091                 enabledViaScript = linkElement->isEnabledViaScript();
3092                 if (linkElement->isLoading()) {
3093                     // it is loading but we should still decide which style sheet set to use
3094                     if (!enabledViaScript && !title.isEmpty() && m_preferredStylesheetSet.isEmpty()) {
3095                         const AtomicString& rel = e->getAttribute(relAttr);
3096                         if (!rel.contains("alternate")) {
3097                             m_preferredStylesheetSet = title;
3098                             m_selectedStylesheetSet = title;
3099                         }
3100                     }
3101                     continue;
3102                 }
3103                 if (!linkElement->sheet())
3104                     title = nullAtom;
3105             }
3106
3107             // Get the current preferred styleset.  This is the
3108             // set of sheets that will be enabled.
3109 #if ENABLE(SVG)
3110             if (n->isSVGElement() && n->hasTagName(SVGNames::styleTag))
3111                 sheet = static_cast<SVGStyleElement*>(n)->sheet();
3112             else
3113 #endif
3114             if (e->hasLocalName(linkTag))
3115                 sheet = static_cast<HTMLLinkElement*>(n)->sheet();
3116             else
3117                 // <STYLE> element
3118                 sheet = static_cast<HTMLStyleElement*>(n)->sheet();
3119
3120             // Check to see if this sheet belongs to a styleset
3121             // (thus making it PREFERRED or ALTERNATE rather than
3122             // PERSISTENT).
3123             if (!enabledViaScript && !title.isEmpty()) {
3124                 // Yes, we have a title.
3125                 if (m_preferredStylesheetSet.isEmpty()) {
3126                     // No preferred set has been established.  If
3127                     // we are NOT an alternate sheet, then establish
3128                     // us as the preferred set.  Otherwise, just ignore
3129                     // this sheet.
3130                     AtomicString rel = e->getAttribute(relAttr);
3131                     if (e->hasLocalName(styleTag) || !rel.contains("alternate"))
3132                         m_preferredStylesheetSet = m_selectedStylesheetSet = title;
3133                 }
3134
3135                 if (title != m_preferredStylesheetSet)
3136                     sheet = 0;
3137             }
3138         }
3139
3140         if (sheet)
3141             sheets.append(sheet);
3142     }
3143
3144     m_styleSheets->swap(sheets);
3145
3146     m_styleSelector.clear();
3147     m_didCalculateStyleSelector = true;
3148     m_hasDirtyStyleSelector = false;
3149 }
3150
3151 void Document::setHoverNode(PassRefPtr<Node> newHoverNode)
3152 {
3153     m_hoverNode = newHoverNode;
3154 }
3155
3156 void Document::setActiveNode(PassRefPtr<Node> newActiveNode)
3157 {
3158     m_activeNode = newActiveNode;
3159 }
3160
3161 void Document::focusedNodeRemoved()
3162 {
3163     setFocusedNode(0);
3164 }
3165
3166 void Document::removeFocusedNodeOfSubtree(Node* node, bool amongChildrenOnly)
3167 {
3168     if (!m_focusedNode || this->inPageCache()) // If the document is in the page cache, then we don't need to clear out the focused node.
3169         return;
3170         
3171     bool nodeInSubtree = false;
3172     if (amongChildrenOnly)
3173         nodeInSubtree = m_focusedNode->isDescendantOf(node);
3174     else
3175         nodeInSubtree = (m_focusedNode == node) || m_focusedNode->isDescendantOf(node);
3176     
3177     if (nodeInSubtree)
3178         document()->focusedNodeRemoved();
3179 }
3180
3181 void Document::hoveredNodeDetached(Node* node)
3182 {
3183     if (!m_hoverNode || (node != m_hoverNode && (!m_hoverNode->isTextNode() || node != m_hoverNode->parentNode())))
3184         return;
3185
3186     m_hoverNode = node->parentNode();
3187     while (m_hoverNode && !m_hoverNode->renderer())
3188         m_hoverNode = m_hoverNode->parentNode();
3189     if (frame())
3190         frame()->eventHandler()->scheduleHoverStateUpdate();
3191 }
3192
3193 void Document::activeChainNodeDetached(Node* node)
3194 {
3195     if (!m_activeNode || (node != m_activeNode && (!m_activeNode->isTextNode() || node != m_activeNode->parentNode())))
3196         return;
3197
3198     m_activeNode = node->parentNode();
3199     while (m_activeNode && !m_activeNode->renderer())
3200         m_activeNode = m_activeNode->parentNode();
3201 }
3202
3203 #if ENABLE(DASHBOARD_SUPPORT)
3204 const Vector<DashboardRegionValue>& Document::dashboardRegions() const
3205 {
3206     return m_dashboardRegions;
3207 }
3208
3209 void Document::setDashboardRegions(const Vector<DashboardRegionValue>& regions)
3210 {
3211     m_dashboardRegions = regions;
3212     setDashboardRegionsDirty(false);
3213 }
3214 #endif
3215
3216 bool Document::setFocusedNode(PassRefPtr<Node> prpNewFocusedNode)
3217 {
3218     RefPtr<Node> newFocusedNode = prpNewFocusedNode;
3219
3220     // Make sure newFocusedNode is actually in this document
3221     if (newFocusedNode && (newFocusedNode->document() != this))
3222         return true;
3223
3224     if (m_focusedNode == newFocusedNode)
3225         return true;
3226
3227     if (m_inPageCache)
3228         return false;
3229
3230     bool focusChangeBlocked = false;
3231     RefPtr<Node> oldFocusedNode = m_focusedNode;
3232     m_focusedNode = 0;
3233
3234     // Remove focus from the existing focus node (if any)
3235     if (oldFocusedNode && !oldFocusedNode->inDetach()) {
3236         if (oldFocusedNode->active())
3237             oldFocusedNode->setActive(false);
3238
3239         oldFocusedNode->setFocus(false);
3240
3241         // Dispatch a change event for text fields or textareas that have been edited
3242         if (oldFocusedNode->isElementNode()) {
3243             Element* element = static_cast<Element*>(oldFocusedNode.get());
3244             if (element->wasChangedSinceLastFormControlChangeEvent())
3245                 element->dispatchFormControlChangeEvent();
3246         }
3247
3248         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
3249         oldFocusedNode->dispatchBlurEvent(newFocusedNode);
3250
3251         if (m_focusedNode) {
3252             // handler shifted focus
3253             focusChangeBlocked = true;
3254             newFocusedNode = 0;
3255         }
3256         
3257         oldFocusedNode->dispatchFocusOutEvent(eventNames().focusoutEvent, newFocusedNode); // DOM level 3 name for the bubbling blur event.
3258         // FIXME: We should remove firing DOMFocusOutEvent event when we are sure no content depends
3259         // on it, probably when <rdar://problem/8503958> is resolved.
3260         oldFocusedNode->dispatchFocusOutEvent(eventNames().DOMFocusOutEvent, newFocusedNode); // DOM level 2 name for compatibility.
3261
3262         if (m_focusedNode) {
3263             // handler shifted focus
3264             focusChangeBlocked = true;
3265             newFocusedNode = 0;
3266         }
3267         if (oldFocusedNode == this && oldFocusedNode->hasOneRef())
3268             return true;
3269             
3270         if (oldFocusedNode == oldFocusedNode->rootEditableElement())
3271             frame()->editor()->didEndEditing();
3272
3273         if (view()) {
3274             Widget* oldWidget = widgetForNode(oldFocusedNode.get());
3275             if (oldWidget)
3276                 oldWidget->setFocus(false);
3277             else
3278                 view()->setFocus(false);
3279         }
3280     }
3281
3282     if (newFocusedNode) {
3283         if (newFocusedNode == newFocusedNode->rootEditableElement() && !acceptsEditingFocus(newFocusedNode.get())) {
3284             // delegate blocks focus change
3285             focusChangeBlocked = true;
3286             goto SetFocusedNodeDone;
3287         }
3288         // Set focus on the new node
3289         m_focusedNode = newFocusedNode;
3290
3291         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
3292         m_focusedNode->dispatchFocusEvent(oldFocusedNode);
3293
3294         if (m_focusedNode != newFocusedNode) {
3295             // handler shifted focus
3296             focusChangeBlocked = true;
3297             goto SetFocusedNodeDone;
3298         }
3299
3300         m_focusedNode->dispatchFocusInEvent(eventNames().focusinEvent, oldFocusedNode); // DOM level 3 bubbling focus event.
3301         // FIXME: We should remove firing DOMFocusInEvent event when we are sure no content depends
3302         // on it, probably when <rdar://problem/8503958> is m.
3303         m_focusedNode->dispatchFocusInEvent(eventNames().DOMFocusInEvent, oldFocusedNode); // DOM level 2 for compatibility.
3304
3305         if (m_focusedNode != newFocusedNode) { 
3306             // handler shifted focus
3307             focusChangeBlocked = true;
3308             goto SetFocusedNodeDone;
3309         }
3310         m_focusedNode->setFocus(true);
3311
3312         if (m_focusedNode == m_focusedNode->rootEditableElement())
3313             frame()->editor()->didBeginEditing();
3314
3315         // eww, I suck. set the qt focus correctly
3316         // ### find a better place in the code for this
3317         if (view()) {
3318             Widget* focusWidget = widgetForNode(m_focusedNode.get());
3319             if (focusWidget) {
3320                 // Make sure a widget has the right size before giving it focus.
3321                 // Otherwise, we are testing edge cases of the Widget code.
3322                 // Specifically, in WebCore this does not work well for text fields.
3323                 updateLayout();
3324                 // Re-get the widget in case updating the layout changed things.
3325                 focusWidget = widgetForNode(m_focusedNode.get());
3326             }
3327             if (focusWidget)
3328                 focusWidget->setFocus(true);
3329             else
3330                 view()->setFocus(true);
3331         }
3332     }
3333
3334 #if PLATFORM(MAC) || PLATFORM(WIN) || PLATFORM(GTK) || PLATFORM(CHROMIUM)
3335     if (!focusChangeBlocked && m_focusedNode && AXObjectCache::accessibilityEnabled()) {
3336         RenderObject* oldFocusedRenderer = 0;
3337         RenderObject* newFocusedRenderer = 0;
3338
3339         if (oldFocusedNode)
3340             oldFocusedRenderer = oldFocusedNode->renderer();
3341         if (newFocusedNode)
3342             newFocusedRenderer = newFocusedNode->renderer();
3343
3344         axObjectCache()->handleFocusedUIElementChanged(oldFocusedRenderer, newFocusedRenderer);
3345     }
3346 #endif
3347     if (!focusChangeBlocked)
3348         page()->chrome()->focusedNodeChanged(m_focusedNode.get());
3349
3350 SetFocusedNodeDone:
3351     updateStyleIfNeeded();
3352     return !focusChangeBlocked;
3353 }
3354     
3355 void Document::getFocusableNodes(Vector<RefPtr<Node> >& nodes)
3356 {
3357     updateLayout();
3358
3359     for (Node* node = firstChild(); node; node = node->traverseNextNode()) {
3360         if (node->isFocusable())
3361             nodes.append(node);
3362     }
3363 }
3364   
3365 void Document::setCSSTarget(Element* n)
3366 {
3367     if (m_cssTarget)
3368         m_cssTarget->setNeedsStyleRecalc();
3369     m_cssTarget = n;
3370     if (n)
3371         n->setNeedsStyleRecalc();
3372 }
3373
3374 void Document::attachNodeIterator(NodeIterator* ni)
3375 {
3376     m_nodeIterators.add(ni);
3377 }
3378
3379 void Document::detachNodeIterator(NodeIterator* ni)
3380 {
3381     // The node iterator can be detached without having been attached if its root node didn't have a document
3382     // when the iterator was created, but has it now.
3383     m_nodeIterators.remove(ni);
3384 }
3385
3386 void Document::moveNodeIteratorsToNewDocument(Node* node, Document* newDocument)
3387 {
3388     HashSet<NodeIterator*> nodeIteratorsList = m_nodeIterators;
3389     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = nodeIteratorsList.end();
3390     for (HashSet<NodeIterator*>::const_iterator it = nodeIteratorsList.begin(); it != nodeIteratorsEnd; ++it) {
3391         if ((*it)->root() == node) {
3392             detachNodeIterator(*it);
3393             newDocument->attachNodeIterator(*it);
3394         }
3395     }
3396 }
3397
3398 void Document::nodeChildrenChanged(ContainerNode* container)
3399 {
3400     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3401         HashSet<Range*>::const_iterator end = m_ranges.end();
3402         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3403             (*it)->nodeChildrenChanged(container);
3404     }
3405 }
3406
3407 void Document::nodeChildrenWillBeRemoved(ContainerNode* container)
3408 {
3409     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3410         HashSet<Range*>::const_iterator end = m_ranges.end();
3411         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3412             (*it)->nodeChildrenWillBeRemoved(container);
3413     }
3414
3415     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = m_nodeIterators.end();
3416     for (HashSet<NodeIterator*>::const_iterator it = m_nodeIterators.begin(); it != nodeIteratorsEnd; ++it) {
3417         for (Node* n = container->firstChild(); n; n = n->nextSibling())
3418             (*it)->nodeWillBeRemoved(n);
3419     }
3420
3421     if (Frame* frame = this->frame()) {
3422         for (Node* n = container->firstChild(); n; n = n->nextSibling()) {
3423             frame->eventHandler()->nodeWillBeRemoved(n);
3424             frame->selection()->nodeWillBeRemoved(n);
3425             frame->page()->dragCaretController()->nodeWillBeRemoved(n);
3426         }
3427     }
3428 }
3429
3430 void Document::nodeWillBeRemoved(Node* n)
3431 {
3432     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = m_nodeIterators.end();
3433     for (HashSet<NodeIterator*>::const_iterator it = m_nodeIterators.begin(); it != nodeIteratorsEnd; ++it)
3434         (*it)->nodeWillBeRemoved(n);
3435
3436     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3437         HashSet<Range*>::const_iterator rangesEnd = m_ranges.end();
3438         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != rangesEnd; ++it)
3439             (*it)->nodeWillBeRemoved(n);
3440     }
3441
3442     if (Frame* frame = this->frame()) {
3443         frame->eventHandler()->nodeWillBeRemoved(n);
3444         frame->selection()->nodeWillBeRemoved(n);
3445         frame->page()->dragCaretController()->nodeWillBeRemoved(n);
3446     }
3447 }
3448
3449 void Document::textInserted(Node* text, unsigned offset, unsigned length)
3450 {
3451     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3452         HashSet<Range*>::const_iterator end = m_ranges.end();
3453         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3454             (*it)->textInserted(text, offset, length);
3455     }
3456
3457     // Update the markers for spelling and grammar checking.
3458     m_markers->shiftMarkers(text, offset, length);
3459 }
3460
3461 void Document::textRemoved(Node* text, unsigned offset, unsigned length)
3462 {
3463     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3464         HashSet<Range*>::const_iterator end = m_ranges.end();
3465         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3466             (*it)->textRemoved(text, offset, length);
3467     }
3468
3469     // Update the markers for spelling and grammar checking.
3470     m_markers->removeMarkers(text, offset, length);
3471     m_markers->shiftMarkers(text, offset + length, 0 - length);
3472 }
3473
3474 void Document::textNodesMerged(Text* oldNode, unsigned offset)
3475 {
3476     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3477         NodeWithIndex oldNodeWithIndex(oldNode);
3478         HashSet<Range*>::const_iterator end = m_ranges.end();
3479         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3480             (*it)->textNodesMerged(oldNodeWithIndex, offset);
3481     }
3482
3483     // FIXME: This should update markers for spelling and grammar checking.
3484 }
3485
3486 void Document::textNodeSplit(Text* oldNode)
3487 {
3488     if (!disableRangeMutation(page()) && !m_ranges.isEmpty()) {
3489         HashSet<Range*>::const_iterator end = m_ranges.end();
3490         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3491             (*it)->textNodeSplit(oldNode);
3492     }
3493
3494     // FIXME: This should update markers for spelling and grammar checking.
3495 }
3496
3497 // FIXME: eventually, this should return a DOMWindow stored in the document.
3498 DOMWindow* Document::domWindow() const
3499 {
3500     if (!frame())
3501         return 0;
3502
3503     // The m_frame pointer is not (not always?) zeroed out when the document is put into b/f cache, so the frame can hold an unrelated document/window pair.
3504     // FIXME: We should always zero out the frame pointer on navigation to avoid accidentally accessing the new frame content.
3505     if (m_frame->document() != this)
3506         return 0;
3507
3508     return frame()->domWindow();
3509 }
3510
3511 void Document::setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
3512 {
3513     DOMWindow* domWindow = this->domWindow();
3514     if (!domWindow)
3515         return;
3516     domWindow->setAttributeEventListener(eventType, listener);
3517 }
3518
3519 EventListener* Document::getWindowAttributeEventListener(const AtomicString& eventType)
3520 {
3521     DOMWindow* domWindow = this->domWindow();
3522     if (!domWindow)
3523         return 0;
3524     return domWindow->getAttributeEventListener(eventType);
3525 }
3526
3527 void Document::dispatchWindowEvent(PassRefPtr<Event> event,  PassRefPtr<EventTarget> target)
3528 {
3529     ASSERT(!eventDispatchForbidden());
3530     DOMWindow* domWindow = this->domWindow();
3531     if (!domWindow)
3532         return;
3533     domWindow->dispatchEvent(event, target);
3534 }
3535
3536 void Document::dispatchWindowLoadEvent()
3537 {
3538     ASSERT(!eventDispatchForbidden());
3539     DOMWindow* domWindow = this->domWindow();
3540     if (!domWindow)
3541         return;
3542     domWindow->dispatchLoadEvent();
3543     m_loadEventFinished = true;
3544 }
3545
3546 void Document::enqueueWindowEvent(PassRefPtr<Event> event)
3547 {
3548     event->setTarget(domWindow());
3549     m_eventQueue->enqueueEvent(event);
3550 }
3551
3552 void Document::enqueueDocumentEvent(PassRefPtr<Event> event)
3553 {
3554     event->setTarget(this);
3555     m_eventQueue->enqueueEvent(event);
3556 }
3557
3558 PassRefPtr<Event> Document::createEvent(const String& eventType, ExceptionCode& ec)
3559 {
3560     RefPtr<Event> event = EventFactory::create(eventType);
3561     if (event)
3562         return event.release();
3563
3564     ec = NOT_SUPPORTED_ERR;
3565     return 0;
3566 }
3567
3568 void Document::addListenerTypeIfNeeded(const AtomicString& eventType)
3569 {
3570     if (eventType == eventNames().DOMSubtreeModifiedEvent)
3571         addListenerType(DOMSUBTREEMODIFIED_LISTENER);
3572     else if (eventType == eventNames().DOMNodeInsertedEvent)
3573         addListenerType(DOMNODEINSERTED_LISTENER);
3574     else if (eventType == eventNames().DOMNodeRemovedEvent)
3575         addListenerType(DOMNODEREMOVED_LISTENER);
3576     else if (eventType == eventNames().DOMNodeRemovedFromDocumentEvent)
3577         addListenerType(DOMNODEREMOVEDFROMDOCUMENT_LISTENER);
3578     else if (eventType == eventNames().DOMNodeInsertedIntoDocumentEvent)
3579         addListenerType(DOMNODEINSERTEDINTODOCUMENT_LISTENER);
3580     else if (eventType == eventNames().DOMAttrModifiedEvent)
3581         addListenerType(DOMATTRMODIFIED_LISTENER);
3582     else if (eventType == eventNames().DOMCharacterDataModifiedEvent)
3583         addListenerType(DOMCHARACTERDATAMODIFIED_LISTENER);
3584     else if (eventType == eventNames().overflowchangedEvent)
3585         addListenerType(OVERFLOWCHANGED_LISTENER);
3586     else if (eventType == eventNames().webkitAnimationStartEvent)
3587         addListenerType(ANIMATIONSTART_LISTENER);
3588     else if (eventType == eventNames().webkitAnimationEndEvent)
3589         addListenerType(ANIMATIONEND_LISTENER);
3590     else if (eventType == eventNames().webkitAnimationIterationEvent)
3591         addListenerType(ANIMATIONITERATION_LISTENER);
3592     else if (eventType == eventNames().webkitTransitionEndEvent)
3593         addListenerType(TRANSITIONEND_LISTENER);
3594     else if (eventType == eventNames().beforeloadEvent)
3595         addListenerType(BEFORELOAD_LISTENER);
3596 #if ENABLE(TOUCH_EVENTS)
3597     else if (eventType == eventNames().touchstartEvent
3598              || eventType == eventNames().touchmoveEvent
3599              || eventType == eventNames().touchendEvent
3600              || eventType == eventNames().touchcancelEvent) {
3601         addListenerType(TOUCH_LISTENER);
3602         if (Page* page = this->page())
3603             page->chrome()->client()->needTouchEvents(true);
3604     }
3605 #endif
3606     else if (eventType == eventNames().scrollEvent)
3607         addListenerType(SCROLL_LISTENER);
3608 }
3609
3610 CSSStyleDeclaration* Document::getOverrideStyle(Element*, const String&)
3611 {
3612     return 0;
3613 }
3614
3615 HTMLFrameOwnerElement* Document::ownerElement() const
3616 {
3617     if (!frame())
3618         return 0;
3619     return frame()->ownerElement();
3620 }
3621
3622 String Document::cookie(ExceptionCode& ec) const
3623 {
3624     if (page() && !page()->cookieEnabled())
3625         return String();
3626
3627     // FIXME: The HTML5 DOM spec states that this attribute can raise an
3628     // INVALID_STATE_ERR exception on getting if the Document has no
3629     // browsing context.
3630
3631     if (!securityOrigin()->canAccessCookies()) {
3632         ec = SECURITY_ERR;
3633         return String();
3634     }
3635
3636     KURL cookieURL = this->cookieURL();
3637     if (cookieURL.isEmpty())
3638         return String();
3639
3640     return cookies(this, cookieURL);
3641 }