+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012, 2013 Apple Inc. All rights reserved.

+#include "CustomElementConstructor.h"

+#include "CustomElementRegistry.h"

+#include "Dictionary.h"

+#include "DocumentSharedObjectPool.h"

+#include "FontLoader.h"

+#include "HTMLFormControlElement.h"

+#include "HTMLPlugInElement.h"

+#include "HTMLScriptElement.h"

+#include "IconController.h"

+#include "NodeTraversal.h"

+#include "PageConsole.h"

+#include "PlugInsResources.h"

+#include "ResourceLoader.h"

+#include "ScriptSourceCode.h"

+#include "ScriptValue.h"

+#include "StylePropertySet.h"

+#include "VisitedLinkState.h"

+#if ENABLE(VIDEO_TRACK)

+#include "CaptionUserPreferences.h"

+#endif

+

+ return url.isEmpty() || url.isBlankURL();

+ return frame->editor().shouldBeginEditing(rangeOfContents(root).get());

+static void printNavigationErrorMessage(Frame* frame, const KURL& activeURL, const char* reason)

+ String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame->document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";

+static const double timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds = 30;

+

+Document::Document(Frame* frame, const KURL& url, unsigned documentClasses)

+ , m_styleResolverThrowawayTimer(this, &Document::styleResolverThrowawayTimerFired, timeBeforeThrowingAwayStyleResolverAfterLastUseInSeconds)

+ , m_didCalculateStyleResolver(false)

+ , m_hasNodesWithPlaceholderStyle(false)

+ , m_needsNotifyRemoveAllPendingStylesheet(false)

+ , m_ignorePendingStylesheets(false)

+ , m_pendingSheetLayout(NoLayoutWithPendingSheets)

+ , m_frame(frame)

+ , m_activeParserCount(0)

+ , m_wellFormed(false)

+ , m_printing(false)

+ , m_paginatedForScreen(false)

+ , m_ignoreAutofocus(false)

+ , m_textColor(Color::black)

+ , m_listenerTypes(0)

+ , m_visitedLinkState(VisitedLinkState::create(this))

+ , m_visuallyOrdered(false)

+ , m_bParsing(false)

+ , m_inStyleRecalc(false)

+ , m_closeAfterStyleRecalc(false)

+ , m_gotoAnchorNeededAfterStylesheetsLoad(false)

+ , m_cssTarget(0)

+ , m_processingLoadEvent(false)

+ , m_xmlVersion(ASCIILiteral("1.0"))

+ , m_documentClasses(documentClasses)

+ , m_weakFactory(this)

+ , m_lastHandledUserGestureTimestamp(0)

+ , m_sharedObjectPoolClearTimer(this, &Document::sharedObjectPoolClearTimerFired)

+#if ENABLE(TEMPLATE_ELEMENT)

+ , m_templateDocumentHost(0)

+#endif

+#if ENABLE(FONT_LOAD_EVENTS)

+ , m_fontloader(0)

+#endif

+ , m_didAssociateFormControlsTimer(this, &Document::didAssociateFormControlsTimerFired)

+ , m_hasInjectedPlugInsScript(false)

+static bool isAttributeOnAllOwners(const WebCore::QualifiedName& attribute, const WebCore::QualifiedName& prefixedAttribute, const HTMLFrameOwnerElement* owner)

+ if (!(owner->hasAttribute(attribute) || owner->hasAttribute(prefixedAttribute)))

+ ASSERT(!hasGuardRefCount());

+

+#if ENABLE(TEMPLATE_ELEMENT)

+ if (m_templateDocument)

+ m_templateDocument->setTemplateDocumentHost(0); // balanced in templateDocument().

+#endif

+#if ENABLE(TOUCH_EVENT_TRACKING)

+ if (Document* ownerDocument = this->ownerDocument())

+ ownerDocument->didRemoveEventTargetNode(this);

+#endif

+ if (this == topDocument())

+ clearAXObjectCache();

+ clearDocumentScope();

+void Document::dispose()

+ // We must make sure not to be retaining any of our children through

+ // these extra pointers or we will create a reference cycle.

+ m_docType = 0;

+ m_focusedElement = 0;

+ m_hoveredElement = 0;

+ m_activeElement = 0;

+ m_titleElement = 0;

+ m_documentElement = 0;

+ m_contextFeatures = ContextFeatures::defaultSwitch();

+ m_userActionElements.documentDidRemoveLastRef();

+ m_fullScreenElement = 0;

+ m_fullScreenElementStack.clear();

+ detachParser();

+

+#if ENABLE(CUSTOM_ELEMENTS)

+ m_registry.clear();

+#endif

+ // removeDetachedChildren() doesn't always unregister IDs,

+ // so tear down scope information upfront to avoid having stale references in the map.

+ destroyTreeScopeData();

+ removeDetachedChildren();

+ m_formController.clear();

+ m_markers->detach();

+ m_cssCanvasElements.clear();

+ clearScriptedAnimationController();

+ ContainerNode* rootNode = scope->rootNode();

