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

+#include "ElementShadow.h"

+#include "FlowThreadController.h"

+#include "PluginDocument.h"

+#include "RenderNamedFlowThread.h"

+#include "StyleResolver.h"

+ // Note: We generalize this to all "blank" URLs and invalid URLs because we

+ return !url.isValid() || url.isBlankURL();

+static bool canAccessAncestor(const SecurityOrigin* activeSecurityOrigin, Frame* targetFrame)

+{

+ // targetFrame can be 0 when we're trying to navigate a top-level frame

+ // that has a 0 opener.

+ if (!targetFrame)

+ return false;

+

+ const bool isLocalActiveOrigin = activeSecurityOrigin->isLocal();

+ for (Frame* ancestorFrame = targetFrame; ancestorFrame; ancestorFrame = ancestorFrame->tree()->parent()) {

+ Document* ancestorDocument = ancestorFrame->document();

+ // FIXME: Should be an ASSERT? Frames should alway have documents.

+ if (!ancestorDocument)

+ return true;

+

+ const SecurityOrigin* ancestorSecurityOrigin = ancestorDocument->securityOrigin();

+ if (activeSecurityOrigin->canAccess(ancestorSecurityOrigin))

+ return true;

+

+ // Allow file URL descendant navigation even when allowFileAccessFromFileURLs is false.

+ // FIXME: It's a bit strange to special-case local origins here. Should we be doing

+ // something more general instead?

+ if (isLocalActiveOrigin && ancestorSecurityOrigin->isLocal())

+ return true;

+ }

+

+ return false;

+}

+

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

+{

+ // FIXME: this error message should contain more specifics of why the navigation change is not allowed.

+ String message = "Unsafe JavaScript attempt to initiate a navigation change for frame with URL " +

+ frame->document()->url().string() + " from frame with URL " + activeURL.string() + ".\n";

+

+ // FIXME: should we print to the console of the document performing the navigation instead?

+ frame->domWindow()->printErrorMessage(message);

+}

+

+ , m_xmlStandalone(StandaloneUnspecified)

+ , m_hasXMLDeclaration(0)

+ , m_isSrcdocDocument(false)

+ , m_referrerPolicy(ReferrerPolicyDefault)

+ , m_scheduledTasksAreSuspended(false)

+ , m_visualUpdatesAllowed(true)

+ , m_visualUpdatesSuppressionTimer(this, &Document::visualUpdatesSuppressionTimerFired)

+#ifndef NDEBUG

+ , m_didDispatchViewportPropertiesChanged(false)

+#endif

+ m_didCalculateStyleResolver = false;

+ m_hasDirtyStyleResolver = false;

+ clearStyleResolver(); // We need to destory CSSFontSelector before destroying m_cachedResourceLoader.

+ m_fullScreenElementStack.clear();

+ for (ShadowRoot* root = element->shadow()->youngestShadowRoot(); root; root = root->olderShadowRoot())

+ clearStyleResolver();

+ clearStyleResolver();

+ return Attr::create(this, QualifiedName(nullAtom, static_cast<Attr*>(importedNode)->name(), nullAtom), static_cast<Attr*>(importedNode)->value());

+ if (source->isShadowRoot()) {

+ // ShadowRoot cannot disconnect itself from the host node.

+ ec = HIERARCHY_REQUEST_ERR;

+ return 0;

+ }

+

+ // FIXME: What about <frame> and <object>?

+bool Document::regionBasedColumnsEnabled() const

+{

+ return settings() && settings()->regionBasedColumnsEnabled();

+}

+

+ return webkitGetFlowByName(flowName, CheckFlowNameForInvalidValues);

+}

+PassRefPtr<WebKitNamedFlow> Document::webkitGetFlowByName(const String& flowName, FlowNameCheck flowNameCheck)

+{

+ if (!cssRegionsEnabled() || !renderer())

+ if (flowNameCheck == CheckFlowNameForInvalidValues) {

+ if (flowName.isEmpty() || !validFlowName(flowName))

+ return 0;

+

+ // Make a slower check for invalid flow name.

+ CSSParser parser(document());

+ if (!parser.parseFlowThread(flowName))

+ return 0;

+ }

+

+ return view->flowThreadController()->ensureRenderFlowThreadWithName(flowName)->ensureNamedFlow();

+

+ if (settings() && settings()->suppressesIncrementalRendering())

+ setVisualUpdatesAllowed(readyState);

+}

