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