+ for (Element* element = ElementTraversal::firstWithin(rootNode); element; element = ElementTraversal::next(element, rootNode)) {

+ if (ShadowRoot* root = element->shadowRoot())

+

+ if (m_selectorQueryCache)

+ m_selectorQueryCache->invalidate();

+

+ m_styleSheetCollection->clearPageUserSheet();

+bool Document::hasManifest() const

+{

+ return documentElement() && documentElement()->hasTagName(htmlTag) && documentElement()->hasAttribute(manifestAttr);

+}

+

+ Element* newDocumentElement = ElementTraversal::firstWithin(this);

+ if (isXHTMLDocument())

+#if ENABLE(CUSTOM_ELEMENTS)

+PassRefPtr<Element> Document::createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionCode& ec)

+{

+ if (!isValidName(localName)) {

+ ec = INVALID_CHARACTER_ERR;

+ return 0;

+ }

+

+ if (m_registry) {

+ if (PassRefPtr<Element> created = m_registry->createElement(QualifiedName(nullAtom, localName, xhtmlNamespaceURI), typeExtension))

+ return created;

+ }

+

+ return setTypeExtension(createElement(localName, ec), typeExtension);

+}

+

+PassRefPtr<Element> Document::createElementNS(const AtomicString& namespaceURI, const String& qualifiedName, const AtomicString& typeExtension, ExceptionCode& ec)

+{

+ String prefix, localName;

+ if (!parseQualifiedName(qualifiedName, prefix, localName, ec))

+ return 0;

+

+ QualifiedName qName(prefix, localName, namespaceURI);

+ if (!hasValidNamespaceForElements(qName)) {

+ ec = NAMESPACE_ERR;

+ return 0;

+ }

+

+ if (m_registry) {

+ if (PassRefPtr<Element> created = m_registry->createElement(qName, typeExtension))

+ return created;

+ }

+

+ return setTypeExtension(createElementNS(namespaceURI, qualifiedName, ec), typeExtension);

+}

+

+PassRefPtr<CustomElementConstructor> Document::registerElement(WebCore::ScriptState* state, const AtomicString& name, ExceptionCode& ec)

+{

+ return registerElement(state, name, Dictionary(), ec);

+}

+

+PassRefPtr<CustomElementConstructor> Document::registerElement(WebCore::ScriptState* state, const AtomicString& name, const Dictionary& options, ExceptionCode& ec)

+{

+ if (!isHTMLDocument() && !isXHTMLDocument()) {

+ ec = NOT_SUPPORTED_ERR;

+ return 0;

+ }

+

+ if (!m_registry)

+ m_registry = adoptRef(new CustomElementRegistry(this));

+ return m_registry->registerElement(state, name, options, ec);

+}

+

+void Document::didCreateCustomElement(Element* element, CustomElementConstructor* constructor)

+{

+ // m_registry is cleared Document::dispose() and can be null here.

+ if (m_registry)

+ m_registry->didCreateElement(element);

+}

+#endif // ENABLE(CUSTOM_ELEMENTS)

+

+ return MutableStylePropertySet::create()->ensureCSSStyleDeclaration();

+ Element* oldElement = toElement(importedNode);

+bool Document::cssCompositingEnabled() const

+{

+ return RuntimeEnabledFeatures::cssCompositingEnabled();

+}

+

+

+ if (!view()->visualUpdatesAllowedByClient())

+ return;

+

+ if (visualUpdatesAllowed)

+ m_visualUpdatesSuppressionTimer.stop();

+ else

+ m_visualUpdatesSuppressionTimer.startOneShot(settings()->incrementalRenderingSuppressionTimeoutInSeconds());

+

+ FrameView* frameView = view();

+ bool needsLayout = frameView && renderer() && (frameView->layoutPending() || renderer()->needsLayout());

+ if (needsLayout)

+ updateLayout();

+

+ if (Page* page = this->page()) {

+ if (frame() == page->mainFrame())

+ frameView->addPaintPendingMilestones(DidFirstPaintAfterSuppressedIncrementalRendering);

+ if (page->requestedLayoutMilestones() & DidFirstLayoutAfterSuppressedIncrementalRendering)

+ frame()->loader()->didLayout(DidFirstLayoutAfterSuppressedIncrementalRendering);

+ }

+

+ if (RenderView* renderView = this->renderView())

+ renderView->repaintViewAndCompositedLayers();

+

+ if (Frame* frame = this->frame())

+ frame->loader()->forcePageTransitionIfNeeded();

+

+ // If the client is extending the visual update suppression period explicitly, the

+ // watchdog should not re-enable visual updates itself, but should wait for the client.

+ if (!view()->visualUpdatesAllowedByClient())

+ return;

+

+void Document::setVisualUpdatesAllowedByClient(bool visualUpdatesAllowedByClient)

+{

+ // We should only re-enable visual updates if ReadyState is Completed or the watchdog timer has fired,

+ // both of which we can determine by looking at the timer.

+

+ if (visualUpdatesAllowedByClient && !m_visualUpdatesSuppressionTimer.isActive() && !visualUpdatesAllowed())

+ setVisualUpdatesAllowed(true);

+}

+

+ // FIXME: This should probably use insert(), but that's (intentionally)

+ // not implemented for the XML parser as it's normally synonymous with

+ // document.write(). append() will end up yielding, but close() will

+ // pump the tokenizer syncrhonously and finish the parse.

+ m_parser->pinToMainThread();

+ m_parser->append(content.impl());