+

+void Document::setVisualUpdatesAllowed(ReadyState readyState)

+{

+ ASSERT(settings() && settings()->suppressesIncrementalRendering());

+ switch (readyState) {

+ case Loading:

+ ASSERT(!m_visualUpdatesSuppressionTimer.isActive());

+ ASSERT(m_visualUpdatesAllowed);

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

+ setVisualUpdatesAllowed(false);

+ break;

+ case Interactive:

+ ASSERT(m_visualUpdatesSuppressionTimer.isActive() || m_visualUpdatesAllowed);

+ break;

+ case Complete:

+ if (m_visualUpdatesSuppressionTimer.isActive()) {

+ ASSERT(!m_visualUpdatesAllowed);

+ m_visualUpdatesSuppressionTimer.stop();

+ setVisualUpdatesAllowed(true);

+ } else

+ ASSERT(m_visualUpdatesAllowed);

+ break;

+ }

+}

+

+void Document::setVisualUpdatesAllowed(bool visualUpdatesAllowed)

+{

+ if (m_visualUpdatesAllowed == visualUpdatesAllowed)

+ return;

+

+ m_visualUpdatesAllowed = visualUpdatesAllowed;

+

+ if (!visualUpdatesAllowed)

+ return;

+

+#if USE(ACCELERATED_COMPOSITING)

+ if (view())

+ view()->updateCompositingLayersAfterLayout();

+#endif

+

+ if (renderer())

+ renderer()->repaint();

+}

+

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

