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, 2012, 2013 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, 2012 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 "CDATASection.h"
  35 #include "CSSStyleDeclaration.h"
  36 #include "CSSStyleSheet.h"
  37 #include "CachedCSSStyleSheet.h"
  38 #include "CachedResourceLoader.h"
  39 #include "Chrome.h"
  40 #include "ChromeClient.h"
  41 #include "Comment.h"
  42 #include "ContentSecurityPolicy.h"
  43 #include "CookieJar.h"
  44 #include "DOMImplementation.h"
  45 #include "DOMNamedFlowCollection.h"
  46 #include "DOMWindow.h"
  47 #include "DateComponents.h"
  48 #include "Dictionary.h"
  49 #include "DocumentLoader.h"
  50 #include "DocumentMarkerController.h"
  51 #include "DocumentSharedObjectPool.h"
  52 #include "DocumentType.h"
  53 #include "Editor.h"
  54 #include "ElementIterator.h"
  55 #include "EntityReference.h"
  56 #include "EventFactory.h"
  57 #include "EventHandler.h"
  58 #include "FontLoader.h"
  59 #include "FormController.h"
  60 #include "FrameLoader.h"
  61 #include "FrameLoaderClient.h"
  62 #include "FrameView.h"
  63 #include "HashChangeEvent.h"
  64 #include "HistogramSupport.h"
  65 #include "History.h"
  66 #include "HTMLAllCollection.h"
  67 #include "HTMLAnchorElement.h"
  68 #include "HTMLBaseElement.h"
  69 #include "HTMLBodyElement.h"
  70 #include "HTMLCanvasElement.h"
  71 #include "HTMLCollection.h"
  72 #include "HTMLDocument.h"
  73 #include "HTMLElementFactory.h"
  74 #include "HTMLFormControlElement.h"
  75 #include "HTMLFrameOwnerElement.h"
  76 #include "HTMLFrameSetElement.h"
  77 #include "HTMLHeadElement.h"
  78 #include "HTMLIFrameElement.h"
  79 #include "HTMLImageElement.h"
  80 #include "HTMLLinkElement.h"
  81 #include "HTMLMediaElement.h"
  82 #include "HTMLNameCollection.h"
  83 #include "HTMLParserIdioms.h"
  84 #include "HTMLPlugInElement.h"
  85 #include "HTMLScriptElement.h"
  86 #include "HTMLStyleElement.h"
  87 #include "HTMLTitleElement.h"
  88 #include "HTTPParsers.h"
  89 #include "HitTestResult.h"
  90 #include "IconController.h"
  91 #include "ImageLoader.h"
  92 #include "InspectorInstrumentation.h"
  93 #include "JSLazyEventListener.h"
  94 #include "Language.h"
  95 #include "LoaderStrategy.h"
  96 #include "Logging.h"
  97 #include "MainFrame.h"
  98 #include "MediaCanStartListener.h"
  99 #include "MediaQueryList.h"
 100 #include "MediaQueryMatcher.h"
 101 #include "MouseEventWithHitTestResults.h"
 102 #include "NameNodeList.h"
 103 #include "NestingLevelIncrementer.h"
 104 #include "NodeIterator.h"
 105 #include "NodeRareData.h"
 106 #include "NodeWithIndex.h"
 107 #include "PageConsole.h"
 108 #include "PageGroup.h"
 109 #include "PageTransitionEvent.h"
 110 #include "PlatformLocale.h"
 111 #include "PlatformStrategies.h"
 112 #include "PlugInsResources.h"
 113 #include "PluginDocument.h"
 114 #include "PointerLockController.h"
 115 #include "PopStateEvent.h"
 116 #include "ProcessingInstruction.h"
 117 #include "RenderLayerCompositor.h"
 118 #include "RenderView.h"
 119 #include "RenderWidget.h"
 120 #include "ResourceLoadScheduler.h"
 121 #include "ResourceLoader.h"
 122 #include "RuntimeEnabledFeatures.h"
 123 #include "SchemeRegistry.h"
 124 #include "ScopedEventQueue.h"
 125 #include "ScriptCallStack.h"
 126 #include "ScriptController.h"
 127 #include "ScriptRunner.h"
 128 #include "ScriptSourceCode.h"
 129 #include "ScrollingCoordinator.h"
 130 #include "SecurityOrigin.h"
 131 #include "SecurityPolicy.h"
 132 #include "SegmentedString.h"
 133 #include "SelectorQuery.h"
 134 #include "Settings.h"
 135 #include "ShadowRoot.h"
 136 #include "StyleProperties.h"
 137 #include "StyleResolver.h"
 138 #include "StyleSheetContents.h"
 139 #include "StyleSheetList.h"
 140 #include "TextResourceDecoder.h"
 141 #include "TransformSource.h"
 142 #include "TreeWalker.h"
 143 #include "VisitedLinkState.h"
 144 #include "XMLDocumentParser.h"
 145 #include "XMLNSNames.h"
 146 #include "XMLNames.h"
 147 #include "XPathEvaluator.h"
 148 #include "XPathExpression.h"
 149 #include "XPathNSResolver.h"
 150 #include "XPathResult.h"
 151 #include "htmlediting.h"
 152 #include <wtf/CurrentTime.h>
 153 #include <wtf/TemporaryChange.h>
 154 #include <wtf/text/StringBuffer.h>
 155
 156 #if ENABLE(SHARED_WORKERS)
 157 #include "SharedWorkerRepository.h"
 158 #endif
 159
 160 #if ENABLE(XSLT)
 161 #include "XSLTProcessor.h"
 162 #endif
 163
 164 #if ENABLE(SVG)
 165 #include "SVGDocumentExtensions.h"
 166 #include "SVGElementFactory.h"
 167 #include "SVGNames.h"
 168 #include "SVGSVGElement.h"
 169 #endif
 170
 171 #if ENABLE(TOUCH_EVENTS)
 172 #include "TouchList.h"
 173 #endif
 174
 175 #if PLATFORM(IOS)
 176 #include "CSSFontSelector.h"
 177 #include "DeviceMotionClientIOS.h"
 178 #include "DeviceMotionController.h"
 179 #include "DeviceOrientationClientIOS.h"
 180 #include "DeviceOrientationController.h"
 181 #include "Geolocation.h"
 182 #include "Navigator.h"
 183 #include "NavigatorGeolocation.h"
 184 #include "WKContentObservation.h"
 185 #include "WebCoreSystemInterface.h"
 186 #endif
 187
 188 #if ENABLE(IOS_GESTURE_EVENTS)
 189 #include "GestureEvent.h"
 190 #endif
 191
 192 #if ENABLE(MATHML)
 193 #include "MathMLElement.h"
 194 #include "MathMLElementFactory.h"
 195 #include "MathMLNames.h"
 196 #endif
 197
 198 #if ENABLE(FULLSCREEN_API)
 199 #include "RenderFullScreen.h"
 200 #endif
 201
 202 #if ENABLE(REQUEST_ANIMATION_FRAME)
 203 #include "RequestAnimationFrameCallback.h"
 204 #include "ScriptedAnimationController.h"
 205 #endif
 206
 207 #if ENABLE(IOS_TEXT_AUTOSIZING)
 208 #include "TextAutoSizing.h"
 209 #endif
 210
 211 #if ENABLE(TEXT_AUTOSIZING)
 212 #include "TextAutosizer.h"
 213 #endif
 214
 215 #if ENABLE(CSP_NEXT)
 216 #include "DOMSecurityPolicy.h"
 217 #endif
 218
 219 #if ENABLE(VIDEO_TRACK)
 220 #include "CaptionUserPreferences.h"
 221 #endif
 222
 223 #if ENABLE(WEB_REPLAY)
 224 #include <replay/EmptyInputCursor.h>
 225 #endif
 226
 227 using namespace WTF;
 228 using namespace Unicode;
 229
 230 namespace WebCore {
 231
 232 using namespace HTMLNames;
 233
 234 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
 235
 236 static const unsigned cMaxWriteRecursionDepth = 21;
 237
 238 // DOM Level 2 says (letters added):
 239 //
 240 // a) Name start characters must have one of the categories Ll, Lu, Lo, Lt, Nl.
 241 // b) Name characters other than Name-start characters must have one of the categories Mc, Me, Mn, Lm, or Nd.
 242 // c) Characters in the compatibility area (i.e. with character code greater than #xF900 and less than #xFFFE) are not allowed in XML names.
 243 // 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.
 244 // 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.
 245 // f) Characters #x20DD-#x20E0 are excluded (in accordance with Unicode, section 5.14).
 246 // g) Character #x00B7 is classified as an extender, because the property list so identifies it.
 247 // h) Character #x0387 is added as a name character, because #x00B7 is its canonical equivalent.
 248 // i) Characters ':' and '_' are allowed as name-start characters.
 249 // j) Characters '-' and '.' are allowed as name characters.
 250 //
 251 // It also contains complete tables. If we decide it's better, we could include those instead of the following code.
 252
 253 static inline bool isValidNameStart(UChar32 c)
 254 {
 255     // rule (e) above
 256     if ((c >= 0x02BB && c <= 0x02C1) || c == 0x559 || c == 0x6E5 || c == 0x6E6)
 257         return true;
 258
 259     // rule (i) above
 260     if (c == ':' || c == '_')
 261         return true;
 262
 263     // rules (a) and (f) above
 264     if (!(U_GET_GC_MASK(c) & (U_GC_LL_MASK | U_GC_LU_MASK | U_GC_LO_MASK | U_GC_LT_MASK | U_GC_NL_MASK)))
 265         return false;
 266
 267     // rule (c) above
 268     if (c >= 0xF900 && c < 0xFFFE)
 269         return false;
 270
 271     // rule (d) above
 272     int type = u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
 273     if (type == U_DT_FONT || type == U_DT_COMPAT)
 274         return false;
 275
 276     return true;
 277 }
 278
 279 static inline bool isValidNamePart(UChar32 c)
 280 {
 281     // rules (a), (e), and (i) above
 282     if (isValidNameStart(c))
 283         return true;
 284
 285     // rules (g) and (h) above
 286     if (c == 0x00B7 || c == 0x0387)
 287         return true;
 288
 289     // rule (j) above
 290     if (c == '-' || c == '.')
 291         return true;
 292
 293     // rules (b) and (f) above
 294     if (!(U_GET_GC_MASK(c) & (U_GC_M_MASK | U_GC_LM_MASK | U_GC_ND_MASK)))
 295         return false;
 296
 297     // rule (c) above
 298     if (c >= 0xF900 && c < 0xFFFE)
 299         return false;
 300
 301     // rule (d) above
 302     int type = u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
 303     if (type == U_DT_FONT || type == U_DT_COMPAT)
 304         return false;
 305
 306     return true;
 307 }
 308
 309 static bool shouldInheritSecurityOriginFromOwner(const URL& url)
 310 {
 311     // http://www.whatwg.org/specs/web-apps/current-work/#origin-0
 312     //
 313     // If a Document has the address "about:blank"
 314     //     The origin of the Document is the origin it was assigned when its browsing context was created.
 315     //
 316     // Note: We generalize this to all "blank" URLs and invalid URLs because we
 317     // treat all of these URLs as about:blank.
 318     //
 319     return url.isEmpty() || url.isBlankURL();
 320 }
 321
 322 static Widget* widgetForElement(Element* focusedElement)
 323 {
 324     if (!focusedElement)
 325         return nullptr;
 326     auto renderer = focusedElement->renderer();
 327     if (!renderer || !renderer->isWidget())
 328         return nullptr;
 329     return toRenderWidget(renderer)->widget();
 330 }
 331
 332 static bool acceptsEditingFocus(Node* node)
 333 {
 334     ASSERT(node);
 335     ASSERT(node->hasEditableStyle());
 336
 337     Node* root = node->rootEditableElement();
 338     Frame* frame = node->document().frame();
 339     if (!frame || !root)
 340         return false;
 341
 342     return frame->editor().shouldBeginEditing(rangeOfContents(*root).get());
 343 }
 344
 345 static bool canAccessAncestor(const SecurityOrigin* activeSecurityOrigin, Frame* targetFrame)
 346 {
 347     // targetFrame can be 0 when we're trying to navigate a top-level frame
 348     // that has a 0 opener.
 349     if (!targetFrame)
 350         return false;
 351
 352     const bool isLocalActiveOrigin = activeSecurityOrigin->isLocal();
 353     for (Frame* ancestorFrame = targetFrame; ancestorFrame; ancestorFrame = ancestorFrame->tree().parent()) {
 354         Document* ancestorDocument = ancestorFrame->document();
 355         // FIXME: Should be an ASSERT? Frames should alway have documents.
 356         if (!ancestorDocument)
 357             return true;
 358
 359         const SecurityOrigin* ancestorSecurityOrigin = ancestorDocument->securityOrigin();
 360         if (activeSecurityOrigin->canAccess(ancestorSecurityOrigin))
 361             return true;
 362
 363         // Allow file URL descendant navigation even when allowFileAccessFromFileURLs is false.
 364         // FIXME: It's a bit strange to special-case local origins here. Should we be doing
 365         // something more general instead?
 366         if (isLocalActiveOrigin && ancestorSecurityOrigin->isLocal())
 367             return true;
 368     }
 369
 370     return false;
 371 }
 372
 373 static void printNavigationErrorMessage(Frame* frame, const URL& activeURL, const char* reason)
 374 {
 375     String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame->document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";
 376
 377     // FIXME: should we print to the console of the document performing the navigation instead?
 378     frame->document()->domWindow()->printErrorMessage(message);
 379 }
 380
 381 uint64_t Document::s_globalTreeVersion = 0;
 382
 383 static const double timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds = 30;
 384
 385 #if ENABLE(IOS_TEXT_AUTOSIZING)
 386 void TextAutoSizingTraits::constructDeletedValue(TextAutoSizingKey& slot)
 387 {
 388     new (&slot) TextAutoSizingKey(TextAutoSizingKey::deletedKeyStyle(), TextAutoSizingKey::deletedKeyDoc());
 389 }
 390
 391 bool TextAutoSizingTraits::isDeletedValue(const TextAutoSizingKey& value)
 392 {
 393     return value.style() == TextAutoSizingKey::deletedKeyStyle() && value.doc() == TextAutoSizingKey::deletedKeyDoc();
 394 }
 395 #endif
 396
 397 Document::Document(Frame* frame, const URL& url, unsigned documentClasses, unsigned constructionFlags)
 398     : ContainerNode(nullptr, CreateDocument)
 399     , TreeScope(this)
 400 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
 401     , m_handlingTouchEvent(false)
 402     , m_touchEventRegionsDirty(false)
 403     , m_touchEventsChangedTimer(this, &Document::touchEventsChangedTimerFired)
 404 #endif
 405     , m_styleResolverThrowawayTimer(this, &Document::styleResolverThrowawayTimerFired, timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds)
 406     , m_didCalculateStyleResolver(false)
 407     , m_hasNodesWithPlaceholderStyle(false)
 408     , m_needsNotifyRemoveAllPendingStylesheet(false)
 409     , m_ignorePendingStylesheets(false)
 410     , m_pendingSheetLayout(NoLayoutWithPendingSheets)
 411     , m_frame(frame)
 412     , m_activeParserCount(0)
 413     , m_wellFormed(false)
 414     , m_printing(false)
 415     , m_paginatedForScreen(false)
 416     , m_ignoreAutofocus(false)
 417     , m_compatibilityMode(NoQuirksMode)
 418     , m_compatibilityModeLocked(false)
 419     , m_textColor(Color::black)
 420     , m_domTreeVersion(++s_globalTreeVersion)
 421     , m_listenerTypes(0)
 422     , m_mutationObserverTypes(0)
 423     , m_styleSheetCollection(*this)
 424     , m_visitedLinkState(VisitedLinkState::create(*this))
 425     , m_visuallyOrdered(false)
 426     , m_readyState(Complete)
 427     , m_bParsing(false)
 428     , m_optimizedStyleSheetUpdateTimer(this, &Document::optimizedStyleSheetUpdateTimerFired)
 429     , m_styleRecalcTimer(this, &Document::styleRecalcTimerFired)
 430     , m_pendingStyleRecalcShouldForce(false)
 431     , m_inStyleRecalc(false)
 432     , m_closeAfterStyleRecalc(false)
 433     , m_gotoAnchorNeededAfterStylesheetsLoad(false)
 434     , m_frameElementsShouldIgnoreScrolling(false)
 435     , m_containsValidityStyleRules(false)
 436     , m_updateFocusAppearanceRestoresSelection(false)
 437     , m_ignoreDestructiveWriteCount(0)
 438     , m_titleSetExplicitly(false)
 439     , m_markers(adoptPtr(new DocumentMarkerController))
 440     , m_updateFocusAppearanceTimer(this, &Document::updateFocusAppearanceTimerFired)
 441     , m_resetHiddenFocusElementTimer(this, &Document::resetHiddenFocusElementTimer)
 442     , m_cssTarget(nullptr)
 443     , m_processingLoadEvent(false)
 444     , m_loadEventFinished(false)
 445     , m_startTime(std::chrono::steady_clock::now())
 446     , m_overMinimumLayoutThreshold(false)
 447     , m_scriptRunner(std::make_unique<ScriptRunner>(*this))
 448     , m_xmlVersion(ASCIILiteral("1.0"))
 449     , m_xmlStandalone(StandaloneUnspecified)
 450     , m_hasXMLDeclaration(false)
 451     , m_designMode(inherit)
 452 #if ENABLE(DASHBOARD_SUPPORT)
 453     , m_hasAnnotatedRegions(false)
 454     , m_annotatedRegionsDirty(false)
 455 #endif
 456     , m_createRenderers(true)
 457     , m_inPageCache(false)
 458     , m_accessKeyMapValid(false)
 459     , m_documentClasses(documentClasses)
 460     , m_isSynthesized(constructionFlags & Synthesized)
 461     , m_isNonRenderedPlaceholder(constructionFlags & NonRenderedPlaceholder)
 462     , m_isViewSource(false)
 463     , m_sawElementsInKnownNamespaces(false)
 464     , m_isSrcdocDocument(false)
 465     , m_eventQueue(*this)
 466     , m_weakFactory(this)
 467     , m_idAttributeName(idAttr)
 468 #if ENABLE(FULLSCREEN_API)
 469     , m_areKeysEnabledInFullScreen(0)
 470     , m_fullScreenRenderer(nullptr)
 471     , m_fullScreenChangeDelayTimer(this, &Document::fullScreenChangeDelayTimerFired)
 472     , m_isAnimatingFullScreen(false)
 473 #endif
 474     , m_loadEventDelayCount(0)
 475     , m_loadEventDelayTimer(this, &Document::loadEventDelayTimerFired)
 476     , m_referrerPolicy(ReferrerPolicyDefault)
 477     , m_directionSetOnDocumentElement(false)
 478     , m_writingModeSetOnDocumentElement(false)
 479     , m_writeRecursionIsTooDeep(false)
 480     , m_writeRecursionDepth(0)
 481     , m_wheelEventHandlerCount(0)
 482     , m_lastHandledUserGestureTimestamp(0)
 483 #if PLATFORM(IOS)
 484 #if ENABLE(DEVICE_ORIENTATION)
 485     , m_deviceMotionClient(DeviceMotionClientIOS::create())
 486     , m_deviceMotionController(DeviceMotionController::create(m_deviceMotionClient.get()))
 487     , m_deviceOrientationClient(DeviceOrientationClientIOS::create())
 488     , m_deviceOrientationController(DeviceOrientationController::create(m_deviceOrientationClient.get()))
 489 #endif
 490     , m_isTelephoneNumberParsingAllowed(true)
 491 #endif
 492     , m_pendingTasksTimer(this, &Document::pendingTasksTimerFired)
 493     , m_scheduledTasksAreSuspended(false)
 494     , m_visualUpdatesAllowed(true)
 495     , m_visualUpdatesSuppressionTimer(this, &Document::visualUpdatesSuppressionTimerFired)
 496     , m_sharedObjectPoolClearTimer(this, &Document::sharedObjectPoolClearTimerFired)
 497 #ifndef NDEBUG
 498     , m_didDispatchViewportPropertiesChanged(false)
 499 #endif
 500 #if ENABLE(TEMPLATE_ELEMENT)
 501     , m_templateDocumentHost(nullptr)
 502 #endif
 503 #if ENABLE(WEB_REPLAY)
 504     , m_inputCursor(EmptyInputCursor::create())
 505 #endif
 506     , m_didAssociateFormControlsTimer(this, &Document::didAssociateFormControlsTimerFired)
 507     , m_hasInjectedPlugInsScript(false)
 508     , m_renderTreeBeingDestroyed(false)
 509 {
 510     // We depend on the url getting immediately set in subframes, but we
 511     // also depend on the url NOT getting immediately set in opened windows.
 512     // See fast/dom/early-frame-url.html
 513     // and fast/dom/location-new-window-no-crash.html, respectively.
 514     // FIXME: Can/should we unify this behavior?
 515     if ((frame && frame->ownerElement()) || !url.isEmpty())
 516         setURL(url);
 517
 518     if (m_frame)
 519         m_cachedResourceLoader = &m_frame->loader().activeDocumentLoader()->cachedResourceLoader();
 520     if (!m_cachedResourceLoader)
 521         m_cachedResourceLoader = CachedResourceLoader::create(nullptr);
 522     m_cachedResourceLoader->setDocument(this);
 523
 524 #if ENABLE(TEXT_AUTOSIZING)
 525     m_textAutosizer = TextAutosizer::create(this);
 526 #endif
 527
 528     resetLinkColor();
 529     resetVisitedLinkColor();
 530     resetActiveLinkColor();
 531
 532     initSecurityContext();
 533     initDNSPrefetch();
 534
 535     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListAndCollectionCounts); ++i)
 536         m_nodeListAndCollectionCounts[i] = 0;
 537
 538     InspectorCounters::incrementCounter(InspectorCounters::DocumentCounter);
 539 }
 540
 541 static void histogramMutationEventUsage(const unsigned short& listenerTypes)
 542 {
 543     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMSubtreeModified", static_cast<bool>(listenerTypes & Document::DOMSUBTREEMODIFIED_LISTENER), 2);
 544     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeInserted", static_cast<bool>(listenerTypes & Document::DOMNODEINSERTED_LISTENER), 2);
 545     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeRemoved", static_cast<bool>(listenerTypes & Document::DOMNODEREMOVED_LISTENER), 2);
 546     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeRemovedFromDocument", static_cast<bool>(listenerTypes & Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER), 2);
 547     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMNodeInsertedIntoDocument", static_cast<bool>(listenerTypes & Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER), 2);
 548     HistogramSupport::histogramEnumeration("DOMAPI.PerDocumentMutationEventUsage.DOMCharacterDataModified", static_cast<bool>(listenerTypes & Document::DOMCHARACTERDATAMODIFIED_LISTENER), 2);
 549 }
 550
 551 #if ENABLE(FULLSCREEN_API)
 552 static bool isAttributeOnAllOwners(const WebCore::QualifiedName& attribute, const WebCore::QualifiedName& prefixedAttribute, const HTMLFrameOwnerElement* owner)
 553 {
 554     if (!owner)
 555         return true;
 556     do {
 557         if (!(owner->hasAttribute(attribute) || owner->hasAttribute(prefixedAttribute)))
 558             return false;
 559     } while ((owner = owner->document().ownerElement()));
 560     return true;
 561 }
 562 #endif
 563
 564 Document::~Document()
 565 {
 566     ASSERT(!renderView());
 567     ASSERT(!m_inPageCache);
 568     ASSERT(m_ranges.isEmpty());
 569     ASSERT(!m_parentTreeScope);
 570
 571 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(IOS)
 572     m_deviceMotionClient->deviceMotionControllerDestroyed();
 573     m_deviceOrientationClient->deviceOrientationControllerDestroyed();
 574 #endif
 575
 576 #if ENABLE(TEMPLATE_ELEMENT)
 577     if (m_templateDocument)
 578         m_templateDocument->setTemplateDocumentHost(nullptr); // balanced in templateDocument().
 579 #endif
 580
 581     // FIXME: Should we reset m_domWindow when we detach from the Frame?
 582     if (m_domWindow)
 583         m_domWindow->resetUnlessSuspendedForPageCache();
 584
 585     m_scriptRunner = nullptr;
 586
 587     histogramMutationEventUsage(m_listenerTypes);
 588
 589     removeAllEventListeners();
 590
 591     // Currently we believe that Document can never outlive the parser.
 592     // Although the Document may be replaced synchronously, DocumentParsers
 593     // generally keep at least one reference to an Element which would in turn
 594     // has a reference to the Document.  If you hit this ASSERT, then that
 595     // assumption is wrong.  DocumentParser::detach() should ensure that even
 596     // if the DocumentParser outlives the Document it won't cause badness.
 597     ASSERT(!m_parser || m_parser->refCount() == 1);
 598     detachParser();
 599
 600     if (this == &topDocument())
 601         clearAXObjectCache();
 602
 603     m_decoder = nullptr;
 604
 605     if (m_styleSheetList)
 606         m_styleSheetList->detachFromDocument();
 607
 608     if (m_elementSheet)
 609         m_elementSheet->detachFromDocument();
 610     m_styleSheetCollection.detachFromDocument();
 611
 612     clearStyleResolver(); // We need to destroy CSSFontSelector before destroying m_cachedResourceLoader.
 613
 614     // It's possible for multiple Documents to end up referencing the same CachedResourceLoader (e.g., SVGImages
 615     // load the initial empty document and the SVGDocument with the same DocumentLoader).
 616     if (m_cachedResourceLoader->document() == this)
 617         m_cachedResourceLoader->setDocument(nullptr);
 618     m_cachedResourceLoader.clear();
 619
 620     // We must call clearRareData() here since a Document class inherits TreeScope
 621     // as well as Node. See a comment on TreeScope.h for the reason.
 622     if (hasRareData())
 623         clearRareData();
 624
 625     ASSERT(!m_listsInvalidatedAtDocument.size());
 626     ASSERT(!m_collectionsInvalidatedAtDocument.size());
 627
 628     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(m_nodeListAndCollectionCounts); ++i)
 629         ASSERT(!m_nodeListAndCollectionCounts[i]);
 630
 631     clearDocumentScope();
 632
 633     InspectorCounters::decrementCounter(InspectorCounters::DocumentCounter);
 634 }
 635
 636 void Document::dropChildren()
 637 {
 638     ASSERT(!m_deletionHasBegun);
 639
 640     // We must make sure not to be retaining any of our children through
 641     // these extra pointers or we will create a reference cycle.
 642     m_focusedElement = nullptr;
 643     m_hoveredElement = nullptr;
 644     m_activeElement = nullptr;
 645     m_titleElement = nullptr;
 646     m_documentElement = nullptr;
 647     m_userActionElements.documentDidRemoveLastRef();
 648 #if ENABLE(FULLSCREEN_API)
 649     m_fullScreenElement = nullptr;
 650     m_fullScreenElementStack.clear();
 651 #endif
 652
 653     detachParser();
 654
 655     // removeDetachedChildren() doesn't always unregister IDs,
 656     // so tear down scope information up front to avoid having
 657     // stale references in the map.
 658
 659     destroyTreeScopeData();
 660     removeDetachedChildren();
 661     m_formController.clear();
 662
 663     m_markers->detach();
 664
 665     m_cssCanvasElements.clear();
 666
 667     commonTeardown();
 668 }
 669
 670 void Document::commonTeardown()
 671 {
 672 #if ENABLE(SVG)
 673     if (svgExtensions())
 674         accessSVGExtensions()->pauseAnimations();
 675 #endif
 676
 677 #if ENABLE(REQUEST_ANIMATION_FRAME)
 678     clearScriptedAnimationController();
 679 #endif
 680 }
 681
 682 Element* Document::getElementByAccessKey(const String& key)
 683 {
 684     if (key.isEmpty())
 685         return nullptr;
 686     if (!m_accessKeyMapValid) {
 687         buildAccessKeyMap(this);
 688         m_accessKeyMapValid = true;
 689     }
 690     return m_elementsByAccessKey.get(key.impl());
 691 }
 692
 693 void Document::buildAccessKeyMap(TreeScope* scope)
 694 {
 695     ASSERT(scope);
 696     ContainerNode* rootNode = scope->rootNode();
 697     for (auto& element : descendantsOfType<Element>(*rootNode)) {
 698         const AtomicString& accessKey = element.fastGetAttribute(accesskeyAttr);
 699         if (!accessKey.isEmpty())
 700             m_elementsByAccessKey.set(accessKey.impl(), &element);
 701
 702         if (ShadowRoot* root = element.shadowRoot())
 703             buildAccessKeyMap(root);
 704     }
 705 }
 706
 707 void Document::invalidateAccessKeyMap()
 708 {
 709     m_accessKeyMapValid = false;
 710     m_elementsByAccessKey.clear();
 711 }
 712
 713 void Document::addImageElementByLowercasedUsemap(const AtomicStringImpl& name, HTMLImageElement& element)
 714 {
 715     return m_imagesByUsemap.add(name, element, *this);
 716 }
 717
 718 void Document::removeImageElementByLowercasedUsemap(const AtomicStringImpl& name, HTMLImageElement& element)
 719 {
 720     return m_imagesByUsemap.remove(name, element);
 721 }
 722
 723 HTMLImageElement* Document::imageElementByLowercasedUsemap(const AtomicStringImpl& name) const
 724 {
 725     return m_imagesByUsemap.getElementByLowercasedUsemap(name, *this);
 726 }
 727
 728 SelectorQueryCache& Document::selectorQueryCache()
 729 {
 730     if (!m_selectorQueryCache)
 731         m_selectorQueryCache = adoptPtr(new SelectorQueryCache());
 732     return *m_selectorQueryCache;
 733 }
 734
 735 MediaQueryMatcher& Document::mediaQueryMatcher()
 736 {
 737     if (!m_mediaQueryMatcher)
 738         m_mediaQueryMatcher = MediaQueryMatcher::create(this);
 739     return *m_mediaQueryMatcher;
 740 }
 741
 742 void Document::setCompatibilityMode(CompatibilityMode mode)
 743 {
 744     if (m_compatibilityModeLocked || mode == m_compatibilityMode)
 745         return;
 746     bool wasInQuirksMode = inQuirksMode();
 747     m_compatibilityMode = mode;
 748
 749     if (m_selectorQueryCache)
 750         m_selectorQueryCache->invalidate();
 751
 752     if (inQuirksMode() != wasInQuirksMode) {
 753         // All user stylesheets have to reparse using the different mode.
 754         m_styleSheetCollection.clearPageUserSheet();
 755         m_styleSheetCollection.invalidateInjectedStyleSheetCache();
 756     }
 757 }
 758
 759 String Document::compatMode() const
 760 {
 761     return inQuirksMode() ? "BackCompat" : "CSS1Compat";
 762 }
 763
 764 void Document::resetLinkColor()
 765 {
 766     m_linkColor = Color(0, 0, 238);
 767 }
 768
 769 void Document::resetVisitedLinkColor()
 770 {
 771     m_visitedLinkColor = Color(85, 26, 139);
 772 }
 773
 774 void Document::resetActiveLinkColor()
 775 {
 776     m_activeLinkColor.setNamedColor("red");
 777 }
 778
 779 DOMImplementation* Document::implementation()
 780 {
 781     if (!m_implementation)
 782         m_implementation = DOMImplementation::create(*this);
 783     return m_implementation.get();
 784 }
 785
 786 bool Document::hasManifest() const
 787 {
 788     return documentElement() && documentElement()->hasTagName(htmlTag) && documentElement()->hasAttribute(manifestAttr);
 789 }
 790
 791 DocumentType* Document::doctype() const
 792 {
 793     for (Node* node = firstChild(); node; node = node->nextSibling()) {
 794         if (node->isDocumentTypeNode())
 795             return static_cast<DocumentType*>(node);
 796     }
 797     return nullptr;
 798 }
 799
 800 void Document::childrenChanged(const ChildChange& change)
 801 {
 802     ContainerNode::childrenChanged(change);
 803
 804     Element* newDocumentElement = childrenOfType<Element>(*this).first();
 805     if (newDocumentElement == m_documentElement)
 806         return;
 807     m_documentElement = newDocumentElement;
 808     // The root style used for media query matching depends on the document element.
 809     clearStyleResolver();
 810 }
 811
 812 PassRefPtr<Element> Document::createElement(const AtomicString& name, ExceptionCode& ec)
 813 {
 814     if (!isValidName(name)) {
 815         ec = INVALID_CHARACTER_ERR;
 816         return nullptr;
 817     }
 818
 819     if (isXHTMLDocument())
 820         return HTMLElementFactory::createElement(QualifiedName(nullAtom, name, xhtmlNamespaceURI), *this);
 821
 822     return createElement(QualifiedName(nullAtom, name, nullAtom), false);
 823 }
 824
 825 PassRefPtr<DocumentFragment> Document::createDocumentFragment()
 826 {
 827     return DocumentFragment::create(document());
 828 }
 829
 830 PassRefPtr<Text> Document::createTextNode(const String& data)
 831 {
 832     return Text::create(*this, data);
 833 }
 834
 835 PassRefPtr<Comment> Document::createComment(const String& data)
 836 {
 837     return Comment::create(*this, data);
 838 }
 839
 840 PassRefPtr<CDATASection> Document::createCDATASection(const String& data, ExceptionCode& ec)
 841 {
 842     if (isHTMLDocument()) {
 843         ec = NOT_SUPPORTED_ERR;
 844         return nullptr;
 845     }
 846     return CDATASection::create(*this, data);
 847 }
 848
 849 PassRefPtr<ProcessingInstruction> Document::createProcessingInstruction(const String& target, const String& data, ExceptionCode& ec)
 850 {
 851     if (!isValidName(target)) {
 852         ec = INVALID_CHARACTER_ERR;
 853         return nullptr;
 854     }
 855     if (isHTMLDocument()) {
 856         ec = NOT_SUPPORTED_ERR;
 857         return nullptr;
 858     }
 859     return ProcessingInstruction::create(*this, target, data);
 860 }
 861
 862 PassRefPtr<EntityReference> Document::createEntityReference(const String& name, ExceptionCode& ec)
 863 {
 864     if (!isValidName(name)) {
 865         ec = INVALID_CHARACTER_ERR;
 866         return nullptr;
 867     }
 868     if (isHTMLDocument()) {
 869         ec = NOT_SUPPORTED_ERR;
 870         return nullptr;
 871     }
 872     return EntityReference::create(*this, name);
 873 }
 874
 875 PassRefPtr<Text> Document::createEditingTextNode(const String& text)
 876 {
 877     return Text::createEditingText(*this, text);
 878 }
 879
 880 PassRefPtr<CSSStyleDeclaration> Document::createCSSStyleDeclaration()
 881 {
 882     Ref<MutableStyleProperties> propertySet(MutableStyleProperties::create());
 883     return propertySet->ensureCSSStyleDeclaration();
 884 }
 885
 886 PassRefPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionCode& ec)
 887 {
 888     ec = 0;
 889
 890     if (!importedNode) {
 891         ec = NOT_SUPPORTED_ERR;
 892         return nullptr;
 893     }
 894
 895     switch (importedNode->nodeType()) {
 896     case TEXT_NODE:
 897         return createTextNode(importedNode->nodeValue());
 898     case CDATA_SECTION_NODE:
 899         return createCDATASection(importedNode->nodeValue(), ec);
 900     case ENTITY_REFERENCE_NODE:
 901         return createEntityReference(importedNode->nodeName(), ec);
 902     case PROCESSING_INSTRUCTION_NODE:
 903         return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), ec);
 904     case COMMENT_NODE:
 905         return createComment(importedNode->nodeValue());
 906     case ELEMENT_NODE: {
 907         Element& oldElement = toElement(*importedNode);
 908         // FIXME: The following check might be unnecessary. Is it possible that
 909         // oldElement has mismatched prefix/namespace?
 910         if (!hasValidNamespaceForElements(oldElement.tagQName())) {
 911             ec = NAMESPACE_ERR;
 912             return nullptr;
 913         }
 914
 915         RefPtr<Element> newElement = createElement(oldElement.tagQName(), false);
 916         newElement->cloneDataFromElement(oldElement);
 917
 918         if (deep) {
 919             for (Node* oldChild = oldElement.firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
 920                 RefPtr<Node> newChild = importNode(oldChild, true, ec);
 921                 if (ec)
 922                     return nullptr;
 923                 newElement->appendChild(newChild.release(), ec);
 924                 if (ec)
 925                     return nullptr;
 926             }
 927         }
 928
 929         return newElement.release();
 930     }
 931     case ATTRIBUTE_NODE:
 932         return Attr::create(*this, QualifiedName(nullAtom, toAttr(*importedNode).name(), nullAtom), toAttr(*importedNode).value());
 933     case DOCUMENT_FRAGMENT_NODE: {
 934         if (importedNode->isShadowRoot()) {
 935             // ShadowRoot nodes should not be explicitly importable.
 936             // Either they are imported along with their host node, or created implicitly.
 937             break;
 938         }
 939         DocumentFragment& oldFragment = toDocumentFragment(*importedNode);
 940         RefPtr<DocumentFragment> newFragment = createDocumentFragment();
 941         if (deep) {
 942             for (Node* oldChild = oldFragment.firstChild(); oldChild; oldChild = oldChild->nextSibling()) {
 943                 RefPtr<Node> newChild = importNode(oldChild, true, ec);
 944                 if (ec)
 945                     return nullptr;
 946                 newFragment->appendChild(newChild.release(), ec);
 947                 if (ec)
 948                     return nullptr;
 949             }
 950         }
 951
 952         return newFragment.release();
 953     }
 954     case ENTITY_NODE:
 955     case NOTATION_NODE:
 956         // 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.
 957         // Ability to add these imported nodes to a DocumentType will be considered for addition to a future release of the DOM.
 958     case DOCUMENT_NODE:
 959     case DOCUMENT_TYPE_NODE:
 960     case XPATH_NAMESPACE_NODE:
 961         break;
 962     }
 963     ec = NOT_SUPPORTED_ERR;
 964     return nullptr;
 965 }
 966
 967
 968 PassRefPtr<Node> Document::adoptNode(PassRefPtr<Node> source, ExceptionCode& ec)
 969 {
 970     if (!source) {
 971         ec = NOT_SUPPORTED_ERR;
 972         return nullptr;
 973     }
 974
 975     if (source->isReadOnlyNode()) {
 976         ec = NO_MODIFICATION_ALLOWED_ERR;
 977         return nullptr;
 978     }
 979
 980     EventQueueScope scope;
 981
 982     switch (source->nodeType()) {
 983     case ENTITY_NODE:
 984     case NOTATION_NODE:
 985     case DOCUMENT_NODE:
 986     case DOCUMENT_TYPE_NODE:
 987     case XPATH_NAMESPACE_NODE:
 988         ec = NOT_SUPPORTED_ERR;
 989         return nullptr;
 990     case ATTRIBUTE_NODE: {
 991         Attr& attr = toAttr(*source);
 992         if (attr.ownerElement())
 993             attr.ownerElement()->removeAttributeNode(&attr, ec);
 994         break;
 995     }
 996     default:
 997         if (source->isShadowRoot()) {
 998             // ShadowRoot cannot disconnect itself from the host node.
 999             ec = HIERARCHY_REQUEST_ERR;
1000             return nullptr;
1001         }
1002         if (source->isFrameOwnerElement()) {
1003             HTMLFrameOwnerElement& frameOwnerElement = toHTMLFrameOwnerElement(*source);
1004             if (frame() && frame()->tree().isDescendantOf(frameOwnerElement.contentFrame())) {
1005                 ec = HIERARCHY_REQUEST_ERR;
1006                 return nullptr;
1007             }
1008         }
1009         if (source->parentNode()) {
1010             source->parentNode()->removeChild(source.get(), ec);
1011             if (ec)
1012                 return nullptr;
1013         }
1014     }
1015
1016     adoptIfNeeded(source.get());
1017
1018     return source;
1019 }
1020
1021 bool Document::hasValidNamespaceForElements(const QualifiedName& qName)
1022 {
1023     // These checks are from DOM Core Level 2, createElementNS
1024     // http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-DocCrElNS
1025     if (!qName.prefix().isEmpty() && qName.namespaceURI().isNull()) // createElementNS(null, "html:div")
1026         return false;
1027     if (qName.prefix() == xmlAtom && qName.namespaceURI() != XMLNames::xmlNamespaceURI) // createElementNS("http://www.example.com", "xml:lang")
1028         return false;
1029
1030     // Required by DOM Level 3 Core and unspecified by DOM Level 2 Core:
1031     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
1032     // createElementNS("http://www.w3.org/2000/xmlns/", "foo:bar"), createElementNS(null, "xmlns:bar"), createElementNS(null, "xmlns")
1033     if (qName.prefix() == xmlnsAtom || (qName.prefix().isEmpty() && qName.localName() == xmlnsAtom))
1034         return qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI;
1035     return qName.namespaceURI() != XMLNSNames::xmlnsNamespaceURI;
1036 }
1037
1038 bool Document::hasValidNamespaceForAttributes(const QualifiedName& qName)
1039 {
1040     return hasValidNamespaceForElements(qName);
1041 }
1042
1043 // FIXME: This should really be in a possible ElementFactory class.
1044 PassRefPtr<Element> Document::createElement(const QualifiedName& name, bool createdByParser)
1045 {
1046     RefPtr<Element> element;
1047
1048     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
1049     if (name.namespaceURI() == xhtmlNamespaceURI)
1050         element = HTMLElementFactory::createElement(name, *this, nullptr, createdByParser);
1051 #if ENABLE(SVG)
1052     else if (name.namespaceURI() == SVGNames::svgNamespaceURI)
1053         element = SVGElementFactory::createElement(name, *this, createdByParser);
1054 #endif
1055 #if ENABLE(MATHML)
1056     else if (name.namespaceURI() == MathMLNames::mathmlNamespaceURI)
1057         element = MathMLElementFactory::createElement(name, *this, createdByParser);
1058 #endif
1059
1060     if (element)
1061         m_sawElementsInKnownNamespaces = true;
1062     else
1063         element = Element::create(name, document());
1064
1065     // <image> uses imgTag so we need a special rule.
1066     ASSERT((name.matches(imageTag) && element->tagQName().matches(imgTag) && element->tagQName().prefix() == name.prefix()) || name == element->tagQName());
1067
1068     return element.release();
1069 }
1070
1071 bool Document::regionBasedColumnsEnabled() const
1072 {
1073     return settings() && settings()->regionBasedColumnsEnabled();
1074 }
1075
1076 bool Document::cssStickyPositionEnabled() const
1077 {
1078     return settings() && settings()->cssStickyPositionEnabled();
1079 }
1080
1081 bool Document::cssRegionsEnabled() const
1082 {
1083     return RuntimeEnabledFeatures::sharedFeatures().cssRegionsEnabled();
1084 }
1085
1086 bool Document::cssCompositingEnabled() const
1087 {
1088     return RuntimeEnabledFeatures::sharedFeatures().cssCompositingEnabled();
1089 }
1090
1091 bool Document::cssGridLayoutEnabled() const
1092 {
1093     return settings() && settings()->cssGridLayoutEnabled();
1094 }
1095
1096 #if ENABLE(CSS_REGIONS)
1097
1098 PassRefPtr<DOMNamedFlowCollection> Document::webkitGetNamedFlows()
1099 {
1100     if (!cssRegionsEnabled() || !renderView())
1101         return nullptr;
1102
1103     updateStyleIfNeeded();
1104
1105     return namedFlows()->createCSSOMSnapshot();
1106 }
1107
1108 #endif
1109
1110 NamedFlowCollection* Document::namedFlows()
1111 {
1112     if (!m_namedFlows)
1113         m_namedFlows = NamedFlowCollection::create(this);
1114
1115     return m_namedFlows.get();
1116 }
1117
1118 PassRefPtr<Element> Document::createElementNS(const String& namespaceURI, const String& qualifiedName, ExceptionCode& ec)
1119 {
1120     String prefix, localName;
1121     if (!parseQualifiedName(qualifiedName, prefix, localName, ec))
1122         return nullptr;
1123
1124     QualifiedName qName(prefix, localName, namespaceURI);
1125     if (!hasValidNamespaceForElements(qName)) {
1126         ec = NAMESPACE_ERR;
1127         return nullptr;
1128     }
1129
1130     return createElement(qName, false);
1131 }
1132
1133 String Document::readyState() const
1134 {
1135     DEFINE_STATIC_LOCAL(const String, loading, (ASCIILiteral("loading")));
1136     DEFINE_STATIC_LOCAL(const String, interactive, (ASCIILiteral("interactive")));
1137     DEFINE_STATIC_LOCAL(const String, complete, (ASCIILiteral("complete")));
1138
1139     switch (m_readyState) {
1140     case Loading:
1141         return loading;
1142     case Interactive:
1143         return interactive;
1144     case Complete:
1145         return complete;
1146     }
1147
1148     ASSERT_NOT_REACHED();
1149     return String();
1150 }
1151
1152 void Document::setReadyState(ReadyState readyState)
1153 {
1154     if (readyState == m_readyState)
1155         return;
1156
1157 #if ENABLE(WEB_TIMING)
1158     switch (readyState) {
1159     case Loading:
1160         if (!m_documentTiming.domLoading)
1161             m_documentTiming.domLoading = monotonicallyIncreasingTime();
1162         break;
1163     case Interactive:
1164         if (!m_documentTiming.domInteractive)
1165             m_documentTiming.domInteractive = monotonicallyIncreasingTime();
1166         break;
1167     case Complete:
1168         if (!m_documentTiming.domComplete)
1169             m_documentTiming.domComplete = monotonicallyIncreasingTime();
1170         break;
1171     }
1172 #endif
1173
1174     m_readyState = readyState;
1175     dispatchEvent(Event::create(eventNames().readystatechangeEvent, false, false));
1176
1177     if (settings() && settings()->suppressesIncrementalRendering())
1178         setVisualUpdatesAllowed(readyState);
1179 }
1180
1181 void Document::setVisualUpdatesAllowed(ReadyState readyState)
1182 {
1183     ASSERT(settings() && settings()->suppressesIncrementalRendering());
1184     switch (readyState) {
1185     case Loading:
1186         ASSERT(!m_visualUpdatesSuppressionTimer.isActive());
1187         ASSERT(m_visualUpdatesAllowed);
1188         setVisualUpdatesAllowed(false);
1189         break;
1190     case Interactive:
1191         ASSERT(m_visualUpdatesSuppressionTimer.isActive() || m_visualUpdatesAllowed);
1192         break;
1193     case Complete:
1194         if (m_visualUpdatesSuppressionTimer.isActive()) {
1195             ASSERT(!m_visualUpdatesAllowed);
1196
1197             if (!view()->visualUpdatesAllowedByClient())
1198                 return;
1199
1200             setVisualUpdatesAllowed(true);
1201         } else
1202             ASSERT(m_visualUpdatesAllowed);
1203         break;
1204     }
1205 }
1206
1207 void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)
1208 {
1209     if (m_visualUpdatesAllowed == visualUpdatesAllowed)
1210         return;
1211
1212     m_visualUpdatesAllowed = visualUpdatesAllowed;
1213
1214     if (visualUpdatesAllowed)
1215         m_visualUpdatesSuppressionTimer.stop();
1216     else
1217         m_visualUpdatesSuppressionTimer.startOneShot(settings()->incrementalRenderingSuppressionTimeoutInSeconds());
1218
1219     if (!visualUpdatesAllowed)
1220         return;
1221
1222     FrameView* frameView = view();
1223     bool needsLayout = frameView && renderView() && (frameView->layoutPending() || renderView()->needsLayout());
1224     if (needsLayout)
1225         updateLayout();
1226
1227     if (Page* page = this->page()) {
1228         if (frame()->isMainFrame()) {
1229             frameView->addPaintPendingMilestones(DidFirstPaintAfterSuppressedIncrementalRendering);
1230             if (page->requestedLayoutMilestones() & DidFirstLayoutAfterSuppressedIncrementalRendering)
1231                 frame()->loader().didLayout(DidFirstLayoutAfterSuppressedIncrementalRendering);
1232         }
1233     }
1234
1235     if (view())
1236         view()->updateCompositingLayersAfterLayout();
1237
1238     if (RenderView* renderView = this->renderView())
1239         renderView->repaintViewAndCompositedLayers();
1240
1241     if (Frame* frame = this->frame())
1242         frame->loader().forcePageTransitionIfNeeded();
1243 }
1244
1245 void Document::visualUpdatesSuppressionTimerFired(Timer<Document>&)
1246 {
1247     ASSERT(!m_visualUpdatesAllowed);
1248
1249     // If the client is extending the visual update suppression period explicitly, the
1250     // watchdog should not re-enable visual updates itself, but should wait for the client.
1251     if (!view()->visualUpdatesAllowedByClient())
1252         return;
1253
1254     setVisualUpdatesAllowed(true);
1255 }
1256
1257 void Document::setVisualUpdatesAllowedByClient(bool visualUpdatesAllowedByClient)
1258 {
1259     // We should only re-enable visual updates if ReadyState is Completed or the watchdog timer has fired,
1260     // both of which we can determine by looking at the timer.
1261
1262     if (visualUpdatesAllowedByClient && !m_visualUpdatesSuppressionTimer.isActive() && !visualUpdatesAllowed())
1263         setVisualUpdatesAllowed(true);
1264 }
1265
1266 AtomicString Document::encoding() const
1267 {
1268     if (TextResourceDecoder* d = decoder())
1269         return d->encoding().domName();
1270     return String();
1271 }
1272
1273 String Document::defaultCharset() const
1274 {
1275     if (Settings* settings = this->settings())
1276         return settings->defaultTextEncodingName();
1277     return String();
1278 }
1279
1280 void Document::setCharset(const String& charset)
1281 {
1282     if (!decoder())
1283         return;
1284     decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
1285 }
1286
1287 void Document::setContentLanguage(const String& language)
1288 {
1289     if (m_contentLanguage == language)
1290         return;
1291     m_contentLanguage = language;
1292
1293     // Recalculate style so language is used when selecting the initial font.
1294     styleResolverChanged(DeferRecalcStyle);
1295 }
1296
1297 void Document::setXMLVersion(const String& version, ExceptionCode& ec)
1298 {
1299     if (!implementation()->hasFeature("XML", String())) {
1300         ec = NOT_SUPPORTED_ERR;
1301         return;
1302     }
1303
1304     if (!XMLDocumentParser::supportsXMLVersion(version)) {
1305         ec = NOT_SUPPORTED_ERR;
1306         return;
1307     }
1308
1309     m_xmlVersion = version;
1310 }
1311
1312 void Document::setXMLStandalone(bool standalone, ExceptionCode& ec)
1313 {
1314     if (!implementation()->hasFeature("XML", String())) {
1315         ec = NOT_SUPPORTED_ERR;
1316         return;
1317     }
1318
1319     m_xmlStandalone = standalone ? Standalone : NotStandalone;
1320 }
1321
1322 void Document::setDocumentURI(const String& uri)
1323 {
1324     // This property is read-only from JavaScript, but writable from Objective-C.
1325     m_documentURI = uri;
1326     updateBaseURL();
1327 }
1328
1329 URL Document::baseURI() const
1330 {
1331     return m_baseURL;
1332 }
1333
1334 void Document::setContent(const String& content)
1335 {
1336     open();
1337     // FIXME: This should probably use insert(), but that's (intentionally)
1338     // not implemented for the XML parser as it's normally synonymous with
1339     // document.write(). append() will end up yielding, but close() will
1340     // pump the tokenizer syncrhonously and finish the parse.
1341     m_parser->append(content.impl());
1342     close();
1343 }
1344
1345 String Document::suggestedMIMEType() const
1346 {
1347     if (isXHTMLDocument())
1348         return ASCIILiteral("application/xhtml+xml");
1349     if (isSVGDocument())
1350         return ASCIILiteral("image/svg+xml");
1351     if (xmlStandalone())
1352         return ASCIILiteral("text/xml");
1353     if (isHTMLDocument())
1354         return ASCIILiteral("text/html");
1355     if (DocumentLoader* loader = this->loader())
1356         return loader->responseMIMEType();
1357     return String();
1358 }
1359
1360 Element* Document::elementFromPoint(int x, int y) const
1361 {
1362     if (!hasLivingRenderTree())
1363         return nullptr;
1364
1365     return TreeScope::elementFromPoint(x, y);
1366 }
1367
1368 PassRefPtr<Range> Document::caretRangeFromPoint(int x, int y)
1369 {
1370     if (!hasLivingRenderTree())
1371         return nullptr;
1372     LayoutPoint localPoint;
1373     Node* node = nodeFromPoint(this, x, y, &localPoint);
1374     if (!node)
1375         return nullptr;
1376
1377     Node* shadowAncestorNode = ancestorInThisScope(node);
1378     if (shadowAncestorNode != node) {
1379         unsigned offset = shadowAncestorNode->nodeIndex();
1380         ContainerNode* container = shadowAncestorNode->parentNode();
1381         return Range::create(*this, container, offset, container, offset);
1382     }
1383
1384     RenderObject* renderer = node->renderer();
1385     if (!renderer)
1386         return nullptr;
1387     VisiblePosition visiblePosition = renderer->positionForPoint(localPoint);
1388     if (visiblePosition.isNull())
1389         return nullptr;
1390
1391     Position rangeCompliantPosition = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
1392     return Range::create(*this, rangeCompliantPosition, rangeCompliantPosition);
1393 }
1394
1395 /*
1396  * Performs three operations:
1397  *  1. Convert control characters to spaces
1398  *  2. Trim leading and trailing spaces
1399  *  3. Collapse internal whitespace.
1400  */
1401 template <typename CharacterType>
1402 static inline StringWithDirection canonicalizedTitle(Document* document, const StringWithDirection& titleWithDirection)
1403 {
1404     const String& title = titleWithDirection.string();
1405     const CharacterType* characters = title.getCharacters<CharacterType>();
1406     unsigned length = title.length();
1407     unsigned i;
1408
1409     StringBuffer<CharacterType> buffer(length);
1410     unsigned builderIndex = 0;
1411
1412     // Skip leading spaces and leading characters that would convert to spaces
1413     for (i = 0; i < length; ++i) {
1414         CharacterType c = characters[i];
1415         if (!(c <= 0x20 || c == 0x7F))
1416             break;
1417     }
1418
1419     if (i == length)
1420         return StringWithDirection();
1421
1422     // Replace control characters with spaces, and backslashes with currency symbols, and collapse whitespace.
1423     bool previousCharWasWS = false;
1424     for (; i < length; ++i) {
1425         CharacterType c = characters[i];
1426         if (c <= 0x20 || c == 0x7F || (U_GET_GC_MASK(c) & (U_GC_ZL_MASK | U_GC_ZP_MASK))) {
1427             if (previousCharWasWS)
1428                 continue;
1429             buffer[builderIndex++] = ' ';
1430             previousCharWasWS = true;
1431         } else {
1432             buffer[builderIndex++] = c;
1433             previousCharWasWS = false;
1434         }
1435     }
1436
1437     // Strip trailing spaces
1438     while (builderIndex > 0) {
1439         --builderIndex;
1440         if (buffer[builderIndex] != ' ')
1441             break;
1442     }
1443
1444     if (!builderIndex && buffer[builderIndex] == ' ')
1445         return StringWithDirection();
1446
1447     buffer.shrink(builderIndex + 1);
1448
1449     // Replace the backslashes with currency symbols if the encoding requires it.
1450     document->displayBufferModifiedByEncoding(buffer.characters(), buffer.length());
1451
1452     return StringWithDirection(String::adopt(buffer), titleWithDirection.direction());
1453 }
1454
1455 void Document::updateTitle(const StringWithDirection& title)
1456 {
1457     if (m_rawTitle == title)
1458         return;
1459
1460     m_rawTitle = title;
1461
1462     if (m_rawTitle.string().isEmpty())
1463         m_title = StringWithDirection();
1464     else {
1465         if (m_rawTitle.string().is8Bit())
1466             m_title = canonicalizedTitle<LChar>(this, m_rawTitle);
1467         else
1468             m_title = canonicalizedTitle<UChar>(this, m_rawTitle);
1469     }
1470     if (DocumentLoader* loader = this->loader())
1471         loader->setTitle(m_title);
1472 }
1473
1474 void Document::setTitle(const String& title)
1475 {
1476     // Title set by JavaScript -- overrides any title elements.
1477     m_titleSetExplicitly = true;
1478     if (!isHTMLDocument() && !isXHTMLDocument())
1479         m_titleElement = nullptr;
1480     else if (!m_titleElement) {
1481         if (HTMLElement* headElement = head()) {
1482             m_titleElement = createElement(titleTag, false);
1483             headElement->appendChild(m_titleElement, ASSERT_NO_EXCEPTION);
1484         }
1485     }
1486
1487     // The DOM API has no method of specifying direction, so assume LTR.
1488     updateTitle(StringWithDirection(title, LTR));
1489
1490     if (m_titleElement && isHTMLTitleElement(m_titleElement.get()))
1491         toHTMLTitleElement(m_titleElement.get())->setText(title);
1492 }
1493
1494 void Document::setTitleElement(const StringWithDirection& title, Element* titleElement)
1495 {
1496     if (titleElement != m_titleElement) {
1497         if (m_titleElement || m_titleSetExplicitly) {
1498             // Only allow the first title element to change the title -- others have no effect.
1499             return;
1500         }
1501         m_titleElement = titleElement;
1502     }
1503
1504     updateTitle(title);
1505 }
1506
1507 void Document::removeTitle(Element* titleElement)
1508 {
1509     if (m_titleElement != titleElement)
1510         return;
1511
1512     m_titleElement = nullptr;
1513     m_titleSetExplicitly = false;
1514
1515     // Update title based on first title element in the head, if one exists.
1516     if (HTMLElement* headElement = head()) {
1517         if (auto firstTitle = childrenOfType<HTMLTitleElement>(*headElement).first())
1518             setTitleElement(firstTitle->textWithDirection(), firstTitle);
1519     }
1520
1521     if (!m_titleElement)
1522         updateTitle(StringWithDirection());
1523 }
1524
1525 #if ENABLE(PAGE_VISIBILITY_API)
1526 void Document::registerForVisibilityStateChangedCallbacks(Element* element)
1527 {
1528     m_visibilityStateCallbackElements.add(element);
1529 }
1530
1531 void Document::unregisterForVisibilityStateChangedCallbacks(Element* element)
1532 {
1533     m_visibilityStateCallbackElements.remove(element);
1534 }
1535
1536 void Document::visibilityStateChanged()
1537 {
1538     dispatchEvent(Event::create(eventNames().visibilitychangeEvent, false, false));
1539     for (auto it = m_visibilityStateCallbackElements.begin(); it != m_visibilityStateCallbackElements.end(); ++it)
1540         (*it)->visibilityStateChanged();
1541 }
1542
1543 PageVisibilityState Document::pageVisibilityState() const
1544 {
1545     // The visibility of the document is inherited from the visibility of the
1546     // page. If there is no page associated with the document, we will assume
1547     // that the page is hidden, as specified by the spec:
1548     // http://dvcs.w3.org/hg/webperf/raw-file/tip/specs/PageVisibility/Overview.html#dom-document-hidden
1549     if (!m_frame || !m_frame->page())
1550         return PageVisibilityStateHidden;
1551     return m_frame->page()->visibilityState();
1552 }
1553
1554 String Document::visibilityState() const
1555 {
1556     return pageVisibilityStateString(pageVisibilityState());
1557 }
1558
1559 bool Document::hidden() const
1560 {
1561     return pageVisibilityState() != PageVisibilityStateVisible;
1562 }
1563 #endif
1564
1565 #if ENABLE(CSP_NEXT)
1566 DOMSecurityPolicy* Document::securityPolicy()
1567 {
1568     if (!m_domSecurityPolicy)
1569         m_domSecurityPolicy = DOMSecurityPolicy::create(this);
1570     return m_domSecurityPolicy.get();
1571 }
1572 #endif
1573
1574 String Document::nodeName() const
1575 {
1576     return "#document";
1577 }
1578
1579 Node::NodeType Document::nodeType() const
1580 {
1581     return DOCUMENT_NODE;
1582 }
1583
1584 FormController& Document::formController()
1585 {
1586     if (!m_formController)
1587         m_formController = FormController::create();
1588     return *m_formController;
1589 }
1590
1591 Vector<String> Document::formElementsState() const
1592 {
1593     if (!m_formController)
1594         return Vector<String>();
1595     return m_formController->formElementsState();
1596 }
1597
1598 void Document::setStateForNewFormElements(const Vector<String>& stateVector)
1599 {
1600     if (!stateVector.size() && !m_formController)
1601         return;
1602     formController().setStateForNewFormElements(stateVector);
1603 }
1604
1605 FrameView* Document::view() const
1606 {
1607     return m_frame ? m_frame->view() : nullptr;
1608 }
1609
1610 Page* Document::page() const
1611 {
1612     return m_frame ? m_frame->page() : nullptr;
1613 }
1614
1615 Settings* Document::settings() const
1616 {
1617     return m_frame ? &m_frame->settings() : nullptr;
1618 }
1619
1620 PassRefPtr<Range> Document::createRange()
1621 {
1622     return Range::create(*this);
1623 }
1624
1625 PassRefPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow,
1626     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
1627 {
1628     if (!root) {
1629         ec = NOT_SUPPORTED_ERR;
1630         return nullptr;
1631     }
1632     return NodeIterator::create(root, whatToShow, filter, expandEntityReferences);
1633 }
1634
1635 PassRefPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow,
1636     PassRefPtr<NodeFilter> filter, bool expandEntityReferences, ExceptionCode& ec)
1637 {
1638     if (!root) {
1639         ec = NOT_SUPPORTED_ERR;
1640         return nullptr;
1641     }
1642     return TreeWalker::create(root, whatToShow, filter, expandEntityReferences);
1643 }
1644
1645 void Document::scheduleForcedStyleRecalc()
1646 {
1647     m_pendingStyleRecalcShouldForce = true;
1648     scheduleStyleRecalc();
1649 }
1650
1651 void Document::scheduleStyleRecalc()
1652 {
1653     if (shouldDisplaySeamlesslyWithParent()) {
1654         // When we're seamless, our parent document manages our style recalcs.
1655         ownerElement()->setNeedsStyleRecalc();
1656         ownerElement()->document().scheduleStyleRecalc();
1657         return;
1658     }
1659
1660     if (m_styleRecalcTimer.isActive() || inPageCache())
1661         return;
1662
1663     ASSERT(childNeedsStyleRecalc() || m_pendingStyleRecalcShouldForce);
1664
1665     // FIXME: Why on earth is this here? This is clearly misplaced.
1666     invalidateAccessKeyMap();
1667
1668     m_styleRecalcTimer.startOneShot(0);
1669
1670     InspectorInstrumentation::didScheduleStyleRecalculation(this);
1671 }
1672
1673 void Document::unscheduleStyleRecalc()
1674 {
1675     ASSERT(!childNeedsStyleRecalc());
1676
1677     m_styleRecalcTimer.stop();
1678     m_pendingStyleRecalcShouldForce = false;
1679 }
1680
1681 bool Document::hasPendingStyleRecalc() const
1682 {
1683     return m_styleRecalcTimer.isActive() && !m_inStyleRecalc;
1684 }
1685
1686 bool Document::hasPendingForcedStyleRecalc() const
1687 {
1688     return m_styleRecalcTimer.isActive() && m_pendingStyleRecalcShouldForce;
1689 }
1690
1691 void Document::styleRecalcTimerFired(Timer<Document>&)
1692 {
1693     updateStyleIfNeeded();
1694 }
1695
1696 void Document::recalcStyle(Style::Change change)
1697 {
1698     ASSERT(!view() || !view()->isPainting());
1699
1700     // NOTE: XSL code seems to be the only client stumbling in here without a RenderView.
1701     if (!m_renderView)
1702         return;
1703
1704     FrameView& frameView = m_renderView->frameView();
1705     if (frameView.isPainting())
1706         return;
1707
1708     if (m_inStyleRecalc)
1709         return; // Guard against re-entrancy. -dwh
1710
1711     RenderView::RepaintRegionAccumulator repaintRegionAccumulator(renderView());
1712
1713     // FIXME: We should update style on our ancestor chain before proceeding (especially for seamless),
1714     // however doing so currently causes several tests to crash, as Frame::setDocument calls Document::attach
1715     // before setting the DOMWindow on the Frame, or the SecurityOrigin on the document. The attach, in turn
1716     // resolves style (here) and then when we resolve style on the parent chain, we may end up
1717     // re-attaching our containing iframe, which when asked HTMLFrameElementBase::isURLAllowed
1718     // hits a null-dereference due to security code always assuming the document has a SecurityOrigin.
1719
1720     m_styleSheetCollection.flushPendingUpdates();
1721
1722     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willRecalculateStyle(this);
1723
1724     if (m_elementSheet && m_elementSheet->contents().usesRemUnits())
1725         m_styleSheetCollection.setUsesRemUnit(true);
1726
1727     m_inStyleRecalc = true;
1728     {
1729         PostAttachCallbackDisabler disabler(*this);
1730         WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1731
1732         if (m_pendingStyleRecalcShouldForce)
1733             change = Style::Force;
1734
1735         if (change == Style::Force) {
1736             // This may get set again during style resolve.
1737             m_hasNodesWithPlaceholderStyle = false;
1738         }
1739
1740         Style::resolveTree(*this, change);
1741
1742         frameView.updateCompositingLayersAfterStyleChange();
1743
1744         clearNeedsStyleRecalc();
1745         clearChildNeedsStyleRecalc();
1746         unscheduleStyleRecalc();
1747
1748         m_inStyleRecalc = false;
1749
1750         // Pseudo element removal and similar may only work with these flags still set. Reset them after the style recalc.
1751         if (m_styleResolver)
1752             m_styleSheetCollection.resetCSSFeatureFlags();
1753     }
1754
1755     // If we wanted to call implicitClose() during recalcStyle, do so now that we're finished.
1756     if (m_closeAfterStyleRecalc) {
1757         m_closeAfterStyleRecalc = false;
1758         implicitClose();
1759     }
1760
1761     InspectorInstrumentation::didRecalculateStyle(cookie);
1762
1763     // As a result of the style recalculation, the currently hovered element might have been
1764     // detached (for example, by setting display:none in the :hover style), schedule another mouseMove event
1765     // to check if any other elements ended up under the mouse pointer due to re-layout.
1766     if (m_hoveredElement && !m_hoveredElement->renderer())
1767         frameView.frame().eventHandler().dispatchFakeMouseMoveEventSoon();
1768
1769     // Style change may reset the focus, e.g. display: none, visibility: hidden.
1770     resetHiddenFocusElementSoon();
1771 }
1772
1773 void Document::updateStyleIfNeeded()
1774 {
1775     ASSERT(isMainThread());
1776     ASSERT(!view() || !view()->isPainting());
1777
1778     if (!view() || view()->isInLayout())
1779         return;
1780
1781     if (m_optimizedStyleSheetUpdateTimer.isActive())
1782         styleResolverChanged(RecalcStyleIfNeeded);
1783
1784     if ((!m_pendingStyleRecalcShouldForce && !childNeedsStyleRecalc()) || inPageCache())
1785         return;
1786
1787     AnimationUpdateBlock animationUpdateBlock(m_frame ? &m_frame->animation() : nullptr);
1788     recalcStyle(Style::NoChange);
1789 }
1790
1791 void Document::updateLayout()
1792 {
1793     ASSERT(isMainThread());
1794
1795     FrameView* frameView = view();
1796     if (frameView && frameView->isInLayout()) {
1797         // View layout should not be re-entrant.
1798         ASSERT_NOT_REACHED();
1799         return;
1800     }
1801
1802     RenderView::RepaintRegionAccumulator repaintRegionAccumulator(renderView());
1803
1804     if (Element* oe = ownerElement())
1805         oe->document().updateLayout();
1806
1807     updateStyleIfNeeded();
1808
1809     StackStats::LayoutCheckPoint layoutCheckPoint;
1810
1811     // Only do a layout if changes have occurred that make it necessary.
1812     if (frameView && renderView() && (frameView->layoutPending() || renderView()->needsLayout()))
1813         frameView->layout();
1814
1815     // Active focus element's isFocusable() state may change after Layout. e.g. width: 0px or height: 0px.
1816     resetHiddenFocusElementSoon();
1817 }
1818
1819 // FIXME: This is a bad idea and needs to be removed eventually.
1820 // Other browsers load stylesheets before they continue parsing the web page.
1821 // Since we don't, we can run JavaScript code that needs answers before the
1822 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
1823 // lets us get reasonable answers. The long term solution to this problem is
1824 // to instead suspend JavaScript execution.
1825 void Document::updateLayoutIgnorePendingStylesheets()
1826 {
1827     bool oldIgnore = m_ignorePendingStylesheets;
1828
1829     if (!haveStylesheetsLoaded()) {
1830         m_ignorePendingStylesheets = true;
1831         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.  Our assumption is that it would be
1832         // dangerous to try to stop it a second time, after page content has already been loaded and displayed
1833         // with accurate style information.  (Our suppression involves blanking the whole page at the
1834         // moment.  If it were more refined, we might be able to do something better.)
1835         // It's worth noting though that this entire method is a hack, since what we really want to do is
1836         // suspend JS instead of doing a layout with inaccurate information.
1837         HTMLElement* bodyElement = body();
1838         if (bodyElement && !bodyElement->renderer() && m_pendingSheetLayout == NoLayoutWithPendingSheets) {
1839             m_pendingSheetLayout = DidLayoutWithPendingSheets;
1840             styleResolverChanged(RecalcStyleImmediately);
1841         } else if (m_hasNodesWithPlaceholderStyle)
1842             // If new nodes have been added or style recalc has been done with style sheets still pending, some nodes
1843             // may not have had their real style calculated yet. Normally this gets cleaned when style sheets arrive
1844             // but here we need up-to-date style immediately.
1845             recalcStyle(Style::Force);
1846     }
1847
1848     updateLayout();
1849
1850     m_ignorePendingStylesheets = oldIgnore;
1851 }
1852
1853 PassRef<RenderStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
1854 {
1855     ASSERT_ARG(element, &element->document() == this);
1856
1857     // On iOS request delegates called during styleForElement may result in re-entering WebKit and killing the style resolver.
1858     ResourceLoadScheduler::Suspender suspender(*platformStrategies()->loaderStrategy()->resourceLoadScheduler());
1859
1860     TemporaryChange<bool> change(m_ignorePendingStylesheets, true);
1861     return ensureStyleResolver().styleForElement(element, element->parentNode() ? element->parentNode()->computedStyle() : nullptr);
1862 }
1863
1864 bool Document::isPageBoxVisible(int pageIndex)
1865 {
1866     Ref<RenderStyle> pageStyle(ensureStyleResolver().styleForPage(pageIndex));
1867     return pageStyle->visibility() != HIDDEN; // display property doesn't apply to @page.
1868 }
1869
1870 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
1871 {
1872     RefPtr<RenderStyle> style = ensureStyleResolver().styleForPage(pageIndex);
1873     RenderView* view = renderView();
1874
1875     int width = pageSize.width();
1876     int height = pageSize.height();
1877     switch (style->pageSizeType()) {
1878     case PAGE_SIZE_AUTO:
1879         break;
1880     case PAGE_SIZE_AUTO_LANDSCAPE:
1881         if (width < height)
1882             std::swap(width, height);
1883         break;
1884     case PAGE_SIZE_AUTO_PORTRAIT:
1885         if (width > height)
1886             std::swap(width, height);
1887         break;
1888     case PAGE_SIZE_RESOLVED: {
1889         LengthSize size = style->pageSize();
1890         ASSERT(size.width().isFixed());
1891         ASSERT(size.height().isFixed());
1892         width = valueForLength(size.width(), 0, view);
1893         height = valueForLength(size.height(), 0, view);
1894         break;
1895     }
1896     default:
1897         ASSERT_NOT_REACHED();
1898     }
1899     pageSize = IntSize(width, height);
1900
1901     // The percentage is calculated with respect to the width even for margin top and bottom.
1902     // http://www.w3.org/TR/CSS2/box.html#margin-properties
1903     marginTop = style->marginTop().isAuto() ? marginTop : intValueForLength(style->marginTop(), width, view);
1904     marginRight = style->marginRight().isAuto() ? marginRight : intValueForLength(style->marginRight(), width, view);
1905     marginBottom = style->marginBottom().isAuto() ? marginBottom : intValueForLength(style->marginBottom(), width, view);
1906     marginLeft = style->marginLeft().isAuto() ? marginLeft : intValueForLength(style->marginLeft(), width, view);
1907 }
1908
1909 void Document::setIsViewSource(bool isViewSource)
1910 {
1911     m_isViewSource = isViewSource;
1912     if (!m_isViewSource)
1913         return;
1914
1915     setSecurityOrigin(SecurityOrigin::createUnique());
1916 }
1917
1918 void Document::createStyleResolver()
1919 {
1920     bool matchAuthorAndUserStyles = true;
1921     if (Settings* settings = this->settings())
1922         matchAuthorAndUserStyles = settings->authorAndUserStylesEnabled();
1923     m_styleResolver = adoptPtr(new StyleResolver(*this, matchAuthorAndUserStyles));
1924     m_styleSheetCollection.combineCSSFeatureFlags();
1925 }
1926
1927 void Document::clearStyleResolver()
1928 {
1929     m_styleResolver.clear();
1930 }
1931
1932 void Document::createRenderTree()
1933 {
1934     ASSERT(!renderView());
1935     ASSERT(!m_inPageCache);
1936     ASSERT(!m_axObjectCache || this != &topDocument());
1937
1938     if (m_isNonRenderedPlaceholder)
1939         return;
1940
1941     // FIXME: It would be better if we could pass the resolved document style directly here.
1942     m_renderView = createRenderer<RenderView>(*this, RenderStyle::create());
1943     Node::setRenderer(m_renderView.get());
1944
1945     renderView()->setIsInWindow(true);
1946
1947     recalcStyle(Style::Force);
1948 }
1949
1950 static void pageWheelEventHandlerCountChanged(Page& page)
1951 {
1952     unsigned count = 0;
1953     for (const Frame* frame = &page.mainFrame(); frame; frame = frame->tree().traverseNext()) {
1954         if (Document* document = frame->document())
1955             count += document->wheelEventHandlerCount();
1956     }
1957     page.chrome().client().numWheelEventHandlersChanged(count);
1958 }
1959
1960 void Document::didBecomeCurrentDocumentInFrame()
1961 {
1962     // FIXME: Are there cases where the document can be dislodged from the frame during the event handling below?
1963     // If so, then m_frame could become 0, and we need to do something about that.
1964
1965     m_frame->script().updateDocument();
1966
1967     if (!hasLivingRenderTree())
1968         createRenderTree();
1969
1970     updateViewportArguments();
1971
1972     // FIXME: Doing this only for the main frame is insufficient.
1973     // Changing a subframe can also change the wheel event handler count.
1974     // FIXME: Doing this only when a document goes into the frame is insufficient.
1975     // Removing a document can also change the wheel event handler count.
1976     // FIXME: Doing this every time is a waste. If the current document and its
1977     // subframes' documents have no wheel event handlers, then the count did not change,
1978     // unless the documents they are replacing had wheel event handlers.
1979     if (page() && m_frame->isMainFrame())
1980         pageWheelEventHandlerCountChanged(*page());
1981
1982 #if ENABLE(TOUCH_EVENTS)
1983     // FIXME: Doing this only for the main frame is insufficient.
1984     // A subframe could have touch event handlers.
1985     if (hasTouchEventHandlers() && page() && m_frame->isMainFrame())
1986         page()->chrome().client().needTouchEvents(true);
1987 #endif
1988
1989 #if PLATFORM(IOS)
1990     // Ensure that document scheduled task state matches frame timer state. It can be out of sync
1991     // if timers state changed while the document was not in the frame (possibly in page cache,
1992     // or simply newly created).
1993     // FIXME: How does this interact with cross-platform code below?
1994     if (m_frame->timersPaused())
1995         suspendScheduledTasks(ActiveDOMObject::DocumentWillBePaused);
1996     else
1997         resumeScheduledTasks(ActiveDOMObject::DocumentWillBePaused);
1998 #endif
1999
2000     if (m_frame->activeDOMObjectsAndAnimationsSuspended()) {
2001         suspendScriptedAnimationControllerCallbacks();
2002         m_frame->animation().suspendAnimationsForDocument(this);
2003         suspendActiveDOMObjects(ActiveDOMObject::PageWillBeSuspended);
2004     }
2005 }
2006
2007 void Document::disconnectFromFrame()
2008 {
2009     m_frame = nullptr;
2010 }
2011
2012 void Document::destroyRenderTree()
2013 {
2014     ASSERT(hasLivingRenderTree());
2015     ASSERT(!m_inPageCache);
2016
2017     TemporaryChange<bool> change(m_renderTreeBeingDestroyed, true);
2018
2019     if (this == &topDocument())
2020         clearAXObjectCache();
2021
2022     documentWillBecomeInactive();
2023
2024     if (FrameView* frameView = view())
2025         frameView->detachCustomScrollbars();
2026
2027 #if ENABLE(FULLSCREEN_API)
2028     if (m_fullScreenRenderer)
2029         setFullScreenRenderer(nullptr);
2030 #endif
2031
2032     m_hoveredElement = nullptr;
2033     m_focusedElement = nullptr;
2034     m_activeElement = nullptr;
2035
2036     if (m_documentElement)
2037         Style::detachRenderTree(*m_documentElement);
2038
2039     clearChildNeedsStyleRecalc();
2040
2041     unscheduleStyleRecalc();
2042
2043     m_renderView = nullptr;
2044     Node::setRenderer(nullptr);
2045
2046 #if ENABLE(IOS_TEXT_AUTOSIZING)
2047     // Do this before the arena is cleared, which is needed to deref the RenderStyle on TextAutoSizingKey.
2048     m_textAutoSizedNodes.clear();
2049 #endif
2050 }
2051
2052 void Document::prepareForDestruction()
2053 {
2054 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
2055     clearTouchEventListeners();
2056 #endif
2057
2058     disconnectDescendantFrames();
2059     if (m_domWindow && m_frame)
2060         m_domWindow->willDetachDocumentFromFrame();
2061
2062     destroyRenderTree();
2063
2064     if (isPluginDocument())
2065         toPluginDocument(this)->detachFromPluginElement();
2066
2067 #if ENABLE(POINTER_LOCK)
2068     if (page())
2069         page()->pointerLockController()->documentDetached(this);
2070 #endif
2071
2072     stopActiveDOMObjects();
2073     m_eventQueue.close();
2074 #if ENABLE(FULLSCREEN_API)
2075     m_fullScreenChangeEventTargetQueue.clear();
2076     m_fullScreenErrorEventTargetQueue.clear();
2077 #endif
2078
2079     commonTeardown();
2080
2081 #if ENABLE(SHARED_WORKERS)
2082     SharedWorkerRepository::documentDetached(this);
2083 #endif
2084
2085 #if ENABLE(TOUCH_EVENTS)
2086     if (m_touchEventTargets && m_touchEventTargets->size() && parentDocument())
2087         parentDocument()->didRemoveEventTargetNode(this);
2088 #endif
2089
2090     if (m_mediaQueryMatcher)
2091         m_mediaQueryMatcher->documentDestroyed();
2092
2093     disconnectFromFrame();
2094 }
2095
2096 void Document::removeAllEventListeners()
2097 {
2098     EventTarget::removeAllEventListeners();
2099
2100     if (m_domWindow)
2101         m_domWindow->removeAllEventListeners();
2102 #if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
2103     clearTouchEventListeners();
2104 #endif
2105     for (Node* node = firstChild(); node; node = NodeTraversal::next(node))
2106         node->removeAllEventListeners();
2107 }
2108
2109 void Document::platformSuspendOrStopActiveDOMObjects()
2110 {
2111 #if PLATFORM(IOS)
2112 #if ENABLE(DEVICE_ORIENTATION)
2113     if (m_deviceMotionController)
2114         m_deviceMotionController->suspendUpdates();
2115     if (m_deviceOrientationController)
2116         m_deviceOrientationController->suspendUpdates();
2117 #endif
2118
2119     if (WebThreadCountOfObservedContentModifiers() > 0) {
2120         Frame* frame = this->frame();
2121         if (Page* page = frame ? frame->page() : nullptr)
2122             page->chrome().client().clearContentChangeObservers(frame);
2123     }
2124 #endif
2125 }
2126
2127 void Document::suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2128 {
2129     ScriptExecutionContext::suspendActiveDOMObjects(why);
2130     platformSuspendOrStopActiveDOMObjects();
2131 }
2132
2133 void Document::resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)
2134 {
2135     ScriptExecutionContext::resumeActiveDOMObjects(why);
2136
2137 #if ENABLE(DEVICE_ORIENTATION) && PLATFORM(IOS)
2138     if (m_deviceMotionController)
2139         m_deviceMotionController->resumeUpdates();
2140     if (m_deviceOrientationController)
2141         m_deviceOrientationController->resumeUpdates();
2142 #endif
2143     // FIXME: For iOS, do we need to add content change observers that were removed in Document::suspendActiveDOMObjects()?
2144 }
2145
2146 void Document::stopActiveDOMObjects()
2147 {
2148     ScriptExecutionContext::stopActiveDOMObjects();
2149     platformSuspendOrStopActiveDOMObjects();
2150 }
2151
2152 void Document::clearAXObjectCache()
2153 {
2154     ASSERT(&topDocument() == this);
2155     // Clear the cache member variable before calling delete because attempts
2156     // are made to access it during destruction.
2157     m_axObjectCache.clear();
2158 }
2159
2160 AXObjectCache* Document::existingAXObjectCache() const
2161 {
2162     Document& topDocument = this->topDocument();
2163     if (!topDocument.hasLivingRenderTree())
2164         return nullptr;
2165     return topDocument.m_axObjectCache.get();
2166 }
2167
2168 AXObjectCache* Document::axObjectCache() const
2169 {
2170     if (!AXObjectCache::accessibilityEnabled())
2171         return nullptr;
2172
2173     // The only document that actually has a AXObjectCache is the top-level
2174     // document.  This is because we need to be able to get from any WebCoreAXObject
2175     // to any other WebCoreAXObject on the same page.  Using a single cache allows
2176     // lookups across nested webareas (i.e. multiple documents).
2177     Document& topDocument = this->topDocument();
2178
2179     // If the document has already been detached, do not make a new axObjectCache.
2180     if (!topDocument.hasLivingRenderTree())
2181         return nullptr;
2182
2183     ASSERT(&topDocument == this || !m_axObjectCache);
2184     if (!topDocument.m_axObjectCache)
2185         topDocument.m_axObjectCache = adoptPtr(new AXObjectCache(topDocument));
2186     return topDocument.m_axObjectCache.get();
2187 }
2188
2189 void Document::setVisuallyOrdered()
2190 {
2191     m_visuallyOrdered = true;
2192     if (renderView())
2193         renderView()->style().setRTLOrdering(VisualOrder);
2194 }
2195
2196 PassRefPtr<DocumentParser> Document::createParser()
2197 {
2198     // FIXME: this should probably pass the frame instead
2199     return XMLDocumentParser::create(*this, view());
2200 }
2201
2202 ScriptableDocumentParser* Document::scriptableDocumentParser() const
2203 {
2204     return parser() ? parser()->asScriptableDocumentParser() : nullptr;
2205 }
2206
2207 void Document::open(Document* ownerDocument)
2208 {
2209     if (ownerDocument) {
2210         setURL(ownerDocument->url());
2211         m_cookieURL = ownerDocument->cookieURL();
2212         setSecurityOrigin(ownerDocument->securityOrigin());
2213     }
2214
2215     if (m_frame) {
2216         if (ScriptableDocumentParser* parser = scriptableDocumentParser()) {
2217             if (parser->isParsing()) {
2218                 // FIXME: HTML5 doesn't tell us to check this, it might not be correct.
2219                 if (parser->isExecutingScript())
2220                     return;
2221
2222                 if (!parser->wasCreatedByScript() && parser->hasInsertionPoint())
2223                     return;
2224             }
2225         }
2226
2227         if (m_frame->loader().state() == FrameStateProvisional)
2228             m_frame->loader().stopAllLoaders();
2229     }
2230
2231     removeAllEventListeners();
2232     implicitOpen();
2233     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2234         parser->setWasCreatedByScript(true);
2235
2236     if (m_frame)
2237         m_frame->loader().didExplicitOpen();
2238 }
2239
2240 void Document::detachParser()
2241 {
2242     if (!m_parser)
2243         return;
2244     m_parser->detach();
2245     m_parser.clear();
2246 }
2247
2248 void Document::cancelParsing()
2249 {
2250     if (!m_parser)
2251         return;
2252
2253     // We have to clear the parser to avoid possibly triggering
2254     // the onload handler when closing as a side effect of a cancel-style
2255     // change, such as opening a new document or closing the window while
2256     // still parsing
2257     detachParser();
2258     explicitClose();
2259 }
2260
2261 void Document::implicitOpen()
2262 {
2263     cancelParsing();
2264
2265     removeChildren();
2266
2267     setCompatibilityMode(NoQuirksMode);
2268
2269     // Documents rendered seamlessly should start out requiring a stylesheet
2270     // collection update in order to ensure they inherit all the relevant data
2271     // from their parent.
2272     if (shouldDisplaySeamlesslyWithParent())
2273         styleResolverChanged(DeferRecalcStyle);
2274
2275     m_parser = createParser();
2276     setParsing(true);
2277     setReadyState(Loading);
2278 }
2279
2280 HTMLElement* Document::body() const
2281 {
2282     // If the document element contains both a frameset and a body, the frameset wins.
2283     auto element = documentElement();
2284     if (!element)
2285         return nullptr;
2286     if (auto frameset = childrenOfType<HTMLFrameSetElement>(*element).first())
2287         return frameset;
2288     return childrenOfType<HTMLBodyElement>(*element).first();
2289 }
2290
2291 void Document::setBody(PassRefPtr<HTMLElement> prpNewBody, ExceptionCode& ec)
2292 {
2293     RefPtr<HTMLElement> newBody = prpNewBody;
2294
2295     if (!newBody || !documentElement() || !newBody->hasTagName(bodyTag)) {
2296         ec = HIERARCHY_REQUEST_ERR;
2297         return;
2298     }
2299
2300     if (&newBody->document() != this) {
2301         ec = 0;
2302         RefPtr<Node> node = importNode(newBody.get(), true, ec);
2303         if (ec)
2304             return;
2305
2306         newBody = toHTMLElement(node.get());
2307     }
2308
2309     HTMLElement* b = body();
2310     if (!b)
2311         documentElement()->appendChild(newBody.release(), ec);
2312     else
2313         documentElement()->replaceChild(newBody.release(), b, ec);
2314 }
2315
2316 HTMLHeadElement* Document::head()
2317 {
2318     if (auto element = documentElement())
2319         return childrenOfType<HTMLHeadElement>(*element).first();
2320     return nullptr;
2321 }
2322
2323 void Document::close()
2324 {
2325     // FIXME: We should follow the specification more closely:
2326     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
2327
2328     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
2329         return;
2330
2331     explicitClose();
2332 }
2333
2334 void Document::explicitClose()
2335 {
2336     if (RefPtr<DocumentParser> parser = m_parser)
2337         parser->finish();
2338
2339     if (!m_frame) {
2340         // Because we have no frame, we don't know if all loading has completed,
2341         // so we just call implicitClose() immediately. FIXME: This might fire
2342         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
2343         implicitClose();
2344         return;
2345     }
2346
2347     m_frame->loader().checkCompleted();
2348 }
2349
2350 void Document::implicitClose()
2351 {
2352     // 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.
2353     if (m_inStyleRecalc) {
2354         m_closeAfterStyleRecalc = true;
2355         return;
2356     }
2357
2358     bool wasLocationChangePending = frame() && frame()->navigationScheduler().locationChangePending();
2359     bool doload = !parsing() && m_parser && !m_processingLoadEvent && !wasLocationChangePending;
2360
2361     if (!doload)
2362         return;
2363
2364     // Call to dispatchWindowLoadEvent can blow us from underneath.
2365     Ref<Document> protect(*this);
2366
2367     m_processingLoadEvent = true;
2368
2369     ScriptableDocumentParser* parser = scriptableDocumentParser();
2370     m_wellFormed = parser && parser->wellFormed();
2371
2372     // We have to clear the parser, in case someone document.write()s from the
2373     // onLoad event handler, as in Radar 3206524.
2374     detachParser();
2375
2376     // FIXME: We kick off the icon loader when the Document is done parsing.
2377     // There are earlier opportunities we could start it:
2378     //  -When the <head> finishes parsing
2379     //  -When any new HTMLLinkElement is inserted into the document
2380     // But those add a dynamic component to the favicon that has UI
2381     // ramifications, and we need to decide what is the Right Thing To Do(tm)
2382     Frame* f = frame();
2383     if (f) {
2384         f->loader().icon().startLoader();
2385         f->animation().startAnimationsIfNotSuspended(this);
2386     }
2387
2388     ImageLoader::dispatchPendingBeforeLoadEvents();
2389     ImageLoader::dispatchPendingLoadEvents();
2390     ImageLoader::dispatchPendingErrorEvents();
2391
2392     HTMLLinkElement::dispatchPendingLoadEvents();
2393     HTMLStyleElement::dispatchPendingLoadEvents();
2394
2395 #if ENABLE(SVG)
2396     // To align the HTML load event and the SVGLoad event for the outermost <svg> element, fire it from
2397     // here, instead of doing it from SVGElement::finishedParsingChildren (if externalResourcesRequired="false",
2398     // which is the default, for ='true' its fired at a later time, once all external resources finished loading).
2399     if (svgExtensions())
2400         accessSVGExtensions()->dispatchSVGLoadEventToOutermostSVGElements();
2401 #endif
2402
2403     dispatchWindowLoadEvent();
2404     enqueuePageshowEvent(PageshowEventNotPersisted);
2405     enqueuePopstateEvent(m_pendingStateObject ? m_pendingStateObject.release() : SerializedScriptValue::nullValue());
2406
2407     if (f)
2408         f->loader().handledOnloadEvents();
2409 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2410     if (!ownerElement())
2411         printf("onload fired at %lld\n", elapsedTime().count());
2412 #endif
2413
2414     // An event handler may have removed the frame
2415     if (!frame()) {
2416         m_processingLoadEvent = false;
2417         return;
2418     }
2419
2420     // Make sure both the initial layout and reflow happen after the onload
2421     // fires. This will improve onload scores, and other browsers do it.
2422     // If they wanna cheat, we can too. -dwh
2423
2424     if (frame()->navigationScheduler().locationChangePending() && elapsedTime() < settings()->layoutInterval()) {
2425         // Just bail out. Before or during the onload we were shifted to another page.
2426         // The old i-Bench suite does this. When this happens don't bother painting or laying out.
2427         m_processingLoadEvent = false;
2428         view()->unscheduleRelayout();
2429         return;
2430     }
2431
2432     frame()->loader().checkCallImplicitClose();
2433
2434     // We used to force a synchronous display and flush here.  This really isn't
2435     // necessary and can in fact be actively harmful if pages are loading at a rate of > 60fps
2436     // (if your platform is syncing flushes and limiting them to 60fps).
2437     m_overMinimumLayoutThreshold = true;
2438     if (!ownerElement() || (ownerElement()->renderer() && !ownerElement()->renderer()->needsLayout())) {
2439         updateStyleIfNeeded();
2440
2441         // Always do a layout after loading if needed.
2442         if (view() && renderView() && (!renderView()->firstChild() || renderView()->needsLayout()))
2443             view()->layout();
2444     }
2445
2446     m_processingLoadEvent = false;
2447
2448 #if PLATFORM(MAC) || PLATFORM(WIN) || PLATFORM(GTK) || PLATFORM(EFL)
2449     if (f && hasLivingRenderTree() && AXObjectCache::accessibilityEnabled()) {
2450         // The AX cache may have been cleared at this point, but we need to make sure it contains an
2451         // AX object to send the notification to. getOrCreate will make sure that an valid AX object
2452         // exists in the cache (we ignore the return value because we don't need it here). This is
2453         // only safe to call when a layout is not in progress, so it can not be used in postNotification.
2454         axObjectCache()->getOrCreate(renderView());
2455         if (this == &topDocument())
2456             axObjectCache()->postNotification(renderView(), AXObjectCache::AXLoadComplete);
2457         else {
2458             // AXLoadComplete can only be posted on the top document, so if it's a document
2459             // in an iframe that just finished loading, post AXLayoutComplete instead.
2460             axObjectCache()->postNotification(renderView(), AXObjectCache::AXLayoutComplete);
2461         }
2462     }
2463 #endif
2464
2465 #if ENABLE(SVG)
2466     if (svgExtensions())
2467         accessSVGExtensions()->startAnimations();
2468 #endif
2469 }
2470
2471 void Document::setParsing(bool b)
2472 {
2473     m_bParsing = b;
2474
2475     if (m_bParsing && !m_sharedObjectPool)
2476         m_sharedObjectPool = DocumentSharedObjectPool::create();
2477
2478     if (!m_bParsing && view())
2479         view()->scheduleRelayout();
2480
2481 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2482     if (!ownerElement() && !m_bParsing)
2483         printf("Parsing finished at %lld\n", elapsedTime().count());
2484 #endif
2485 }
2486
2487 bool Document::shouldScheduleLayout()
2488 {
2489     // This function will only be called when FrameView thinks a layout is needed.
2490     // This enforces a couple extra rules.
2491     //
2492     //    (a) Only schedule a layout once the stylesheets are loaded.
2493     //    (b) Only schedule layout once we have a body element.
2494
2495     return (haveStylesheetsLoaded() && body())
2496         || (documentElement() && !documentElement()->hasTagName(htmlTag));
2497 }
2498
2499 bool Document::isLayoutTimerActive()
2500 {
2501     return view() && view()->layoutPending() && !minimumLayoutDelay().count();
2502 }
2503
2504 std::chrono::milliseconds Document::minimumLayoutDelay()
2505 {
2506     if (m_overMinimumLayoutThreshold)
2507         return std::chrono::milliseconds(0);
2508
2509     std::chrono::milliseconds elapsed = elapsedTime();
2510     m_overMinimumLayoutThreshold = elapsed > settings()->layoutInterval();
2511
2512     // We'll want to schedule the timer to fire at the minimum layout threshold.
2513     return std::max(std::chrono::milliseconds(0), settings()->layoutInterval() - elapsed);
2514 }
2515
2516 std::chrono::milliseconds Document::elapsedTime() const
2517 {
2518     auto elapsedTime = std::chrono::steady_clock::now() - m_startTime;
2519
2520     return std::chrono::duration_cast<std::chrono::milliseconds>(elapsedTime);
2521 }
2522
2523 void Document::write(const SegmentedString& text, Document* ownerDocument)
2524 {
2525     NestingLevelIncrementer nestingLevelIncrementer(m_writeRecursionDepth);
2526
2527     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > 1) && m_writeRecursionIsTooDeep;
2528     m_writeRecursionIsTooDeep = (m_writeRecursionDepth > cMaxWriteRecursionDepth) || m_writeRecursionIsTooDeep;
2529
2530     if (m_writeRecursionIsTooDeep)
2531        return;
2532
2533 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2534     if (!ownerElement())
2535         printf("Beginning a document.write at %lld\n", elapsedTime().count());
2536 #endif
2537
2538     bool hasInsertionPoint = m_parser && m_parser->hasInsertionPoint();
2539     if (!hasInsertionPoint && m_ignoreDestructiveWriteCount)
2540         return;
2541
2542     if (!hasInsertionPoint)
2543         open(ownerDocument);
2544
2545     ASSERT(m_parser);
2546     m_parser->insert(text);
2547
2548 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2549     if (!ownerElement())
2550         printf("Ending a document.write at %lld\n", elapsedTime().count());
2551 #endif
2552 }
2553
2554 void Document::write(const String& text, Document* ownerDocument)
2555 {
2556     write(SegmentedString(text), ownerDocument);
2557 }
2558
2559 void Document::writeln(const String& text, Document* ownerDocument)
2560 {
2561     write(text, ownerDocument);
2562     write("\n", ownerDocument);
2563 }
2564
2565 double Document::minimumTimerInterval() const
2566 {
2567     Page* p = page();
2568     if (!p)
2569         return ScriptExecutionContext::minimumTimerInterval();
2570     return p->settings().minDOMTimerInterval();
2571 }
2572
2573 double Document::timerAlignmentInterval() const
2574 {
2575     Page* p = page();
2576     if (!p)
2577         return ScriptExecutionContext::timerAlignmentInterval();
2578     return p->settings().domTimerAlignmentInterval();
2579 }
2580
2581 EventTarget* Document::errorEventTarget()
2582 {
2583     return m_domWindow.get();
2584 }
2585
2586 void Document::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack> callStack)
2587 {
2588     addMessage(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber, columnNumber, callStack);
2589 }
2590
2591 void Document::setURL(const URL& url)
2592 {
2593     const URL& newURL = url.isEmpty() ? blankURL() : url;
2594     if (newURL == m_url)
2595         return;
2596
2597     m_url = newURL;
2598     m_documentURI = m_url.string();
2599     updateBaseURL();
2600 }
2601
2602 void Document::updateBaseURL()
2603 {
2604     URL oldBaseURL = m_baseURL;
2605     // DOM 3 Core: When the Document supports the feature "HTML" [DOM Level 2 HTML], the base URI is computed using
2606     // first the value of the href attribute of the HTML BASE element if any, and the value of the documentURI attribute
2607     // from the Document interface otherwise.
2608     if (!m_baseElementURL.isEmpty())
2609         m_baseURL = m_baseElementURL;
2610     else if (!m_baseURLOverride.isEmpty())
2611         m_baseURL = m_baseURLOverride;
2612     else {
2613         // The documentURI attribute is read-only from JavaScript, but writable from Objective C, so we need to retain
2614         // this fallback behavior. We use a null base URL, since the documentURI attribute is an arbitrary string
2615         // and DOM 3 Core does not specify how it should be resolved.
2616         m_baseURL = URL(ParsedURLString, documentURI());
2617     }
2618
2619     if (m_selectorQueryCache)
2620         m_selectorQueryCache->invalidate();
2621
2622     if (!m_baseURL.isValid())
2623         m_baseURL = URL();
2624
2625     if (m_elementSheet) {
2626         // Element sheet is silly. It never contains anything.
2627         ASSERT(!m_elementSheet->contents().ruleCount());
2628         bool usesRemUnits = m_elementSheet->contents().usesRemUnits();
2629         m_elementSheet = CSSStyleSheet::createInline(*this, m_baseURL);
2630         // FIXME: So we are not really the parser. The right fix is to eliminate the element sheet completely.
2631         m_elementSheet->contents().parserSetUsesRemUnits(usesRemUnits);
2632     }
2633
2634     if (!equalIgnoringFragmentIdentifier(oldBaseURL, m_baseURL)) {
2635         // Base URL change changes any relative visited links.
2636         // 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.
2637         for (auto& anchor : descendantsOfType<HTMLAnchorElement>(*this))
2638             anchor.invalidateCachedVisitedLinkHash();
2639     }
2640 }
2641
2642 void Document::setBaseURLOverride(const URL& url)
2643 {
2644     m_baseURLOverride = url;
2645     updateBaseURL();
2646 }
2647
2648 void Document::processBaseElement()
2649 {
2650     // Find the first href attribute in a base element and the first target attribute in a base element.
2651     const AtomicString* href = nullptr;
2652     const AtomicString* target = nullptr;
2653     auto baseDescendants = descendantsOfType<HTMLBaseElement>(*this);
2654     for (auto base = baseDescendants.begin(), end = baseDescendants.end(); base != end && (!href || !target); ++base) {
2655         if (!href) {
2656             const AtomicString& value = base->fastGetAttribute(hrefAttr);
2657             if (!value.isNull())
2658                 href = &value;
2659         }
2660         if (!target) {
2661             const AtomicString& value = base->fastGetAttribute(targetAttr);
2662             if (!value.isNull())
2663                 target = &value;
2664         }
2665     }
2666
2667     // FIXME: Since this doesn't share code with completeURL it may not handle encodings correctly.
2668     URL baseElementURL;
2669     if (href) {
2670         String strippedHref = stripLeadingAndTrailingHTMLSpaces(*href);
2671         if (!strippedHref.isEmpty())
2672             baseElementURL = URL(url(), strippedHref);
2673     }
2674     if (m_baseElementURL != baseElementURL && contentSecurityPolicy()->allowBaseURI(baseElementURL)) {
2675         m_baseElementURL = baseElementURL;
2676         updateBaseURL();
2677     }
2678
2679     m_baseTarget = target ? *target : nullAtom;
2680 }
2681
2682 String Document::userAgent(const URL& url) const
2683 {
2684     return frame() ? frame()->loader().userAgent(url) : String();
2685 }
2686
2687 void Document::disableEval(const String& errorMessage)
2688 {
2689     if (!frame())
2690         return;
2691
2692     frame()->script().disableEval(errorMessage);
2693 }
2694
2695 bool Document::canNavigate(Frame* targetFrame)
2696 {
2697     if (!m_frame)
2698         return false;
2699
2700     // FIXME: We shouldn't call this function without a target frame, but
2701     // fast/forms/submit-to-blank-multiple-times.html depends on this function
2702     // returning true when supplied with a 0 targetFrame.
2703     if (!targetFrame)
2704         return true;
2705
2706     // Frame-busting is generally allowed, but blocked for sandboxed frames lacking the 'allow-top-navigation' flag.
2707     if (!isSandboxed(SandboxTopNavigation) && targetFrame == &m_frame->tree().top())
2708         return true;
2709
2710     if (isSandboxed(SandboxNavigation)) {
2711         if (targetFrame->tree().isDescendantOf(m_frame))
2712             return true;
2713
2714         const char* reason = "The frame attempting navigation is sandboxed, and is therefore disallowed from navigating its ancestors.";
2715         if (isSandboxed(SandboxTopNavigation) && targetFrame == &m_frame->tree().top())
2716             reason = "The frame attempting navigation of the top-level window is sandboxed, but the 'allow-top-navigation' flag is not set.";
2717
2718         printNavigationErrorMessage(targetFrame, url(), reason);
2719         return false;
2720     }
2721
2722     // This is the normal case. A document can navigate its decendant frames,
2723     // or, more generally, a document can navigate a frame if the document is
2724     // in the same origin as any of that frame's ancestors (in the frame
2725     // hierarchy).
2726     //
2727     // See http://www.adambarth.com/papers/2008/barth-jackson-mitchell.pdf for
2728     // historical information about this security check.
2729     if (canAccessAncestor(securityOrigin(), targetFrame))
2730         return true;
2731
2732     // Top-level frames are easier to navigate than other frames because they
2733     // display their URLs in the address bar (in most browsers). However, there
2734     // are still some restrictions on navigation to avoid nuisance attacks.
2735     // Specifically, a document can navigate a top-level frame if that frame
2736     // opened the document or if the document is the same-origin with any of
2737     // the top-level frame's opener's ancestors (in the frame hierarchy).
2738     //
2739     // In both of these cases, the document performing the navigation is in
2740     // some way related to the frame being navigate (e.g., by the "opener"
2741     // and/or "parent" relation). Requiring some sort of relation prevents a
2742     // document from navigating arbitrary, unrelated top-level frames.
2743     if (!targetFrame->tree().parent()) {
2744         if (targetFrame == m_frame->loader().opener())
2745             return true;
2746
2747         if (canAccessAncestor(securityOrigin(), targetFrame->loader().opener()))
2748             return true;
2749     }
2750
2751     printNavigationErrorMessage(targetFrame, url(), "The frame attempting navigation is neither same-origin with the target, nor is it the target's parent or opener.");
2752     return false;
2753 }
2754
2755 Frame* Document::findUnsafeParentScrollPropagationBoundary()
2756 {
2757     Frame* currentFrame = m_frame;
2758     if (!currentFrame)
2759         return nullptr;
2760
2761     Frame* ancestorFrame = currentFrame->tree().parent();
2762
2763     while (ancestorFrame) {
2764         if (!ancestorFrame->document()->securityOrigin()->canAccess(securityOrigin()))
2765             return currentFrame;
2766         currentFrame = ancestorFrame;
2767         ancestorFrame = ancestorFrame->tree().parent();
2768     }
2769     return nullptr;
2770 }
2771
2772
2773 void Document::seamlessParentUpdatedStylesheets()
2774 {
2775     styleResolverChanged(RecalcStyleImmediately);
2776 }
2777
2778 void Document::didRemoveAllPendingStylesheet()
2779 {
2780     m_needsNotifyRemoveAllPendingStylesheet = false;
2781
2782     styleResolverChanged(DeferRecalcStyleIfNeeded);
2783
2784     if (m_pendingSheetLayout == DidLayoutWithPendingSheets) {
2785         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
2786         if (renderView())
2787             renderView()->repaintViewAndCompositedLayers();
2788     }
2789
2790     if (ScriptableDocumentParser* parser = scriptableDocumentParser())
2791         parser->executeScriptsWaitingForStylesheets();
2792
2793     if (m_gotoAnchorNeededAfterStylesheetsLoad && view())
2794         view()->scrollToFragment(m_url);
2795 }
2796
2797 CSSStyleSheet& Document::elementSheet()
2798 {
2799     if (!m_elementSheet)
2800         m_elementSheet = CSSStyleSheet::createInline(*this, m_baseURL);
2801     return *m_elementSheet;
2802 }
2803
2804 void Document::processHttpEquiv(const String& equiv, const String& content)
2805 {
2806     ASSERT(!equiv.isNull() && !content.isNull());
2807
2808     Frame* frame = this->frame();
2809
2810     if (equalIgnoringCase(equiv, "default-style")) {
2811         // The preferred style set has been overridden as per section
2812         // 14.3.2 of the HTML4.0 specification.  We need to update the
2813         // sheet used variable and then update our style selector.
2814         // For more info, see the test at:
2815         // http://www.hixie.ch/tests/evil/css/import/main/preferred.html
2816         // -dwh
2817         m_styleSheetCollection.setSelectedStylesheetSetName(content);
2818         m_styleSheetCollection.setPreferredStylesheetSetName(content);
2819         styleResolverChanged(DeferRecalcStyle);
2820     } else if (equalIgnoringCase(equiv, "refresh")) {
2821         double delay;
2822         String url;
2823         if (frame && parseHTTPRefresh(content, true, delay, url)) {
2824             if (url.isEmpty())
2825                 url = m_url.string();
2826             else
2827                 url = completeURL(url).string();
2828             frame->navigationScheduler().scheduleRedirect(delay, url);
2829         }
2830     } else if (equalIgnoringCase(equiv, "set-cookie")) {
2831         // FIXME: make setCookie work on XML documents too; e.g. in case of <html:meta .....>
2832         if (isHTMLDocument()) {
2833             // Exception (for sandboxed documents) ignored.
2834             toHTMLDocument(this)->setCookie(content, IGNORE_EXCEPTION);
2835         }
2836     } else if (equalIgnoringCase(equiv, "content-language"))
2837         setContentLanguage(content);
2838     else if (equalIgnoringCase(equiv, "x-dns-prefetch-control"))
2839         parseDNSPrefetchControlHeader(content);
2840     else if (equalIgnoringCase(equiv, "x-frame-options")) {
2841         if (frame) {
2842             FrameLoader& frameLoader = frame->loader();
2843             unsigned long requestIdentifier = 0;
2844             if (frameLoader.activeDocumentLoader() && frameLoader.activeDocumentLoader()->mainResourceLoader())
2845                 requestIdentifier = frameLoader.activeDocumentLoader()->mainResourceLoader()->identifier();
2846             if (frameLoader.shouldInterruptLoadForXFrameOptions(content, url(), requestIdentifier)) {
2847                 String message = "Refused to display '" + url().stringCenterEllipsizedToLength() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
2848                 frameLoader.stopAllLoaders();
2849                 // Stopping the loader isn't enough, as we're already parsing the document; to honor the header's
2850                 // intent, we must navigate away from the possibly partially-rendered document to a location that
2851                 // doesn't inherit the parent's SecurityOrigin.
2852                 frame->navigationScheduler().scheduleLocationChange(securityOrigin(), SecurityOrigin::urlWithUniqueSecurityOrigin(), String());
2853                 addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, message, requestIdentifier);
2854             }
2855         }
2856     } else if (equalIgnoringCase(equiv, "content-security-policy"))
2857         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Enforce);
2858     else if (equalIgnoringCase(equiv, "content-security-policy-report-only"))
2859         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Report);
2860     else if (equalIgnoringCase(equiv, "x-webkit-csp"))
2861         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedEnforce);
2862     else if (equalIgnoringCase(equiv, "x-webkit-csp-report-only"))
2863         contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedReport);
2864 }
2865
2866 // Though isspace() considers \t and \v to be whitespace, Win IE doesn't.
2867 static bool isSeparator(UChar c)
2868 {
2869     return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '=' || c == ',' || c == '\0';
2870 }
2871
2872 void Document::processArguments(const String& features, void* data, ArgumentsCallback callback)
2873 {
2874     // Tread lightly in this code -- it was specifically designed to mimic Win IE's parsing behavior.
2875     int keyBegin, keyEnd;
2876     int valueBegin, valueEnd;
2877
2878     int i = 0;
2879     int length = features.length();
2880     String buffer = features.lower();
2881     while (i < length) {
2882         // skip to first non-separator, but don't skip past the end of the string
2883         while (isSeparator(buffer[i])) {
2884             if (i >= length)
2885                 break;
2886             i++;
2887         }
2888         keyBegin = i;
2889
2890         // skip to first separator
2891         while (!isSeparator(buffer[i]))
2892             i++;
2893         keyEnd = i;
2894
2895         // skip to first '=', but don't skip past a ',' or the end of the string
2896         while (buffer[i] != '=') {
2897             if (buffer[i] == ',' || i >= length)
2898                 break;
2899             i++;
2900         }
2901
2902         // skip to first non-separator, but don't skip past a ',' or the end of the string
2903         while (isSeparator(buffer[i])) {
2904             if (buffer[i] == ',' || i >= length)
2905                 break;
2906             i++;
2907         }
2908         valueBegin = i;
2909
2910         // skip to first separator
2911         while (!isSeparator(buffer[i]))
2912             i++;
2913         valueEnd = i;
2914
2915         ASSERT_WITH_SECURITY_IMPLICATION(i <= length);
2916
2917         String keyString = buffer.substring(keyBegin, keyEnd - keyBegin);
2918         String valueString = buffer.substring(valueBegin, valueEnd - valueBegin);
2919         callback(keyString, valueString, this, data);
2920     }
2921 }
2922
2923 void Document::processViewport(const String& features, ViewportArguments::Type origin)
2924 {
2925     ASSERT(!features.isNull());
2926
2927     if (origin < m_viewportArguments.type)
2928         return;
2929
2930     m_viewportArguments = ViewportArguments(origin);
2931     processArguments(features, (void*)&m_viewportArguments, &setViewportFeature);
2932
2933 #if PLATFORM(IOS)
2934     // FIXME: <rdar://problem/8955959> Investigate moving to ToT WebKit's extended Viewport Implementation
2935     // Moving to ToT's implementation would mean calling findConfigurationForViewportData, which does
2936     // bounds checking and determining concrete values for ValueAuto which we already do in UIKit.
2937     // To maintain old behavior, we just need to update a few values, leaving Auto's for UIKit.
2938     finalizeViewportArguments(m_viewportArguments);
2939 #endif
2940
2941     updateViewportArguments();
2942 }
2943
2944 void Document::updateViewportArguments()
2945 {
2946     if (page() && frame()->isMainFrame()) {
2947 #ifndef NDEBUG
2948         m_didDispatchViewportPropertiesChanged = true;
2949 #endif
2950         page()->chrome().dispatchViewportPropertiesDidChange(m_viewportArguments);
2951 #if PLATFORM(IOS)
2952         page()->chrome().didReceiveDocType(frame());
2953 #endif
2954     }
2955 }
2956
2957 #if PLATFORM(IOS)
2958 // FIXME: Find a better place for this functionality.
2959 void setParserFeature(const String& key, const String& value, Document* document, void*)
2960 {
2961     if (key == "telephone" && equalIgnoringCase(value, "no"))
2962         document->setIsTelephoneNumberParsingAllowed(false);
2963 }
2964
2965 void Document::processFormatDetection(const String& features)
2966 {
2967     ASSERT(!features.isNull());
2968     processArguments(features, nullptr, &setParserFeature);
2969 }
2970
2971 void Document::processWebAppOrientations()
2972 {
2973     if (Page* page = this->page())
2974         page->chrome().client().webAppOrientationsUpdated();
2975 }
2976 #endif
2977
2978 void Document::processReferrerPolicy(const String& policy)
2979 {
2980     ASSERT(!policy.isNull());
2981
2982     m_referrerPolicy = ReferrerPolicyDefault;
2983
2984     if (equalIgnoringCase(policy, "never"))
2985         m_referrerPolicy = ReferrerPolicyNever;
2986     else if (equalIgnoringCase(policy, "always"))
2987         m_referrerPolicy = ReferrerPolicyAlways;
2988     else if (equalIgnoringCase(policy, "origin"))
2989         m_referrerPolicy = ReferrerPolicyOrigin;
2990 }
2991
2992 MouseEventWithHitTestResults Document::prepareMouseEvent(const HitTestRequest& request, const LayoutPoint& documentPoint, const PlatformMouseEvent& event)
2993 {
2994     if (!hasLivingRenderTree())
2995         return MouseEventWithHitTestResults(event, HitTestResult(LayoutPoint()));
2996
2997     HitTestResult result(documentPoint);
2998     renderView()->hitTest(request, result);
2999
3000     if (!request.readOnly())
3001         updateHoverActiveState(request, result.innerElement(), &event);
3002
3003     return MouseEventWithHitTestResults(event, result);
3004 }
3005
3006 // DOM Section 1.1.1
3007 bool Document::childTypeAllowed(NodeType type) const
3008 {
3009     switch (type) {
3010     case ATTRIBUTE_NODE:
3011     case CDATA_SECTION_NODE:
3012     case DOCUMENT_FRAGMENT_NODE:
3013     case DOCUMENT_NODE:
3014     case ENTITY_NODE:
3015     case ENTITY_REFERENCE_NODE:
3016     case NOTATION_NODE:
3017     case TEXT_NODE:
3018     case XPATH_NAMESPACE_NODE:
3019         return false;
3020     case COMMENT_NODE:
3021     case PROCESSING_INSTRUCTION_NODE:
3022         return true;
3023     case DOCUMENT_TYPE_NODE:
3024     case ELEMENT_NODE:
3025         // Documents may contain no more than one of each of these.
3026         // (One Element and one DocumentType.)
3027         for (Node* c = firstChild(); c; c = c->nextSibling())
3028             if (c->nodeType() == type)
3029                 return false;
3030         return true;
3031     }
3032     return false;
3033 }
3034
3035 bool Document::canReplaceChild(Node* newChild, Node* oldChild)
3036 {
3037     if (!oldChild)
3038         // ContainerNode::replaceChild will raise a NOT_FOUND_ERR.
3039         return true;
3040
3041     if (oldChild->nodeType() == newChild->nodeType())
3042         return true;
3043
3044     int numDoctypes = 0;
3045     int numElements = 0;
3046
3047     // First, check how many doctypes and elements we have, not counting
3048     // the child we're about to remove.
3049     for (Node* c = firstChild(); c; c = c->nextSibling()) {
3050         if (c == oldChild)
3051             continue;
3052
3053         switch (c->nodeType()) {
3054         case DOCUMENT_TYPE_NODE:
3055             numDoctypes++;
3056             break;
3057         case ELEMENT_NODE:
3058             numElements++;
3059             break;
3060         default:
3061             break;
3062         }
3063     }
3064
3065     // Then, see how many doctypes and elements might be added by the new child.
3066     if (newChild->isDocumentFragment()) {
3067         for (Node* c = newChild->firstChild(); c; c = c->nextSibling()) {
3068             switch (c->nodeType()) {
3069             case ATTRIBUTE_NODE:
3070             case CDATA_SECTION_NODE:
3071             case DOCUMENT_FRAGMENT_NODE:
3072             case DOCUMENT_NODE:
3073             case ENTITY_NODE:
3074             case ENTITY_REFERENCE_NODE:
3075             case NOTATION_NODE:
3076             case TEXT_NODE:
3077             case XPATH_NAMESPACE_NODE:
3078                 return false;
3079             case COMMENT_NODE:
3080             case PROCESSING_INSTRUCTION_NODE:
3081                 break;
3082             case DOCUMENT_TYPE_NODE:
3083                 numDoctypes++;
3084                 break;
3085             case ELEMENT_NODE:
3086                 numElements++;
3087                 break;
3088             }
3089         }
3090     } else {
3091         switch (newChild->nodeType()) {
3092         case ATTRIBUTE_NODE:
3093         case CDATA_SECTION_NODE:
3094         case DOCUMENT_FRAGMENT_NODE:
3095         case DOCUMENT_NODE:
3096         case ENTITY_NODE:
3097         case ENTITY_REFERENCE_NODE:
3098         case NOTATION_NODE:
3099         case TEXT_NODE:
3100         case XPATH_NAMESPACE_NODE:
3101             return false;
3102         case COMMENT_NODE:
3103         case PROCESSING_INSTRUCTION_NODE:
3104             return true;
3105         case DOCUMENT_TYPE_NODE:
3106             numDoctypes++;
3107             break;
3108         case ELEMENT_NODE:
3109             numElements++;
3110             break;
3111         }
3112     }
3113
3114     if (numElements > 1 || numDoctypes > 1)
3115         return false;
3116
3117     return true;
3118 }
3119
3120 PassRefPtr<Node> Document::cloneNode(bool deep)
3121 {
3122     RefPtr<Document> clone = cloneDocumentWithoutChildren();
3123     clone->cloneDataFromDocument(*this);
3124     if (deep)
3125         cloneChildNodes(clone.get());
3126     return clone.release();
3127 }
3128
3129 PassRefPtr<Document> Document::cloneDocumentWithoutChildren() const
3130 {
3131     return isXHTMLDocument() ? createXHTML(nullptr, url()) : create(nullptr, url());
3132 }
3133
3134 void Document::cloneDataFromDocument(const Document& other)
3135 {
3136     ASSERT(m_url == other.url());
3137     m_baseURL = other.baseURL();
3138     m_baseURLOverride = other.baseURLOverride();
3139     m_documentURI = other.documentURI();
3140
3141     setCompatibilityMode(other.compatibilityMode());
3142     setSecurityOrigin(other.securityOrigin());
3143     setDecoder(other.decoder());
3144 }
3145
3146 StyleSheetList* Document::styleSheets()
3147 {
3148     if (!m_styleSheetList)
3149         m_styleSheetList = StyleSheetList::create(this);
3150     return m_styleSheetList.get();
3151 }
3152
3153 String Document::preferredStylesheetSet() const
3154 {
3155     return m_styleSheetCollection.preferredStylesheetSetName();
3156 }
3157
3158 String Document::selectedStylesheetSet() const
3159 {
3160     return m_styleSheetCollection.selectedStylesheetSetName();
3161 }
3162
3163 void Document::setSelectedStylesheetSet(const String& aString)
3164 {
3165     m_styleSheetCollection.setSelectedStylesheetSetName(aString);
3166     styleResolverChanged(DeferRecalcStyle);
3167 }
3168
3169 void Document::evaluateMediaQueryList()
3170 {
3171     if (m_mediaQueryMatcher)
3172         m_mediaQueryMatcher->styleResolverChanged();
3173 }
3174
3175 void Document::optimizedStyleSheetUpdateTimerFired(Timer<Document>&)
3176 {
3177     styleResolverChanged(RecalcStyleIfNeeded);
3178 }
3179
3180 void Document::scheduleOptimizedStyleSheetUpdate()
3181 {
3182     if (m_optimizedStyleSheetUpdateTimer.isActive())
3183         return;
3184     m_styleSheetCollection.setPendingUpdateType(DocumentStyleSheetCollection::OptimizedUpdate);
3185     m_optimizedStyleSheetUpdateTimer.startOneShot(0);
3186 }
3187
3188 void Document::styleResolverChanged(StyleResolverUpdateFlag updateFlag)
3189 {
3190     if (m_optimizedStyleSheetUpdateTimer.isActive())
3191         m_optimizedStyleSheetUpdateTimer.stop();
3192
3193     // Don't bother updating, since we haven't loaded all our style info yet
3194     // and haven't calculated the style selector for the first time.
3195     if (!hasLivingRenderTree() || (!m_didCalculateStyleResolver && !haveStylesheetsLoaded())) {
3196         m_styleResolver.clear();
3197         return;
3198     }
3199     m_didCalculateStyleResolver = true;
3200
3201 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
3202     if (!ownerElement())
3203         printf("Beginning update of style selector at time %lld.\n", elapsedTime().count());
3204 #endif
3205
3206     DocumentStyleSheetCollection::UpdateFlag styleSheetUpdate = (updateFlag == RecalcStyleIfNeeded || updateFlag == DeferRecalcStyleIfNeeded)
3207         ? DocumentStyleSheetCollection::OptimizedUpdate
3208         : DocumentStyleSheetCollection::FullUpdate;
3209     bool stylesheetChangeRequiresStyleRecalc = m_styleSheetCollection.updateActiveStyleSheets(styleSheetUpdate);
3210
3211     if (updateFlag == DeferRecalcStyle) {
3212         scheduleForcedStyleRecalc();
3213         return;
3214     }
3215
3216     if (updateFlag == DeferRecalcStyleIfNeeded) {
3217         if (stylesheetChangeRequiresStyleRecalc)
3218             scheduleForcedStyleRecalc();
3219         return;
3220     }
3221
3222     if (!stylesheetChangeRequiresStyleRecalc)
3223         return;
3224
3225     // This recalcStyle initiates a new recalc cycle. We need to bracket it to
3226     // make sure animations get the correct update time
3227     {
3228         AnimationUpdateBlock animationUpdateBlock(m_frame ? &m_frame->animation() : nullptr);
3229         recalcStyle(Style::Force);
3230     }
3231
3232 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
3233     if (!ownerElement())
3234         printf("Finished update of style selector at time %lld\n", elapsedTime().count());
3235 #endif
3236
3237     if (renderView()) {
3238         renderView()->setNeedsLayoutAndPrefWidthsRecalc();
3239         if (view())
3240             view()->scheduleRelayout();
3241     }
3242
3243     evaluateMediaQueryList();
3244 }
3245
3246 void Document::notifySeamlessChildDocumentsOfStylesheetUpdate() const
3247 {
3248     // If we're not in a frame yet any potential child documents won't have a StyleResolver to update.
3249     if (!frame())
3250         return;
3251
3252     // Seamless child frames are expected to notify their seamless children recursively, so we only do direct children.
3253     for (Frame* child = frame()->tree().firstChild(); child; child = child->tree().nextSibling()) {
3254         Document* childDocument = child->document();
3255         if (childDocument->shouldDisplaySeamlesslyWithParent()) {
3256             ASSERT(&childDocument->seamlessParentIFrame()->document() == this);
3257             childDocument->seamlessParentUpdatedStylesheets();
3258         }
3259     }
3260 }
3261
3262 void Document::removeFocusedNodeOfSubtree(Node* node, bool amongChildrenOnly)
3263 {
3264     if (!m_focusedElement || this->inPageCache()) // If the document is in the page cache, then we don't need to clear out the focused node.
3265         return;
3266
3267     Element* focusedElement = node->treeScope().focusedElement();
3268     if (!focusedElement)
3269         return;
3270
3271     bool nodeInSubtree = false;
3272     if (amongChildrenOnly)
3273         nodeInSubtree = focusedElement->isDescendantOf(node);
3274     else
3275         nodeInSubtree = (focusedElement == node) || focusedElement->isDescendantOf(node);
3276
3277     if (nodeInSubtree)
3278         setFocusedElement(nullptr);
3279 }
3280
3281 void Document::hoveredElementDidDetach(Element* element)
3282 {
3283     if (!m_hoveredElement || element != m_hoveredElement)
3284         return;
3285
3286     m_hoveredElement = element->parentElement();
3287     while (m_hoveredElement && !m_hoveredElement->renderer())
3288         m_hoveredElement = m_hoveredElement->parentElement();
3289     if (frame())
3290         frame()->eventHandler().scheduleHoverStateUpdate();
3291 }
3292
3293 void Document::elementInActiveChainDidDetach(Element* element)
3294 {
3295     if (!m_activeElement || element != m_activeElement)
3296         return;
3297
3298     m_activeElement = element->parentElement();
3299     while (m_activeElement && !m_activeElement->renderer())
3300         m_activeElement = m_activeElement->parentElement();
3301 }
3302
3303 #if ENABLE(DASHBOARD_SUPPORT)
3304 const Vector<AnnotatedRegionValue>& Document::annotatedRegions() const
3305 {
3306     return m_annotatedRegions;
3307 }
3308
3309 void Document::setAnnotatedRegions(const Vector<AnnotatedRegionValue>& regions)
3310 {
3311     m_annotatedRegions = regions;
3312     setAnnotatedRegionsDirty(false);
3313 }
3314 #endif
3315
3316 bool Document::setFocusedElement(PassRefPtr<Element> prpNewFocusedElement, FocusDirection direction)
3317 {
3318     RefPtr<Element> newFocusedElement = prpNewFocusedElement;
3319
3320     // Make sure newFocusedElement is actually in this document
3321     if (newFocusedElement && (&newFocusedElement->document() != this))
3322         return true;
3323
3324     if (m_focusedElement == newFocusedElement)
3325         return true;
3326
3327     if (m_inPageCache)
3328         return false;
3329
3330     bool focusChangeBlocked = false;
3331     RefPtr<Element> oldFocusedElement = m_focusedElement.release();
3332
3333     // Remove focus from the existing focus node (if any)
3334     if (oldFocusedElement) {
3335         if (oldFocusedElement->active())
3336             oldFocusedElement->setActive(false);
3337
3338         oldFocusedElement->setFocus(false);
3339
3340         // Dispatch a change event for form control elements that have been edited.
3341         if (oldFocusedElement->isFormControlElement()) {
3342             HTMLFormControlElement* formControlElement = toHTMLFormControlElement(oldFocusedElement.get());
3343             if (formControlElement->wasChangedSinceLastFormControlChangeEvent())
3344                 formControlElement->dispatchFormControlChangeEvent();
3345         }
3346
3347         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
3348         oldFocusedElement->dispatchBlurEvent(newFocusedElement);
3349
3350         if (m_focusedElement) {
3351             // handler shifted focus
3352             focusChangeBlocked = true;
3353             newFocusedElement = nullptr;
3354         }
3355
3356         oldFocusedElement->dispatchFocusOutEvent(eventNames().focusoutEvent, newFocusedElement); // DOM level 3 name for the bubbling blur event.
3357         // FIXME: We should remove firing DOMFocusOutEvent event when we are sure no content depends
3358         // on it, probably when <rdar://problem/8503958> is resolved.
3359         oldFocusedElement->dispatchFocusOutEvent(eventNames().DOMFocusOutEvent, newFocusedElement); // DOM level 2 name for compatibility.
3360
3361         if (m_focusedElement) {
3362             // handler shifted focus
3363             focusChangeBlocked = true;
3364             newFocusedElement = nullptr;
3365         }
3366
3367         if (oldFocusedElement->isRootEditableElement())
3368             frame()->editor().didEndEditing();
3369
3370         if (view()) {
3371             if (Widget* oldWidget = widgetForElement(oldFocusedElement.get()))
3372                 oldWidget->setFocus(false);
3373             else
3374                 view()->setFocus(false);
3375         }
3376     }
3377
3378     if (newFocusedElement && newFocusedElement->isFocusable()) {
3379         if (newFocusedElement->isRootEditableElement() && !acceptsEditingFocus(newFocusedElement.get())) {
3380             // delegate blocks focus change
3381             focusChangeBlocked = true;
3382             goto SetFocusedNodeDone;
3383         }
3384         // Set focus on the new node
3385         m_focusedElement = newFocusedElement;
3386
3387         // Dispatch the focus event and let the node do any other focus related activities (important for text fields)
3388         m_focusedElement->dispatchFocusEvent(oldFocusedElement, direction);
3389
3390         if (m_focusedElement != newFocusedElement) {
3391             // handler shifted focus
3392             focusChangeBlocked = true;
3393             goto SetFocusedNodeDone;
3394         }
3395
3396         m_focusedElement->dispatchFocusInEvent(eventNames().focusinEvent, oldFocusedElement); // DOM level 3 bubbling focus event.
3397
3398         if (m_focusedElement != newFocusedElement) {
3399             // handler shifted focus
3400             focusChangeBlocked = true;
3401             goto SetFocusedNodeDone;
3402         }
3403
3404         // FIXME: We should remove firing DOMFocusInEvent event when we are sure no content depends
3405         // on it, probably when <rdar://problem/8503958> is m.
3406         m_focusedElement->dispatchFocusInEvent(eventNames().DOMFocusInEvent, oldFocusedElement); // DOM level 2 for compatibility.
3407
3408         if (m_focusedElement != newFocusedElement) {
3409             // handler shifted focus
3410             focusChangeBlocked = true;
3411             goto SetFocusedNodeDone;
3412         }
3413
3414         m_focusedElement->setFocus(true);
3415
3416         if (m_focusedElement->isRootEditableElement())
3417             frame()->editor().didBeginEditing();
3418
3419         // eww, I suck. set the qt focus correctly
3420         // ### find a better place in the code for this
3421         if (view()) {
3422             Widget* focusWidget = widgetForElement(m_focusedElement.get());
3423             if (focusWidget) {
3424                 // Make sure a widget has the right size before giving it focus.
3425                 // Otherwise, we are testing edge cases of the Widget code.
3426                 // Specifically, in WebCore this does not work well for text fields.
3427                 updateLayout();
3428                 // Re-get the widget in case updating the layout changed things.
3429                 focusWidget = widgetForElement(m_focusedElement.get());
3430             }
3431             if (focusWidget)
3432                 focusWidget->setFocus(true);
3433             else
3434                 view()->setFocus(true);
3435         }
3436     }
3437
3438     if (!focusChangeBlocked && m_focusedElement) {
3439         // Create the AXObject cache in a focus change because GTK relies on it.
3440         if (AXObjectCache* cache = axObjectCache())
3441             cache->handleFocusedUIElementChanged(oldFocusedElement.get(), newFocusedElement.get());
3442     }
3443
3444     if (!focusChangeBlocked && page())
3445         page()->chrome().focusedElementChanged(m_focusedElement.get());
3446
3447 SetFocusedNodeDone:
3448     updateStyleIfNeeded();
3449     return !focusChangeBlocked;
3450 }
3451
3452 void Document::setCSSTarget(Element* n)
3453 {
3454     if (m_cssTarget)
3455         m_cssTarget->didAffectSelector(AffectedSelectorTarget);
3456     m_cssTarget = n;
3457     if (n)
3458         n->didAffectSelector(AffectedSelectorTarget);
3459 }
3460
3461 void Document::registerNodeList(LiveNodeList& list)
3462 {
3463     m_nodeListAndCollectionCounts[list.invalidationType()]++;
3464     if (list.isRootedAtDocument())
3465         m_listsInvalidatedAtDocument.add(&list);
3466 }
3467
3468 void Document::unregisterNodeList(LiveNodeList& list)
3469 {
3470     m_nodeListAndCollectionCounts[list.invalidationType()]--;
3471     if (list.isRootedAtDocument()) {
3472         ASSERT(m_listsInvalidatedAtDocument.contains(&list));
3473         m_listsInvalidatedAtDocument.remove(&list);
3474     }
3475 }
3476
3477 void Document::registerCollection(HTMLCollection& collection)
3478 {
3479     m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]++;
3480     m_nodeListAndCollectionCounts[collection.invalidationType()]++;
3481     if (collection.isRootedAtDocument())
3482         m_collectionsInvalidatedAtDocument.add(&collection);
3483 }
3484
3485 void Document::unregisterCollection(HTMLCollection& collection)
3486 {
3487     m_nodeListAndCollectionCounts[InvalidateOnIdNameAttrChange]--;
3488     m_nodeListAndCollectionCounts[collection.invalidationType()]--;
3489     if (collection.isRootedAtDocument()) {
3490         ASSERT(m_collectionsInvalidatedAtDocument.contains(&collection));
3491         m_collectionsInvalidatedAtDocument.remove(&collection);
3492     }
3493 }
3494
3495 void Document::attachNodeIterator(NodeIterator* ni)
3496 {
3497     m_nodeIterators.add(ni);
3498 }
3499
3500 void Document::detachNodeIterator(NodeIterator* ni)
3501 {
3502     // The node iterator can be detached without having been attached if its root node didn't have a document
3503     // when the iterator was created, but has it now.
3504     m_nodeIterators.remove(ni);
3505 }
3506
3507 void Document::moveNodeIteratorsToNewDocument(Node* node, Document* newDocument)
3508 {
3509     HashSet<NodeIterator*> nodeIteratorsList = m_nodeIterators;
3510     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = nodeIteratorsList.end();
3511     for (HashSet<NodeIterator*>::const_iterator it = nodeIteratorsList.begin(); it != nodeIteratorsEnd; ++it) {
3512         if ((*it)->root() == node) {
3513             detachNodeIterator(*it);
3514             newDocument->attachNodeIterator(*it);
3515         }
3516     }
3517 }
3518
3519 void Document::updateRangesAfterChildrenChanged(ContainerNode& container)
3520 {
3521     if (!m_ranges.isEmpty()) {
3522         for (auto it = m_ranges.begin(), end = m_ranges.end(); it != end; ++it)
3523             (*it)->nodeChildrenChanged(container);
3524     }
3525 }
3526
3527 void Document::nodeChildrenWillBeRemoved(ContainerNode& container)
3528 {
3529     if (!m_ranges.isEmpty()) {
3530         for (auto it = m_ranges.begin(), end = m_ranges.end(); it != end; ++it)
3531             (*it)->nodeChildrenWillBeRemoved(container);
3532     }
3533
3534     for (auto it = m_nodeIterators.begin(), end = m_nodeIterators.end(); it != end; ++it) {
3535         for (Node* n = container.firstChild(); n; n = n->nextSibling())
3536             (*it)->nodeWillBeRemoved(n);
3537     }
3538
3539     if (Frame* frame = this->frame()) {
3540         for (Node* n = container.firstChild(); n; n = n->nextSibling()) {
3541             frame->eventHandler().nodeWillBeRemoved(n);
3542             frame->selection().nodeWillBeRemoved(n);
3543             frame->page()->dragCaretController().nodeWillBeRemoved(n);
3544         }
3545     }
3546 }
3547
3548 void Document::nodeWillBeRemoved(Node* n)
3549 {
3550     HashSet<NodeIterator*>::const_iterator nodeIteratorsEnd = m_nodeIterators.end();
3551     for (HashSet<NodeIterator*>::const_iterator it = m_nodeIterators.begin(); it != nodeIteratorsEnd; ++it)
3552         (*it)->nodeWillBeRemoved(n);
3553
3554     if (!m_ranges.isEmpty()) {
3555         HashSet<Range*>::const_iterator rangesEnd = m_ranges.end();
3556         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != rangesEnd; ++it)
3557             (*it)->nodeWillBeRemoved(n);
3558     }
3559
3560     if (Frame* frame = this->frame()) {
3561         frame->eventHandler().nodeWillBeRemoved(n);
3562         frame->selection().nodeWillBeRemoved(n);
3563         frame->page()->dragCaretController().nodeWillBeRemoved(n);
3564     }
3565 }
3566
3567 void Document::textInserted(Node* text, unsigned offset, unsigned length)
3568 {
3569     if (!m_ranges.isEmpty()) {
3570         HashSet<Range*>::const_iterator end = m_ranges.end();
3571         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3572             (*it)->textInserted(text, offset, length);
3573     }
3574
3575     // Update the markers for spelling and grammar checking.
3576     m_markers->shiftMarkers(text, offset, length);
3577 }
3578
3579 void Document::textRemoved(Node* text, unsigned offset, unsigned length)
3580 {
3581     if (!m_ranges.isEmpty()) {
3582         HashSet<Range*>::const_iterator end = m_ranges.end();
3583         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3584             (*it)->textRemoved(text, offset, length);
3585     }
3586
3587     // Update the markers for spelling and grammar checking.
3588     m_markers->removeMarkers(text, offset, length);
3589     m_markers->shiftMarkers(text, offset + length, 0 - length);
3590 }
3591
3592 void Document::textNodesMerged(Text* oldNode, unsigned offset)
3593 {
3594     if (!m_ranges.isEmpty()) {
3595         NodeWithIndex oldNodeWithIndex(oldNode);
3596         HashSet<Range*>::const_iterator end = m_ranges.end();
3597         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3598             (*it)->textNodesMerged(oldNodeWithIndex, offset);
3599     }
3600
3601     // FIXME: This should update markers for spelling and grammar checking.
3602 }
3603
3604 void Document::textNodeSplit(Text* oldNode)
3605 {
3606     if (!m_ranges.isEmpty()) {
3607         HashSet<Range*>::const_iterator end = m_ranges.end();
3608         for (HashSet<Range*>::const_iterator it = m_ranges.begin(); it != end; ++it)
3609             (*it)->textNodeSplit(oldNode);
3610     }
3611
3612     // FIXME: This should update markers for spelling and grammar checking.
3613 }
3614
3615 void Document::createDOMWindow()
3616 {
3617     ASSERT(m_frame);
3618     ASSERT(!m_domWindow);
3619
3620     m_domWindow = DOMWindow::create(this);
3621
3622     ASSERT(m_domWindow->document() == this);
3623     ASSERT(m_domWindow->frame() == m_frame);
3624 }
3625
3626 void Document::takeDOMWindowFrom(Document* document)
3627 {
3628     ASSERT(m_frame);
3629     ASSERT(!m_domWindow);
3630     ASSERT(document->m_domWindow);
3631     // A valid DOMWindow is needed by CachedFrame for its documents.
3632     ASSERT(!document->inPageCache());
3633
3634     m_domWindow = document->m_domWindow.release();
3635     m_domWindow->didSecureTransitionTo(this);
3636
3637     ASSERT(m_domWindow->document() == this);
3638     ASSERT(m_domWindow->frame() == m_frame);
3639 }
3640
3641 void Document::setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener)
3642 {
3643     if (!m_domWindow)
3644         return;
3645     m_domWindow->setAttributeEventListener(eventType, listener);
3646 }
3647
3648 void Document::setWindowAttributeEventListener(const AtomicString& eventType, const QualifiedName& attributeName, const AtomicString& attributeValue)
3649 {
3650     if (!m_frame)
3651         return;
3652     setWindowAttributeEventListener(eventType, JSLazyEventListener::createForDOMWindow(*m_frame, attributeName, attributeValue));
3653 }
3654