+ if (isXHTMLDocument())

+ if (isSVGDocument())

+ if (xmlStandalone())

+ if (isHTMLDocument())

+

+ return TreeScope::elementFromPoint(x, y);

+ Node* node = nodeFromPoint(this, x, y, &localPoint);

+ headElement->appendChild(m_titleElement, ASSERT_NO_EXCEPTION);

+ ASSERT(isHTMLTitleElement(m_titleElement.get()));

+ if (isHTMLTitleElement(m_titleElement.get()))

+ toHTMLTitleElement(m_titleElement.get())->setText(title);

+ if (isHTMLTitleElement(e)) {

+ HTMLTitleElement* titleElement = toHTMLTitleElement(e);

+FormController& Document::formController()

+ return *m_formController;

+ formController().setStateForNewFormElements(stateVector);

+ PostAttachCallbackDisabler disabler(this);

+ Element* element = toElement(n);

+

+ // As a result of the style recalculation, the currently hovered element might have been

+ // detached (for example, by setting display:none in the :hover style), schedule another mouseMove event

+ // to check if any other elements ended up under the mouse pointer due to re-layout.

+ if (m_hoveredElement && !m_hoveredElement->renderer() && frame())

+ frame()->eventHandler()->dispatchFakeMouseMoveEventSoon();

+

+ FrameView* frameView = view();

+ if (frameView && frameView->isInLayout()) {

+ // View layout should not be re-entrant.

+ ASSERT_NOT_REACHED();

+ return;

+ }

+

+

+ if (frameView && renderer() && (frameView->layoutPending() || renderer()->needsLayout()))

+ frameView->layout();

+ RefPtr<RenderStyle> style = ensureStyleResolver()->styleForElement(element, element->parentNode() ? element->parentNode()->computedStyle() : 0);

+ RefPtr<RenderStyle> style = ensureStyleResolver()->styleForPage(pageIndex);

+void Document::attach(const AttachContext& context)

+ m_renderArena = RenderArena::create();

+ setRenderer(new (m_renderArena.get()) RenderView(this));

+ renderView()->setIsInWindow(true);

+ ContainerNode::attach(context);

+void Document::detach(const AttachContext& context)

+ clearScriptedAnimationController();

+ m_hoveredElement = 0;

+ m_focusedElement = 0;

+ m_activeElement = 0;

+ ContainerNode::detach(context);

+#if ENABLE(TOUCH_EVENTS)

+ if (m_touchEventTargets && m_touchEventTargets->size() && parentDocument())

+ parentDocument()->didRemoveEventTargetNode(this);

+#endif

+

+ for (Node* node = firstChild(); node; node = NodeTraversal::next(node))

+void Document::resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension why)

+ ScriptExecutionContext::resumeActiveDOMObjects(why);

+ ASSERT(topDocument() == this);

+ m_axObjectCache.clear();

+AXObjectCache* Document::existingAXObjectCache() const

+ if (!AXObjectCache::accessibilityEnabled())

+ return 0;

+

+ // If the renderer is gone then we are in the process of destruction.

+ // This method will be called before m_frame = 0.

+ if (!topDocument()->renderer())

+ return 0;

+

+ return topDocument()->m_axObjectCache.get();

+ if (!AXObjectCache::accessibilityEnabled())

+ return 0;

+

+

+ // If the document has already been detached, do not make a new axObjectCache.

+ if (!topDocument->renderer())

+ return 0;

+

+ topDocument->m_axObjectCache = adoptPtr(new AXObjectCache(topDocument));

+ // Documents rendered seamlessly should start out requiring a stylesheet

+ // collection update in order to ensure they inherit all the relevant data

+ // from their parent.

+ if (shouldDisplaySeamlesslyWithParent())

+ styleResolverChanged(DeferRecalcStyle);

+

+ // Call to dispatchWindowLoadEvent can blow us from underneath.

+ RefPtr<Document> protect(this);

+

+ f->animation()->startAnimationsIfNotSuspended(this);

+ if (view() && renderer() && (!renderer()->firstChild() || renderer()->needsLayout()))

+#if PLATFORM(MAC) || PLATFORM(WIN)

+ if (f && renderer() && AXObjectCache::accessibilityEnabled()) {

+ axObjectCache()->getOrCreate(renderer());

+ axObjectCache()->postNotification(renderer(), AXObjectCache::AXLoadComplete, true);

+ axObjectCache()->postNotification(renderer(), AXObjectCache::AXLayoutComplete, true);

+

+ if (m_bParsing && !m_sharedObjectPool)

+ m_sharedObjectPool = DocumentSharedObjectPool::create();

+

+void Document::logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack> callStack)

+ addMessage(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber, columnNumber, callStack);

+ m_baseURL = KURL(ParsedURLString, documentURI());

+

+ if (m_selectorQueryCache)

+ m_selectorQueryCache->invalidate();