+{

+ ASSERT(!m_visualUpdatesAllowed);

+ setVisualUpdatesAllowed(true);

+ styleResolverChanged(DeferRecalcStyle);

+ m_xmlStandalone = standalone ? Standalone : NotStandalone;

+PassRefPtr<NodeList> Document::nodesFromRect(int centerX, int centerY, unsigned topPadding, unsigned rightPadding, unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping, bool allowShadowContent) const

+ enum ShadowContentFilterPolicy shadowContentFilterPolicy = allowShadowContent ? AllowShadowContent : DoNotAllowShadowContent;

+ HitTestResult result(point, topPadding, rightPadding, bottomPadding, leftPadding, shadowContentFilterPolicy);

+ renderView()->hitTest(request, result);

+ renderView()->hitTest(request, result);

+ renderView->hitTest(request, result);

+ if (m_hasDirtyStyleResolver)

+ if (m_elemSheet && m_elemSheet->internal()->usesRemUnits())

+ m_usesRemUnits = true;

+

+ RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(this, m_styleResolver ? m_styleResolver->fontSelector() : 0);

+ StyleChange ch = Node::diff(documentStyle.get(), renderer()->style(), this);

+ view()->updateCompositingLayersAfterStyleChange();

+ if (m_styleResolver)

+ styleResolverChanged(RecalcStyleImmediately);

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

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

+ RenderView* view = renderView();

+ width = valueForLength(size.width(), 0, view);

+ height = valueForLength(size.height(), 0, view);

+ marginTop = style->marginTop().isAuto() ? marginTop : intValueForLength(style->marginTop(), width, view);

+ marginRight = style->marginRight().isAuto() ? marginRight : intValueForLength(style->marginRight(), width, view);

+ marginBottom = style->marginBottom().isAuto() ? marginBottom : intValueForLength(style->marginBottom(), width, view);

+ marginLeft = style->marginLeft().isAuto() ? marginLeft : intValueForLength(style->marginLeft(), width, view);

+ m_usesSiblingRules = m_usesSiblingRules || m_styleResolver->usesSiblingRules();

+ m_usesFirstLineRules = m_usesFirstLineRules || m_styleResolver->usesFirstLineRules();

+ m_usesBeforeAfterRules = m_usesBeforeAfterRules || m_styleResolver->usesBeforeAfterRules();

+ m_usesLinkRules = m_usesLinkRules || m_styleResolver->usesLinkRules();

+ m_usesSiblingRules = m_styleResolver->usesSiblingRules();

+ m_usesFirstLineRules = m_styleResolver->usesFirstLineRules();

+ m_usesBeforeAfterRules = m_styleResolver->usesBeforeAfterRules();

+ m_usesLinkRules = m_styleResolver->usesLinkRules();

+void Document::createStyleResolver()

+ m_styleResolver = adoptPtr(new StyleResolver(this, matchAuthorAndUserStyles));

+

+inline void Document::clearStyleResolver()

+ m_styleResolver.clear();

+ ImageLoader::dispatchPendingErrorEvents();

+ if (!frame()) {

+ m_processingLoadEvent = false;

+ }

+ m_processingLoadEvent = false;

+ m_processingLoadEvent = false;

+ if (m_elemSheet) {

+ // Element sheet is silly. It never contains anything.

+ ASSERT(!m_elemSheet->internal()->ruleCount());

+ bool usesRemUnits = m_elemSheet->internal()->usesRemUnits();

+ m_elemSheet = CSSStyleSheet::createInline(this, m_baseURL);

+ // FIXME: So we are not really the parser. The right fix is to eliminate the element sheet completely.

+ m_elemSheet->internal()->parserSetUsesRemUnits(usesRemUnits);

+ }

+

+bool Document::canNavigate(Frame* targetFrame)

+{

+ if (!m_frame)

+ return false;

+

+ // FIXME: We shouldn't call this function without a target frame, but

+ // fast/forms/submit-to-blank-multiple-times.html depends on this function

+ // returning true when supplied with a 0 targetFrame.

+ if (!targetFrame)

+ return true;

+

+ // Frame-busting is generally allowed (unless we're sandboxed and prevent from frame-busting).

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

+ return true;

+

+ if (isSandboxed(SandboxNavigation)) {

+ if (targetFrame->tree()->isDescendantOf(m_frame))

+ return true;

+

+ printNavigationErrorMessage(targetFrame, url());

+ return false;

+ }

+

+ // This is the normal case. A document can navigate its decendant frames,

+ // or, more generally, a document can navigate a frame if the document is

+ // in the same origin as any of that frame's ancestors (in the frame

+ // hierarchy).

+ //

+ // See http://www.adambarth.com/papers/2008/barth-jackson-mitchell.pdf for

+ // historical information about this security check.

+ if (canAccessAncestor(securityOrigin(), targetFrame))

+ return true;

+

+ // Top-level frames are easier to navigate than other frames because they

+ // display their URLs in the address bar (in most browsers). However, there

+ // are still some restrictions on navigation to avoid nuisance attacks.

+ // Specifically, a document can navigate a top-level frame if that frame

+ // opened the document or if the document is the same-origin with any of

+ // the top-level frame's opener's ancestors (in the frame hierarchy).

+ //

+ // In both of these cases, the document performing the navigation is in

+ // some way related to the frame being navigate (e.g., by the "opener"

+ // and/or "parent" relation). Requiring some sort of relation prevents a

+ // document from navigating arbitrary, unrelated top-level frames.

+ if (!targetFrame->tree()->parent()) {

+ if (targetFrame == m_frame->loader()->opener())

+ return true;

+

+ if (canAccessAncestor(securityOrigin(), targetFrame->loader()->opener()))

+ return true;

+ }

+

+ printNavigationErrorMessage(targetFrame, url());

+ return false;

+}

+

+Frame* Document::findUnsafeParentScrollPropagationBoundary()

+{

+ Frame* currentFrame = m_frame;

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

+

+ while (ancestorFrame) {

+ if (!ancestorFrame->document()->securityOrigin()->canAccess(securityOrigin()))

+ return currentFrame;

+ currentFrame = ancestorFrame;

+ ancestorFrame = ancestorFrame->tree()->parent();

+ }

+ return 0;

+}

+

+ m_pageUserSheet->internal()->setIsUserStyleSheet(true);

+ m_pageUserSheet->internal()->parseString(userSheetText);

+ styleResolverChanged(DeferRecalcStyle);

+ styleResolverChanged(RecalcStyleImmediately);

+ RefPtr<CSSStyleSheet> groupSheet = CSSStyleSheet::createInline(const_cast<Document*>(this), sheet->url());

+ m_pageGroupUserSheets->append(groupSheet);

+ groupSheet->internal()->setIsUserStyleSheet(sheet->level() == UserStyleUserLevel);

+ groupSheet->internal()->parseString(sheet->source());

+ styleResolverChanged(DeferRecalcStyle);

+ styleResolverChanged(RecalcStyleImmediately);

+void Document::addUserSheet(PassRefPtr<StyleSheetInternal> userSheet)

+ m_userSheets->append(CSSStyleSheet::create(userSheet, this));

+ styleResolverChanged(RecalcStyleImmediately);

+ styleResolverChanged(DeferRecalcStyle);

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

+#ifndef NDEBUG

+ m_didDispatchViewportPropertiesChanged = true;

+#endif

+ }