+ for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::next(element)) {

+ if (isHTMLAnchorElement(element))

+ toHTMLAnchorElement(element)->invalidateCachedVisitedLinkHash();

+ for (Element* element = ElementTraversal::firstWithin(this); element && (!href || !target); element = ElementTraversal::next(element)) {

+ if (element->hasTagName(baseTag)) {

+ const AtomicString& value = element->fastGetAttribute(hrefAttr);

+ const AtomicString& value = element->fastGetAttribute(targetAttr);

+ if (m_baseElementURL != baseElementURL && contentSecurityPolicy()->allowBaseURI(baseElementURL)) {

+ // Frame-busting is generally allowed, but blocked for sandboxed frames lacking the 'allow-top-navigation' flag.

+ const char* reason = "The frame attempting navigation is sandboxed, and is therefore disallowed from navigating its ancestors.";

+ if (isSandboxed(SandboxTopNavigation) && targetFrame == m_frame->tree()->top())

+ reason = "The frame attempting navigation of the top-level window is sandboxed, but the 'allow-top-navigation' flag is not set.";

+

+ printNavigationErrorMessage(targetFrame, url(), reason);

+ printNavigationErrorMessage(targetFrame, url(), "The frame attempting navigation is neither same-origin with the target, nor is it the target's parent or opener.");

+ if (!currentFrame)

+ return 0;

+

+ Frame* ancestorFrame = currentFrame->tree()->parent();

+ // Exception (for sandboxed documents) ignored.

+ toHTMLDocument(this)->setCookie(content, IGNORE_EXCEPTION);

+ String message = "Refused to display '" + url().stringCenterEllipsizedToLength() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";

+ // Stopping the loader isn't enough, as we're already parsing the document; to honor the header's

+ // intent, we must navigate away from the possibly partially-rendered document to a location that

+ // doesn't inherit the parent's SecurityOrigin.

+ frame->navigationScheduler()->scheduleLocationChange(securityOrigin(), SecurityOrigin::urlWithUniqueSecurityOrigin(), String());

+ addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, message, requestIdentifier);

+ contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Enforce);

+ contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::Report);

+ contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedEnforce);

+ contentSecurityPolicy()->didReceiveHeader(content, ContentSecurityPolicy::PrefixedReport);

+ ASSERT_WITH_SECURITY_IMPLICATION(i <= length);

+ page()->chrome().dispatchViewportPropertiesDidChange(m_viewportArguments);

+ updateHoverActiveState(request, result.innerElement(), &event);

+ DocumentStyleSheetCollection::UpdateFlag styleSheetUpdate = (updateFlag == RecalcStyleIfNeeded || updateFlag == DeferRecalcStyleIfNeeded)

+ if (updateFlag == DeferRecalcStyleIfNeeded) {

+ if (stylesheetChangeRequiresStyleRecalc)

+ scheduleForcedStyleRecalc();

+ return;

+ }

+

+void Document::setActiveElement(PassRefPtr<Element> newActiveElement)

+ if (!newActiveElement) {

+ m_activeElement.clear();

+ return;

+ }

+ m_activeElement = newActiveElement;

+ if (!m_focusedElement || this->inPageCache()) // If the document is in the page cache, then we don't need to clear out the focused node.

+ Element* focusedElement = node->treeScope()->focusedElement();

+ if (!focusedElement)

+ nodeInSubtree = focusedElement->isDescendantOf(node);

+ nodeInSubtree = (focusedElement == node) || focusedElement->isDescendantOf(node);

+ setFocusedElement(0);

+void Document::hoveredElementDidDetach(Element* element)

+ if (!m_hoveredElement || element != m_hoveredElement)

+ m_hoveredElement = element->parentElement();

+ while (m_hoveredElement && !m_hoveredElement->renderer())

+ m_hoveredElement = m_hoveredElement->parentElement();

+void Document::elementInActiveChainDidDetach(Element* element)

+ if (!m_activeElement || element != m_activeElement)

+ m_activeElement = element->parentElement();

+ while (m_activeElement && !m_activeElement->renderer())

+ m_activeElement = m_activeElement->parentElement();

+bool Document::setFocusedElement(PassRefPtr<Element> prpNewFocusedElement, FocusDirection direction)

+ RefPtr<Element> newFocusedElement = prpNewFocusedElement;

+ // Make sure newFocusedElement is actually in this document

+ if (newFocusedElement && (newFocusedElement->document() != this))

+ if (m_focusedElement == newFocusedElement)

+ RefPtr<Element> oldFocusedElement = m_focusedElement.release();