+ m_referrerPolicy = ReferrerPolicyDefault;

+ m_referrerPolicy = ReferrerPolicyNever;

+ m_referrerPolicy = ReferrerPolicyAlways;

+ m_referrerPolicy = ReferrerPolicyOrigin;

+ renderView()->hitTest(request, result);

+ styleResolverChanged(DeferRecalcStyle);

+ styleResolverChanged(RecalcStyleIfNeeded);

+void Document::evaluateMediaQueryList()

+{

+ if (m_mediaQueryMatcher)

+ m_mediaQueryMatcher->styleResolverChanged();

+}

+

+void Document::styleResolverChanged(StyleResolverUpdateFlag updateFlag)

+ if (!attached() || (!m_didCalculateStyleResolver && !haveStylesheetsLoaded())) {

+ m_styleResolver.clear();

+ evaluateMediaQueryList();

+

+ AtomicString rel = e->getAttribute(relAttr);

+

+ if (rel.contains("alternate") && title.isEmpty())

+ sheet = 0;

+bool Document::testAddedStylesheetRequiresStyleRecalc(StyleSheetInternal* stylesheet)

+ if (!StyleResolver::determineStylesheetSelectorScopes(stylesheet, idScopes, classScopes))

+ // Invalidate the subtrees that match the scopes.

+ Node* node = firstChild();

+ while (node) {

+ if (!node->isStyledElement()) {

+ node = node->traverseNextNode();

+ }

+ StyledElement* element = static_cast<StyledElement*>(node);

+ if (SelectorChecker::elementMatchesSelectorScopes(element, idScopes, classScopes)) {

+ element->setNeedsStyleRecalc();

+ // The whole subtree is now invalidated, we can skip to the next sibling.

+ node = node->traverseNextSibling();

+ continue;

+ }

+ node = node->traverseNextNode();

+

+void Document::analyzeStylesheetChange(StyleResolverUpdateFlag updateFlag, const Vector<RefPtr<StyleSheet> >& newStylesheets, bool& requiresStyleResolverReset, bool& requiresFullStyleRecalc)

+ requiresStyleResolverReset = true;

+ if (!m_styleResolver)

+ requiresStyleResolverReset = false;

+ if (newStylesheets[i]->disabled())

+ continue;

+ if (testAddedStylesheetRequiresStyleRecalc(static_cast<CSSStyleSheet*>(newStylesheets[i].get())->internal()))

+static bool styleSheetsUseRemUnits(const Vector<RefPtr<StyleSheet> >& sheets)

+{

+ for (unsigned i = 0; i < sheets.size(); ++i) {

+ if (!sheets[i]->isCSSStyleSheet())

+ continue;

+ if (static_cast<CSSStyleSheet*>(sheets[i].get())->internal()->usesRemUnits())

+ return true;

+ }

+ return false;

+}

+

+bool Document::updateActiveStylesheets(StyleResolverUpdateFlag updateFlag)

+ m_hasDirtyStyleResolver = true;

+ bool requiresStyleResolverReset;

+ analyzeStylesheetChange(updateFlag, newStylesheets, requiresStyleResolverReset, requiresFullStyleRecalc);

+ if (requiresStyleResolverReset)

+ clearStyleResolver();

+ m_styleResolver->appendAuthorStylesheets(m_styleSheets->length(), newStylesheets);

+ m_usesRemUnits = styleSheetsUseRemUnits(m_styleSheets->vector());

+ m_didCalculateStyleResolver = true;

+ m_hasDirtyStyleResolver = false;

+ else if (eventType == eventNames().webkitRegionLayoutUpdateEvent)

+ addListenerType(REGIONLAYOUTUPDATE_LISTENER);

+

+#ifndef NDEBUG

+ // Clear the update flag to be able to check if the viewport arguments update

+ // is dispatched, after the document is restored from the page cache.

+ m_didDispatchViewportPropertiesChanged = false;

+#endif

+ return Attr::create(this, qName, emptyString());

+ OwnPtr<HTMLNameCollection>& collection = m_windowNamedItemCollections.add(name.impl(), nullptr).iterator->second;

+ OwnPtr<HTMLNameCollection>& collection = m_documentNamedItemCollections.add(name.impl(), nullptr).iterator->second;

+static bool isEligibleForSeamless(Document* parent, Document* child)

+{

+ // It should not matter what we return for the top-most document.

+ if (!parent)

+ return false;

+ if (parent->isSandboxed(SandboxSeamlessIframes))

+ return false;

+ if (child->isSrcdocDocument())

+ return true;

+ if (parent->securityOrigin()->canAccess(child->securityOrigin()))

+ return true;

+ return parent->securityOrigin()->canRequest(child->url());

+}

+

+ // Web security is turned off. We should let this document access every

+ // other document. This is used primary by testing harnesses for web

+ // sites.

+ securityOrigin()->grantUniversalAccess();

+ // Some clients want file:// URLs to have universal access, but that

+ // setting is dangerous for other clients.

+ securityOrigin()->grantUniversalAccess();

+ // Some clients want file:// URLs to have even tighter restrictions by

+ // default, and not be able to access other local files.

+ // FIXME 81578: The naming of this is confusing. Files with restricted access to other local files

+ // still can have other privileges that can be remembered, thereby not making them unique origins.

+ securityOrigin()->enforceFilePathSeparation();

+ Document* parentDocument = ownerElement() ? ownerElement()->document() : 0;

+ if (parentDocument && m_frame->loader()->shouldTreatURLAsSrcdocDocument(url())) {

+ m_isSrcdocDocument = true;

+ setBaseURLOverride(parentDocument->baseURL());

+ }

+

+ // FIXME: What happens if we inherit the security origin? This check may need to be later.

+ // <iframe seamless src="about:blank"> likely won't work as-is.

+ m_mayDisplaySeamlessWithParent = isEligibleForSeamless(parentDocument, this);

+

+ if (isSandboxed(SandboxOrigin)) {

+ // If we're supposed to inherit our security origin from our owner,

+ // but we're also sandboxed, the only thing we inherit is the ability

+ // to load local resources. This lets about:blank iframes in file://

+ // URL documents load images and other resources from the file system.

+ if (ownerFrame->document()->securityOrigin()->canLoadLocalResources())

+ securityOrigin()->grantLoadLocalResources();

+ return;

+ }

+

+}

+

+void Document::initContentSecurityPolicy()

+{

+ if (!m_frame->tree()->parent() || !shouldInheritSecurityOriginFromOwner(m_url))

+ return;

+ contentSecurityPolicy()->copyStateFrom(m_frame->tree()->parent()->document()->contentSecurityPolicy());

+ RefPtr<HTMLCanvasElement>& element = m_cssCanvasElements.add(name, 0).iterator->second;

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

+ ASSERT(!m_scheduledTasksAreSuspended);

+

+ suspendActiveDOMObjects(reason);

+

+ m_scheduledTasksAreSuspended = true;

+ ASSERT(m_scheduledTasksAreSuspended);

+

+

+ m_scheduledTasksAreSuspended = false;

+ // The Mozilla Full Screen API <https://wiki.mozilla.org/Gecko:FullScreenAPI> has different requirements

+ // for full screen mode, and do not have the concept of a full screen element stack.

+ bool inLegacyMozillaMode = (flags & Element::LEGACY_MOZILLA_REQUEST);

+ do {

+

+ // 1. If any of the following conditions are true, terminate these steps and queue a task to fire

+ // an event named fullscreenerror with its bubbles attribute set to true on the context object's

+ // node document:

+

+ // The context object is not in a document.

+ if (!element->inDocument())

+ break;

+

+ // The context object's node document, or an ancestor browsing context's document does not have

+ // the fullscreen enabled flag set.

+

+ // The context object's node document fullscreen element stack is not empty and its top element

+ // is not an ancestor of the context object. (NOTE: Ignore this requirement if the request was

+ // made via the legacy Mozilla-style API.)

+ if (!m_fullScreenElementStack.isEmpty() && !m_fullScreenElementStack.first()->contains(element) && !inLegacyMozillaMode)

+ break;

+

+ // A descendant browsing context's document has a non-empty fullscreen element stack.

+ bool descendentHasNonEmptyStack = false;

+ for (Frame* descendant = frame() ? frame()->tree()->traverseNext() : 0; descendant; descendant = descendant->tree()->traverseNext()) {

+ if (descendant->document()->webkitFullscreenElement()) {

+ descendentHasNonEmptyStack = true;

+ break;

+ }

+ }

+ if (descendentHasNonEmptyStack && !inLegacyMozillaMode)

+ break;

+

+ // This algorithm is not allowed to show a pop-up:

+ // An algorithm is allowed to show a pop-up if, in the task in which the algorithm is running, either:

+ // - an activation behavior is currently being processed whose click event was trusted, or

+ // - the event listener for a trusted click event is being handled.

+

+ // There is a previously-established user preference, security risk, or platform limitation.

+ if (!page() || !page()->settings()->fullScreenEnabled())

+ break;

+

+ // 2. Let doc be element's node document. (i.e. "this")

+ Document* currentDoc = this;

+

+ // 3. Let docs be all doc's ancestor browsing context's documents (if any) and doc.

+ Deque<Document*> docs;

+

+ do {

+ docs.prepend(currentDoc);

+ currentDoc = currentDoc->ownerElement() ? currentDoc->ownerElement()->document() : 0;

+ } while (currentDoc);

+

+ // 4. For each document in docs, run these substeps:

+ Deque<Document*>::iterator current = docs.begin(), following = docs.begin();

+

+ do {

+ ++following;

+

+ // 1. Let following document be the document after document in docs, or null if there is no

+ // such document.

+ Document* currentDoc = *current;

+ Document* followingDoc = following != docs.end() ? *following : 0;

+

+ // 2. If following document is null, push context object on document's fullscreen element

+ // stack, and queue a task to fire an event named fullscreenchange with its bubbles attribute

+ // set to true on the document.

+ if (!followingDoc) {

+ currentDoc->pushFullscreenElementStack(element);

+ addDocumentToFullScreenChangeEventQueue(currentDoc);

+ continue;

+ }

+

+ // 3. Otherwise, if document's fullscreen element stack is either empty or its top element

+ // is not following document's browsing context container,

+ Element* topElement = currentDoc->webkitFullscreenElement();

+ if (!topElement || topElement != followingDoc->ownerElement()) {

+ // ...push following document's browsing context container on document's fullscreen element

+ // stack, and queue a task to fire an event named fullscreenchange with its bubbles attribute

+ // set to true on document.

+ currentDoc->pushFullscreenElementStack(followingDoc->ownerElement());

+ addDocumentToFullScreenChangeEventQueue(currentDoc);

+ continue;

+ }

+

+ // 4. Otherwise, do nothing for this document. It stays the same.

+ } while (++current != docs.end());

+

+ // 5. Return, and run the remaining steps asynchronously.

+ // 6. Optionally, perform some animation.

+

+ // 7. Optionally, display a message indicating how the user can exit displaying the context object fullscreen.

+

+ // The Mozilla "cancelFullScreen()" API behaves like the W3C "fully exit fullscreen" behavior, which

+ // is defined as:

+ // "To fully exit fullscreen act as if the exitFullscreen() method was invoked on the top-level browsing

+ // context's document and subsequently empty that document's fullscreen element stack."

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

+

+ // To achieve that aim, remove all the elements from the top document's stack except for the first before

+ // calling webkitExitFullscreen():

+ Deque<RefPtr<Element> > replacementFullscreenElementStack;

+ replacementFullscreenElementStack.prepend(topDocument()->webkitFullscreenElement());

+ topDocument()->m_fullScreenElementStack.swap(replacementFullscreenElementStack);

+

+ topDocument()->webkitExitFullscreen();

+}

+

+void Document::webkitExitFullscreen()

+{

+ // The exitFullscreen() method must run these steps:

+ // 1. Let doc be the context object. (i.e. "this")

+ Document* currentDoc = this;

+

+ // 2. If doc's fullscreen element stack is empty, terminate these steps.

+ if (m_fullScreenElementStack.isEmpty())

+ return;

+

+ // 3. Let descendants be all the doc's descendant browsing context's documents with a non-empty fullscreen

+ // element stack (if any), ordered so that the child of the doc is last and the document furthest

+ // away from the doc is first.

+ Deque<RefPtr<Document> > descendants;

+ for (Frame* descendant = frame() ? frame()->tree()->traverseNext() : 0; descendant; descendant = descendant->tree()->traverseNext()) {

+ if (descendant->document()->webkitFullscreenElement())

+ descendants.prepend(descendant->document());

+ }

+

+ // 4. For each descendant in descendants, empty descendant's fullscreen element stack, and queue a

+ // task to fire an event named fullscreenchange with its bubbles attribute set to true on descendant.

+ for (Deque<RefPtr<Document> >::iterator i = descendants.begin(); i != descendants.end(); ++i) {

+ (*i)->clearFullscreenElementStack();

+ addDocumentToFullScreenChangeEventQueue(i->get());

+ }

+

+ // 5. While doc is not null, run these substeps:

+ Element* newTop = 0;

+ while (currentDoc) {

+ // 1. Pop the top element of doc's fullscreen element stack.

+ currentDoc->popFullscreenElementStack();

+

+ // If doc's fullscreen element stack is non-empty and the element now at the top is either

+ // not in a document or its node document is not doc, repeat this substep.

+ newTop = currentDoc->webkitFullscreenElement();

+ if (newTop && (!newTop->inDocument() || newTop->document() != currentDoc))

+ continue;

+

+ // 2. Queue a task to fire an event named fullscreenchange with its bubbles attribute set to true

+ // on doc.

+ Node* target = currentDoc->m_fullScreenElement.get();

+ if (!target)

+ target = currentDoc;

+ addDocumentToFullScreenChangeEventQueue(currentDoc);

+

+ // 3. If doc's fullscreen element stack is empty and doc's browsing context has a browsing context

+ // container, set doc to that browsing context container's node document.

+ if (!newTop && currentDoc->ownerElement())

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

+

+ // 4. Otherwise, set doc to null.

+ currentDoc = 0;

+ }

+

+ // 6. Return, and run the remaining steps asynchronously.

+ // 7. Optionally, perform some animation.

+

+ // Only exit out of full screen window mode if there are no remaining elements in the

+ // full screen stack.

+ if (!newTop) {

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

+ return;

+ }

+

+ // Otherwise, notify the chrome of the new full screen element.

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

+}

+

+bool Document::webkitFullscreenEnabled() const

+{

+ // 4. The fullscreenEnabled attribute must return true if the context object and all ancestor

+ // browsing context's documents have their fullscreen enabled flag set, or false otherwise.

+

+ // Top-level browsing contexts are implied to have their allowFullScreen attribute set.

+ HTMLFrameOwnerElement* owner = ownerElement();

+ if (!owner)

+ return true;

+

+ do {

+ if (!owner->isFrameElementBase())

+ continue;

+

+ if (!static_cast<HTMLFrameElementBase*>(owner)->allowFullScreen())

+ return false;

+ } while ((owner = owner->document()->ownerElement()));

+

+ return true;

+ if (!attached() || inPageCache())

+ return;

+

+

+ // Protect against being called after the document has been removed from the page.

+ if (!page())

+ return;

+

+ ASSERT(page()->settings()->fullScreenEnabled());

+#if USE(NATIVE_FULLSCREEN_VIDEO)

+ if (element && element->isMediaElement())

+ return;

+#endif

+

+

+ if (!m_fullScreenElement)

+ return;

+

+ if (!attached() || inPageCache())

+ return;

+

+ if (!m_fullScreenElement)

+ return;

+

+ if (!attached() || inPageCache())

+ return;

+

+ if (!m_fullScreenElement)

+ return;

+

+ if (!attached() || inPageCache())

+ return;

+

+ m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);

+

+ m_fullScreenElement = 0;

+ Deque<RefPtr<Node> > changeQueue;

+ m_fullScreenChangeEventTargetQueue.swap(changeQueue);

+

+ while (!changeQueue.isEmpty()) {

+ RefPtr<Node> node = changeQueue.takeFirst();

+ if (!node)

+ node = documentElement();

+ if (!contains(node.get()))

+ changeQueue.append(documentElement());

+ node->dispatchEvent(Event::create(eventNames().webkitfullscreenchangeEvent, true, false));

+ Deque<RefPtr<Node> > errorQueue;

+ m_fullScreenErrorEventTargetQueue.swap(errorQueue);

+

+ while (!errorQueue.isEmpty()) {

+ RefPtr<Node> node = errorQueue.takeFirst();

+ if (!node)

+ node = documentElement();

+ // If the node was removed from our tree, also message the documentElement.

+ if (!contains(node.get()))

+ errorQueue.append(documentElement());

+ node->dispatchEvent(Event::create(eventNames().webkitfullscreenerrorEvent, true, false));

+

+void Document::clearFullscreenElementStack()

+{

+ m_fullScreenElementStack.clear();

+}

+

+void Document::popFullscreenElementStack()

+{

+ if (m_fullScreenElementStack.isEmpty())

+ return;

+

+ m_fullScreenElementStack.removeFirst();

+}

+

+void Document::pushFullscreenElementStack(Element* element)

+{

+ m_fullScreenElementStack.prepend(element);

+}

+

+void Document::addDocumentToFullScreenChangeEventQueue(Document* doc)

+{

+ ASSERT(doc);

+ Node* target = doc->webkitFullscreenElement();

+ if (!target)

+ target = doc->webkitCurrentFullScreenElement();

+ if (!target)

+ target = doc;

+ m_fullScreenChangeEventTargetQueue.append(target);

+}

+int Document::webkitRequestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback> callback)

+ if (!m_scriptedAnimationController) {

+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)

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

+#else

+ m_scriptedAnimationController = ScriptedAnimationController::create(this, 0);

+#endif

+ // It's possible that the Page may have suspended scripted animations before

+ // we were created. We need to make sure that we don't start up the animation

+ // controller on a background tab, for example.

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

+ m_scriptedAnimationController->suspend();

+ }

+ return m_scriptedAnimationController->registerCallback(callback);

+void Document::serviceScriptedAnimations(double monotonicAnimationStartTime)

+ m_scriptedAnimationController->serviceScriptedAnimations(monotonicAnimationStartTime);

+HTMLIFrameElement* Document::seamlessParentIFrame() const

+{

+ if (!shouldDisplaySeamlesslyWithParent())

+ return 0;

+

+ HTMLFrameOwnerElement* ownerElement = this->ownerElement();

+ ASSERT(ownerElement->hasTagName(iframeTag));

+ return static_cast<HTMLIFrameElement*>(ownerElement);

+}

+

+bool Document::shouldDisplaySeamlesslyWithParent() const

+ HTMLFrameOwnerElement* ownerElement = this->ownerElement();

+ if (!ownerElement)

+ return false;

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

+ NodeListsNodeData::MicroDataItemListCache::AddResult result = nodeLists->m_microDataItemListCache.add(localTypeNames, 0);

+ if (!result.isNewEntry)

+ return PassRefPtr<NodeList>(result.iterator->second);

+ result.iterator->second = list.get();

+IntSize Document::viewportSize() const

+{

+ if (!view())

+ return IntSize();

+ return view()->visibleContentRect(/* includeScrollbars */ true).size();

+}

+

+Node* eventTargetNodeForDocument(Document* doc)

+{

+ if (!doc)

+ return 0;

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

+ if (!node && doc->isPluginDocument()) {

+ PluginDocument* pluginDocument = static_cast<PluginDocument*>(doc);

+ node = pluginDocument->pluginNode();

+ }

+ if (!node && doc->isHTMLDocument())

+ node = doc->body();

+ if (!node)

+ node = doc->documentElement();

+ return node;

+}

+