+ if (oldFocusedElement) {

+ ASSERT(!oldFocusedElement->inDetach());

+ if (oldFocusedElement->active())

+ oldFocusedElement->setActive(false);

+ oldFocusedElement->setFocus(false);

+ // Dispatch a change event for form control elements that have been edited.

+ if (oldFocusedElement->isFormControlElement()) {

+ HTMLFormControlElement* formControlElement = toHTMLFormControlElement(oldFocusedElement.get());

+ if (formControlElement->wasChangedSinceLastFormControlChangeEvent())

+ formControlElement->dispatchFormControlChangeEvent();

+ oldFocusedElement->dispatchBlurEvent(newFocusedElement);

+ if (m_focusedElement) {

+ newFocusedElement = 0;

+ oldFocusedElement->dispatchFocusOutEvent(eventNames().focusoutEvent, newFocusedElement); // DOM level 3 name for the bubbling blur event.

+ oldFocusedElement->dispatchFocusOutEvent(eventNames().DOMFocusOutEvent, newFocusedElement); // DOM level 2 name for compatibility.

+ if (m_focusedElement) {

+ newFocusedElement = 0;

+ if (oldFocusedElement->isRootEditableElement())

+ frame()->editor().didEndEditing();

+ Widget* oldWidget = widgetForNode(oldFocusedElement.get());

+ if (newFocusedElement && newFocusedElement->isFocusable()) {

+ if (newFocusedElement->isRootEditableElement() && !acceptsEditingFocus(newFocusedElement.get())) {

+ m_focusedElement = newFocusedElement;

+ m_focusedElement->dispatchFocusEvent(oldFocusedElement, direction);

+ if (m_focusedElement != newFocusedElement) {

+ m_focusedElement->dispatchFocusInEvent(eventNames().focusinEvent, oldFocusedElement); // DOM level 3 bubbling focus event.

+ if (m_focusedElement != newFocusedElement) {

+ m_focusedElement->dispatchFocusInEvent(eventNames().DOMFocusInEvent, oldFocusedElement); // DOM level 2 for compatibility.

+ if (m_focusedElement != newFocusedElement) {

+ m_focusedElement->setFocus(true);

+

+ if (m_focusedElement->isRootEditableElement())

+ frame()->editor().didBeginEditing();

+ Widget* focusWidget = widgetForNode(m_focusedElement.get());

+ focusWidget = widgetForNode(m_focusedElement.get());

+ if (!focusChangeBlocked && m_focusedElement) {

+ // Create the AXObject cache in a focus change because GTK relies on it.

+ if (AXObjectCache* cache = axObjectCache())

+ cache->handleFocusedUIElementChanged(oldFocusedElement.get(), newFocusedElement.get());

+ }

+

+ page()->chrome().focusedNodeChanged(m_focusedElement.get());

+ if (m_cssTarget)

+ m_cssTarget->didAffectSelector(AffectedSelectorTarget);

+ if (n)

+ n->didAffectSelector(AffectedSelectorTarget);

+ else if (eventType == eventNames().webkitTransitionEndEvent || eventType == eventNames().transitionendEvent)

+ renderView()->setIsInWindow(false);

+ renderView()->setIsInWindow(true);

+#if ENABLE(VIDEO_TRACK)

+void Document::registerForCaptionPreferencesChangedCallbacks(Element* e)

+{

+ if (page())

+ page()->group().captionPreferences()->setInterestedInCaptionPreferenceChanges();

+

+ m_captionPreferencesChangedElements.add(e);

+}

+

+void Document::unregisterForCaptionPreferencesChangedCallbacks(Element* e)

+{

+ m_captionPreferencesChangedElements.remove(e);

+}

+

+void Document::captionPreferencesChanged()

+{

+ HashSet<Element*>::iterator end = m_captionPreferencesChangedElements.end();

+ for (HashSet<Element*>::iterator it = m_captionPreferencesChangedElements.begin(); it != end; ++it)

+ (*it)->captionPreferencesChanged();

+}

+#endif

+

+ return frame->editor().command(commandName,

+void Document::pushCurrentScript(PassRefPtr<HTMLScriptElement> newCurrentScript)

+{

+ ASSERT(newCurrentScript);

+ m_currentScriptStack.append(newCurrentScript);

+}

+

+void Document::popCurrentScript()

+{

+ ASSERT(!m_currentScriptStack.isEmpty());

+ m_currentScriptStack.removeLast();

+}

+

+ Frame* ownerFrame = frame();

+ processor->createDocumentFromSource(newSource, resultEncoding, resultMIMEType, this, ownerFrame);

+ InspectorInstrumentation::frameDocumentUpdated(ownerFrame);

+ return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLAllCollection>(this, DocAll);

+ return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<WindowNameCollection>(this, WindowNamedItems, name);

+ return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<DocumentNameCollection>(this, DocumentNamedItems, name);

+ // Schedule dropping of the DocumentSharedObjectPool. We keep it alive for a while after parsing finishes

+ // so that dynamically inserted content can also benefit from sharing optimizations.

+ // Note that we don't refresh the timer on pool access since that could lead to huge caches being kept

+ // alive indefinitely by something innocuous like JS setting .innerHTML repeatedly on a timer.

+ static const int timeToKeepSharedObjectPoolAliveAfterParsingFinishedInSeconds = 10;

+ m_sharedObjectPoolClearTimer.startOneShot(timeToKeepSharedObjectPoolAliveAfterParsingFinishedInSeconds);

+

+ // Parser should have picked up all preloads by now

+ m_cachedResourceLoader->clearPreloads();

+}

+

+void Document::sharedObjectPoolClearTimerFired(Timer<Document>*)

+{

+ m_sharedObjectPool.clear();

+}

+

+void Document::didAccessStyleResolver()

+{

+ m_styleResolverThrowawayTimer.restart();

+}

+

+void Document::styleResolverThrowawayTimerFired(DeferrableOneShotTimer<Document>*)

+{

+ ASSERT(!m_inStyleRecalc);

+ clearStyleResolver();

+const Vector<IconURL>& Document::shortcutIconURLs()

+{

+ // Include any icons where type = link, rel = "shortcut icon".

+ return iconURLs(Favicon);

+}

+

+const Vector<IconURL>& Document::iconURLs(int iconTypesMask)

+ if (!(linkElement->iconType() & iconTypesMask))

+ m_iconURLs.append(newURL);

+ m_iconURLs.reverse();

+void Document::addIconURL(const String& url, const String&, const String&, IconType iconType)

+ Frame* f = frame();

+ if (!f)

+ f->loader()->didChangeIcons(iconType);

+ m_mayDisplaySeamlesslyWithParent = isEligibleForSeamless(parentDocument, this);

+ Element* element = focusedElement();

+ if (!element)

+void Document::addConsoleMessage(MessageSource source, MessageLevel level, const String& message, unsigned long requestIdentifier)

+ postTask(AddConsoleMessageTask::create(source, level, message));

+ if (Page* page = this->page())

+ page->console()->addMessage(source, level, message, requestIdentifier, this);

+}

+

+void Document::addMessage(MessageSource source, MessageLevel level, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, PassRefPtr<ScriptCallStack> callStack, ScriptState* state, unsigned long requestIdentifier)

+{

+ if (!isContextThread()) {

+ postTask(AddConsoleMessageTask::create(source, level, message));

+ return;

+

+ if (Page* page = this->page())

+ page->console()->addMessage(source, level, message, sourceURL, lineNumber, columnNumber, callStack, state, requestIdentifier);

+}

+

+SecurityOrigin* Document::topOrigin() const

+{

+ return topDocument()->securityOrigin();

+ PerformTaskContext(WeakPtr<Document> document, PassOwnPtr<ScriptExecutionContext::Task> task)

+ : documentReference(document)

+ WeakPtr<Document> documentReference;

+ Document* document = context->documentReference.get();

+ callOnMainThread(didReceiveTask, new PerformTaskContext(m_weakFactory.createWeakPtr(), task));

+void Document::resumeScheduledTasks(ActiveDOMObject::ReasonForSuspension reason)

+ if (reasonForSuspendingActiveDOMObjects() != reason)

+ return;

+

+ resumeActiveDOMObjects(reason);

+void Document::scriptedAnimationControllerSetThrottled(bool isThrottled)

+{

+#if ENABLE(REQUEST_ANIMATION_FRAME)

+ if (m_scriptedAnimationController)

+ m_scriptedAnimationController->setThrottled(isThrottled);

+#endif

+}

+

+ return isAttributeOnAllOwners(allowfullscreenAttr, webkitallowfullscreenAttr, element->document()->ownerElement());

+ if (!page()->chrome().client()->supportsFullScreenForElement(element, flags & Element::ALLOW_KEYBOARD_INPUT)) {

+ if (!page()->chrome().client()->supportsFullScreenForElement(element, false))

+ page()->chrome().client()->enterFullScreenForElement(element);

+ page()->chrome().client()->exitFullScreenForElement(m_fullScreenElement.get());

+ page()->chrome().client()->enterFullScreenForElement(newTop);

+ return isAttributeOnAllOwners(allowfullscreenAttr, webkitallowfullscreenAttr, ownerElement());

+ page()->chrome().client()->fullScreenRendererChanged(m_fullScreenRenderer);

+ page()->chrome().client()->fullScreenRendererChanged(0);

+ Deque<RefPtr<Node> > errorQueue;

+ m_fullScreenErrorEventTargetQueue.swap(errorQueue);

+ if (element->isInTopLayer())

+ return;

+ element->setIsInTopLayer(true);

+ if (!element->isInTopLayer())

+ return;

+ element->setIsInTopLayer(false);

+ m_scriptedAnimationController = ScriptedAnimationController::create(this, page() ? page()->chrome().displayID() : 0);

+

+void Document::clearScriptedAnimationController()

+{

+ // FIXME: consider using ActiveDOMObject.

+ if (m_scriptedAnimationController)

+ m_scriptedAnimationController->clearDocumentPointer();

+ m_scriptedAnimationController.clear();

+}

+void Document::didAddTouchEventHandler(Node* handler)

+ if (!m_touchEventTargets.get())

+ m_touchEventTargets = adoptPtr(new TouchEventTargetSet);

+ m_touchEventTargets->add(handler);

+ if (Document* parent = parentDocument()) {

+ parent->didAddTouchEventHandler(this);

+ }

+ if (Page* page = this->page()) {

+#if ENABLE(TOUCH_EVENT_TRACKING)

+ if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())

+ scrollingCoordinator->touchEventTargetRectsDidChange(this);

+#endif

+ if (m_touchEventTargets->size() == 1)

+ page->chrome().client()->needTouchEvents(true);

+ }

+#else

+ UNUSED_PARAM(handler);

+void Document::didRemoveTouchEventHandler(Node* handler)

+ if (!m_touchEventTargets.get())

+ return;

+ ASSERT(m_touchEventTargets->contains(handler));

+ m_touchEventTargets->remove(handler);

+ if (Document* parent = parentDocument()) {

+ parent->didRemoveTouchEventHandler(this);

+ }

+#if ENABLE(TOUCH_EVENT_TRACKING)

+ if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())

+ scrollingCoordinator->touchEventTargetRectsDidChange(this);

+#endif

+ if (m_touchEventTargets->size())

+ return;

+ if (frame->document() && frame->document()->hasTouchEventHandlers())

+ page->chrome().client()->needTouchEvents(false);

+#else

+ UNUSED_PARAM(handler);

+#if ENABLE(TOUCH_EVENTS)

+void Document::didRemoveEventTargetNode(Node* handler)

+{

+ if (m_touchEventTargets) {

+ m_touchEventTargets->removeAll(handler);

+ if ((handler == this || m_touchEventTargets->isEmpty()) && parentDocument())

+ parentDocument()->didRemoveEventTargetNode(this);

+ }

+}

+#endif

+

+void Document::resetLastHandledUserGestureTimestamp()

+{

+ m_lastHandledUserGestureTimestamp = currentTime();

+}

+

+ return toHTMLIFrameElement(ownerElement());

+ if (!RuntimeEnabledFeatures::seamlessIFramesEnabled())

+ return false;

+ return m_mayDisplaySeamlesslyWithParent && ownerElement->hasTagName(iframeTag) && ownerElement->fastHasAttribute(seamlessAttr);

+ return view()->visibleContentRect(ScrollableArea::IncludeScrollbars).size();

+}

+

+#if ENABLE(CSS_DEVICE_ADAPTATION)

+IntSize Document::initialViewportSize() const

+{

+ if (!view())

+ return IntSize();

+ return view()->initialViewportSize();

+#endif

+ Node* node = doc->focusedElement();

+ PluginDocument* pluginDocument = toPluginDocument(doc);

+ node = pluginDocument->pluginElement();

+bool Document::hasActiveParser()

+{

+ return m_activeParserCount || (m_parser && m_parser->processingData());

+}

+

+void Document::decrementActiveParserCount()

+{

+ --m_activeParserCount;

+ if (!frame())

+ return;

+ // FIXME: This should always be enabled, but it seems to cause

+ // http/tests/security/feed-urls-from-remote.html to timeout on Mac WK1

+ // see http://webkit.org/b/110554 and http://webkit.org/b/110401

+#if ENABLE(THREADED_HTML_PARSER)

+ loader()->checkLoadComplete();

+#endif

+ frame()->loader()->checkLoadComplete();

+}

+

+void Document::updateHoverActiveState(const HitTestRequest& request, Element* innerElement, const PlatformMouseEvent* event)

+ ASSERT(!request.readOnly());

+ Element* innerElementInDocument = innerElement;

+ while (innerElementInDocument && innerElementInDocument->document() != this) {

+ innerElementInDocument->document()->updateHoverActiveState(request, innerElementInDocument, event);

+ innerElementInDocument = innerElementInDocument->document()->ownerElement();

+ }

+ Element* oldActiveElement = activeElement();

+ if (oldActiveElement && !request.active()) {

+ for (RenderObject* curr = oldActiveElement->renderer(); curr; curr = curr->parent()) {

+ if (!curr->node() || !curr->node()->isElementNode())

+ continue;

+ Element* element = toElement(curr->node());

+ element->setActive(false);

+ m_userActionElements.setInActiveChain(element, false);

+ setActiveElement(0);

+ Element* newActiveElement = innerElementInDocument;

+ if (!oldActiveElement && newActiveElement && request.active() && !request.touchMove()) {

+ for (RenderObject* curr = newActiveElement->renderer(); curr; curr = curr->parent()) {

+ if (!curr->node() || !curr->node()->isElementNode() || curr->isText())

+ continue;

+ m_userActionElements.setInActiveChain(toElement(curr->node()), true);

+

+ setActiveElement(newActiveElement);

+ bool allowActiveChanges = !oldActiveElement && activeElement();

+ RefPtr<Element> oldHoveredElement = m_hoveredElement.release();

+

+ // A touch release does not set a new hover target; setting the element we're working with to 0

+ // will clear the chain of hovered elements all the way to the top of the tree.

+ if (request.touchRelease())

+ innerElementInDocument = 0;

+ // Check to see if the hovered Element has changed.

+ Element* newHoveredElement = innerElementInDocument;

+ while (newHoveredElement && !newHoveredElement->renderer())

+ newHoveredElement = newHoveredElement->parentOrShadowHostElement();

+ m_hoveredElement = newHoveredElement;

+ RenderObject* oldHoverObj = oldHoveredElement ? oldHoveredElement->renderer() : 0;

+ RenderObject* newHoverObj = newHoveredElement ? newHoveredElement->renderer() : 0;

+ Vector<RefPtr<Element>, 32> elementsToRemoveFromChain;

+ Vector<RefPtr<Element>, 32> elementsToAddToChain;

+

+ // mouseenter and mouseleave events are only dispatched if there is a capturing eventhandler on an ancestor

+ // or a normal eventhandler on the element itself (they don't bubble).

+ // This optimization is necessary since these events can cause O(n²) capturing event-handler checks.

+ bool hasCapturingMouseEnterListener = false;

+ bool hasCapturingMouseLeaveListener = false;

+ if (event && newHoveredElement != oldHoveredElement.get()) {

+ for (Node* curr = newHoveredElement; curr; curr = curr->parentOrShadowHostNode()) {

+ if (curr->hasCapturingEventListeners(eventNames().mouseenterEvent)) {

+ hasCapturingMouseEnterListener = true;

+ break;

+ }

+ }

+ for (Node* curr = oldHoveredElement.get(); curr; curr = curr->parentOrShadowHostNode()) {

+ if (curr->hasCapturingEventListeners(eventNames().mouseleaveEvent)) {

+ hasCapturingMouseLeaveListener = true;

+ break;

+ }

+ }

+ }

+ // If the old hovered element is not nil but it's renderer is, it was probably detached as part of the :hover style

+ // (for instance by setting display:none in the :hover pseudo-class). In this case, the old hovered element (and its ancestors)

+ // must be updated, to ensure it's normal style is re-applied.

+ if (oldHoveredElement && !oldHoverObj) {

+ for (Element* element= oldHoveredElement.get(); element; element = element->parentElement()) {

+ if (!mustBeInActiveChain || element->inActiveChain())

+ elementsToRemoveFromChain.append(element);

+ }

+ }

+

+ if (!curr->node() || !curr->node()->isElementNode())

+ continue;

+ Element* element = toElement(curr->node());

+ if (!mustBeInActiveChain || element->inActiveChain())

+ elementsToRemoveFromChain.append(element);

+ }

+ // Unset hovered nodes in sub frame documents if the old hovered node was a frame owner.

+ if (oldHoveredElement && oldHoveredElement->isFrameOwnerElement()) {

+ if (Document* contentDocument = toFrameOwnerElement(oldHoveredElement.get())->contentDocument())

+ contentDocument->updateHoverActiveState(request, 0, event);

+ if (!curr->node() || !curr->node()->isElementNode())

+ continue;

+ Element* element = toElement(curr->node());

+ if (!mustBeInActiveChain || element->inActiveChain())

+ elementsToAddToChain.append(element);

+ size_t removeCount = elementsToRemoveFromChain.size();

+ for (size_t i = 0; i < removeCount; ++i) {

+ elementsToRemoveFromChain[i]->setHovered(false);

+ if (event && (hasCapturingMouseLeaveListener || elementsToRemoveFromChain[i]->hasEventListeners(eventNames().mouseleaveEvent)))

+ elementsToRemoveFromChain[i]->dispatchMouseEvent(*event, eventNames().mouseleaveEvent, 0, newHoveredElement);

+ bool sawCommonAncestor = false;

+ for (size_t i = 0, size = elementsToAddToChain.size(); i < size; ++i) {

+ if (allowActiveChanges)

+ elementsToAddToChain[i]->setActive(true);

+ if (ancestor && elementsToAddToChain[i] == ancestor->node())

+ sawCommonAncestor = true;

+ if (!sawCommonAncestor) {

+ // Elements after the common hover ancestor does not change hover state, but are iterated over because they may change active state.

+ elementsToAddToChain[i]->setHovered(true);

+ if (event && (hasCapturingMouseEnterListener || elementsToAddToChain[i]->hasEventListeners(eventNames().mouseenterEvent)))

+ elementsToAddToChain[i]->dispatchMouseEvent(*event, eventNames().mouseenterEvent, 0, oldHoveredElement.get());

+ }

+ updateStyleIfNeeded();

+#if ENABLE(TEMPLATE_ELEMENT)

+Document* Document::ensureTemplateDocument()

+{

+ if (const Document* document = templateDocument())

+ return const_cast<Document*>(document);

+

+ if (isHTMLDocument())

+ m_templateDocument = HTMLDocument::create(0, blankURL());

+ else

+ m_templateDocument = Document::create(0, blankURL());

+

+ m_templateDocument->setTemplateDocumentHost(this); // balanced in dtor.

+

+ return m_templateDocument.get();

+}

+#endif

+

+#if ENABLE(FONT_LOAD_EVENTS)

+PassRefPtr<FontLoader> Document::fontloader()

+{

+ if (!m_fontloader)

+ m_fontloader = FontLoader::create(this);

+ return m_fontloader;

+}

+#endif

+

+void Document::didAssociateFormControl(Element* element)

+{

+ if (!frame() || !frame()->page() || !frame()->page()->chrome().client()->shouldNotifyOnFormChanges())

+ return;

+ m_associatedFormControls.add(element);

+ if (!m_didAssociateFormControlsTimer.isActive())

+ m_didAssociateFormControlsTimer.startOneShot(0);

+}

+

+void Document::didAssociateFormControlsTimerFired(Timer<Document>* timer)

+{

+ ASSERT_UNUSED(timer, timer == &m_didAssociateFormControlsTimer);

+ if (!frame() || !frame()->page())

+ return;

+

+ Vector<RefPtr<Element> > associatedFormControls;

+ copyToVector(m_associatedFormControls, associatedFormControls);

+

+ frame()->page()->chrome().client()->didAssociateFormControls(associatedFormControls);

+ m_associatedFormControls.clear();

+}

+

+void Document::ensurePlugInsInjectedScript(DOMWrapperWorld* world)

+{

+ if (m_hasInjectedPlugInsScript)

+ return;

+

+ // Use the JS file provided by the Chrome client, or fallback to the default one.

+ String jsString = page()->chrome().client()->plugInExtraScript();

+ if (!jsString)

+ jsString = plugInsJavaScript;

+

+ page()->mainFrame()->script()->evaluateInWorld(ScriptSourceCode(jsString), world);

+

+ m_hasInjectedPlugInsScript = true;

+}

+