Element should check inActiveDocument before forcing layout.

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 426 matching lines @@
     return nullAtom;
 }
 
 bool Element::shouldIgnoreAttributeCase() const
 {
     return isHTMLElement() && document().isHTMLDocument();
 }
 
 void Element::scrollIntoView(bool alignToTop)
 {
+    if (!inActiveDocument())
+        return;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (!layoutObject())
         return;
 
     LayoutRect bounds = boundingBox();
     // Align to the top / bottom and to the closest edge.
     if (alignToTop)
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
     else
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
 }
 
 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
 {
+    if (!inActiveDocument())
+        return;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (!layoutObject())
         return;
 
     LayoutRect bounds = boundingBox();
     if (centerIfNeeded)
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
     else
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
@@ skipping 99 matching lines @@
 static double adjustForLocalZoom(LayoutUnit value, LayoutObject& layoutObject)
 {
     float zoomFactor = localZoomForLayoutObject(layoutObject);
     if (zoomFactor == 1)
         return value.toDouble();
     return value.toDouble() / zoomFactor;
 }
 
 int Element::offsetLeft()
 {
+    if (inActiveDocument())
+        return 0;
     document().updateLayoutIgnorePendingStylesheets();
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return lroundf(adjustForLocalZoom(layoutObject->offsetLeft(), *layoutObject));
     return 0;
 }
 
 int Element::offsetTop()
 {
+    if (inActiveDocument())
+        return 0;
     document().updateLayoutIgnorePendingStylesheets();
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return lroundf(adjustForLocalZoom(layoutObject->pixelSnappedOffsetTop(), *layoutObject));
     return 0;
 }
 
 int Element::offsetWidth()
 {
+    if (inActiveDocument())
+        return 0;
     document().updateLayoutIgnorePendingStylesheets();
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(layoutObject->pixelSnappedOffsetWidth(), *layoutObject).round();
     return 0;
 }
 
 int Element::offsetHeight()
 {
+    if (inActiveDocument())
+        return 0;
     document().updateLayoutIgnorePendingStylesheets();
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(layoutObject->pixelSnappedOffsetHeight(), *layoutObject).round();
     return 0;
 }
 
 Element* Element::offsetParent()
 {
+    if (inActiveDocument())
+        return nullptr;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     LayoutObject* layoutObject = this->layoutObject();
     if (!layoutObject)
         return nullptr;
 
     Element* element = layoutObject->offsetParent();
     if (!element)
         return nullptr;
 
     if (element->isInShadowTree() && !element->containingShadowRoot()->isOpen())
         return nullptr;
 
     return element;
 }
 
 int Element::clientLeft()
 {
+    if (inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(roundToInt(layoutObject->clientLeft()), *layoutObject);
     return 0;
 }
 
 int Element::clientTop()
 {
+    if (inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(roundToInt(layoutObject->clientTop()), *layoutObject);
     return 0;
 }
 
 int Element::clientWidth()
 {
+    if (inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     // When in strict mode, clientWidth for the document element should return the width of the containing frame.
     // When in quirks mode, clientWidth for the body element should return the width of the containing frame.
     bool inQuirksMode = document().inQuirksMode();
     if ((!inQuirksMode && document().documentElement() == this)
         || (inQuirksMode && isHTMLElement() && document().body() == this)) {
         if (FrameView* view = document().view()) {
             if (LayoutView* layoutView = document().layoutView()) {
                 if (document().page()->settings().forceZeroLayoutHeight())
                     return adjustLayoutUnitForAbsoluteZoom(view->visibleContentSize().width(), *layoutView);
                 return adjustLayoutUnitForAbsoluteZoom(view->layoutSize().width(), *layoutView);
             }
         }
     }
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(layoutObject->pixelSnappedClientWidth(), *layoutObject).round();
     return 0;
 }
 
 int Element::clientHeight()
 {
+    if (inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     // When in strict mode, clientHeight for the document element should return the height of the containing frame.
     // When in quirks mode, clientHeight for the body element should return the height of the containing frame.
     bool inQuirksMode = document().inQuirksMode();
 
     if ((!inQuirksMode && document().documentElement() == this)
         || (inQuirksMode && isHTMLElement() && document().body() == this)) {
         if (FrameView* view = document().view()) {
             if (LayoutView* layoutView = document().layoutView()) {
                 if (document().page()->settings().forceZeroLayoutHeight())
                     return adjustLayoutUnitForAbsoluteZoom(view->visibleContentSize().height(), *layoutView);
                 return adjustLayoutUnitForAbsoluteZoom(view->layoutSize().height(), *layoutView);
             }
         }
     }
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(layoutObject->pixelSnappedClientHeight(), *layoutObject).round();
     return 0;
 }
 
 double Element::scrollLeft()
 {
+    if (inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (document().scrollingElement() == this) {
         if (document().domWindow())
             return document().domWindow()->scrollX();
         return 0;
     }
 
     if (LayoutBox* box = layoutBox())
         return adjustScrollForAbsoluteZoom(box->scrollLeft(), *box);
 
     return 0;
 }
 
 double Element::scrollTop()
 {
+    if (inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (document().scrollingElement() == this) {
         if (document().domWindow())
             return document().domWindow()->scrollY();
         return 0;
     }
 
     if (LayoutBox* box = layoutBox())
         return adjustScrollForAbsoluteZoom(box->scrollTop(), *box);
 
     return 0;
 }
 
 void Element::setScrollLeft(double newLeft)
 {
+    if (!inActiveDocument())
+        return;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     newLeft = ScrollableArea::normalizeNonFiniteScroll(newLeft);
 
     if (document().scrollingElement() == this) {
         if (LocalDOMWindow* window = document().domWindow())
             window->scrollTo(newLeft, window->scrollY());
     } else {
         LayoutBox* box = layoutBox();
         if (box)
             box->setScrollLeft(LayoutUnit::fromFloatRound(newLeft * box->style()->effectiveZoom()));
     }
 }
 
 void Element::setScrollTop(double newTop)
 {
+    if (!inActiveDocument())
+        return;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     newTop = ScrollableArea::normalizeNonFiniteScroll(newTop);
 
     if (document().scrollingElement() == this) {
         if (LocalDOMWindow* window = document().domWindow())
             window->scrollTo(window->scrollX(), newTop);
     } else {
         LayoutBox* box = layoutBox();
         if (box)
             box->setScrollTop(LayoutUnit::fromFloatRound(newTop * box->style()->effectiveZoom()));
     }
 }
 
 int Element::scrollWidth()
 {
+    if (!inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (document().scrollingElement() == this) {
         if (document().view())
             return adjustForAbsoluteZoom(document().view()->contentsWidth(), document().frame()->pageZoomFactor());
         return 0;
     }
 
     if (LayoutBox* box = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(box->scrollWidth(), *box).round();
     return 0;
 }
 
 int Element::scrollHeight()
 {
+    if (!inActiveDocument())
+        return 0;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (document().scrollingElement() == this) {
         if (document().view())
             return adjustForAbsoluteZoom(document().view()->contentsHeight(), document().frame()->pageZoomFactor());
         return 0;
     }
 
     if (LayoutBox* box = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(box->scrollHeight(), *box).round();
     return 0;
 }
 
 void Element::scrollBy(double x, double y)
 {
     ScrollToOptions scrollToOptions;
     scrollToOptions.setLeft(x);
     scrollToOptions.setTop(y);
     scrollBy(scrollToOptions);
 }
 
 void Element::scrollBy(const ScrollToOptions& scrollToOptions)
 {
+    if (!inActiveDocument())
+        return;
+
     // FIXME: This should be removed once scroll updates are processed only after
     // the compositing update. See http://crbug.com/420741.
     document().updateLayoutIgnorePendingStylesheets();
 
     if (document().scrollingElement() == this) {
         scrollFrameBy(scrollToOptions);
     } else {
         scrollLayoutBoxBy(scrollToOptions);
     }
 }
 
 void Element::scrollTo(double x, double y)
 {
     ScrollToOptions scrollToOptions;
     scrollToOptions.setLeft(x);
     scrollToOptions.setTop(y);
     scrollTo(scrollToOptions);
 }
 
 void Element::scrollTo(const ScrollToOptions& scrollToOptions)
 {
+    if (!inActiveDocument())
+        return;
+
     // FIXME: This should be removed once scroll updates are processed only after
     // the compositing update. See http://crbug.com/420741.
     document().updateLayoutIgnorePendingStylesheets();
 
     if (document().scrollingElement() == this) {
         scrollFrameTo(scrollToOptions);
     } else {
         scrollLayoutBoxTo(scrollToOptions);
     }
 }
@@ skipping 78 matching lines @@
 }
 
 void Element::decrementProxyCount()
 {
     if (ensureElementRareData().decrementProxyCount() == 0)
         setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::CompositorProxy));
 }
 
 bool Element::hasNonEmptyLayoutSize() const
 {
+    if (!inActiveDocument())
+        return false;
+
     document().updateLayoutIgnorePendingStylesheets();
 
     if (LayoutBoxModelObject* box = layoutBoxModelObject())
         return box->hasNonEmptyLayoutSize();
     return false;
 }
 
 IntRect Element::boundsInViewportSpace()
 {
+    if (!inActiveDocument())
+        return IntRect();
+
     document().updateLayoutIgnorePendingStylesheets();
 
     FrameView* view = document().view();
     if (!view)
         return IntRect();
 
     Vector<FloatQuad> quads;
     if (isSVGElement() && layoutObject()) {
         // Get the bounding rectangle from the SVG model.
         SVGElement* svgElement = toSVGElement(this);
@@ skipping 11 matching lines @@
 
     IntRect result = quads[0].enclosingBoundingBox();
     for (size_t i = 1; i < quads.size(); ++i)
         result.unite(quads[i].enclosingBoundingBox());
 
     return view->soonToBeRemovedContentsToUnscaledViewport(result);
 }
 
 ClientRectList* Element::getClientRects()
 {
+    if (!inActiveDocument())
+        return ClientRectList::create();
+
     document().updateLayoutIgnorePendingStylesheets();
 
     LayoutObject* elementLayoutObject = layoutObject();
     if (!elementLayoutObject || (!elementLayoutObject->isBoxModelObject() && !elementLayoutObject->isBR()))
         return ClientRectList::create();
 
     // FIXME: Handle SVG elements.
     // FIXME: Handle table/inline-table with a caption.
 
     Vector<FloatQuad> quads;
     elementLayoutObject->absoluteQuads(quads);
     document().adjustFloatQuadsForScrollAndAbsoluteZoom(quads, *elementLayoutObject);
     return ClientRectList::create(quads);
 }
 
 ClientRect* Element::getBoundingClientRect()
 {
+    if (!inActiveDocument())
+        return ClientRect::create();
+
     document().updateLayoutIgnorePendingStylesheets();
 
     Vector<FloatQuad> quads;
     LayoutObject* elementLayoutObject = layoutObject();
     if (elementLayoutObject) {
         if (isSVGElement() && !elementLayoutObject->isSVGRoot()) {
             // Get the bounding rectangle from the SVG model.
             SVGElement* svgElement = toSVGElement(this);
             FloatRect localRect;
             if (svgElement->getBoundingBox(localRect))
@@ skipping 18 matching lines @@
 IntRect Element::screenRect() const
 {
     if (!layoutObject())
         return IntRect();
     // FIXME: this should probably respect transforms
     return document().view()->contentsToScreen(layoutObject()->absoluteBoundingBoxRectIgnoringTransforms());
 }
 
 const AtomicString& Element::computedRole()
 {
-    document().updateLayoutIgnorePendingStylesheets();
+    if (inActiveDocument())
+        document().updateLayoutIgnorePendingStylesheets();
     OwnPtr<ScopedAXObjectCache> cache = ScopedAXObjectCache::create(document());
     return cache->get()->computedRoleForNode(this);
 }
 
 String Element::computedName()
 {
-    document().updateLayoutIgnorePendingStylesheets();
+    if (inActiveDocument())
+        document().updateLayoutIgnorePendingStylesheets();
     OwnPtr<ScopedAXObjectCache> cache = ScopedAXObjectCache::create(document());
     return cache->get()->computedNameForNode(this);
 }
 
 const AtomicString& Element::getAttribute(const AtomicString& localName) const
 {
     if (!elementData())
         return nullAtom;
     synchronizeAttribute(localName);
     if (const Attribute* attribute = elementData()->attributes().find(localName, shouldIgnoreAttributeCase()))
@@ skipping 1233 matching lines @@
 {
     if (!elementData())
         return false;
     QualifiedName qName(nullAtom, localName, namespaceURI);
     synchronizeAttribute(qName);
     return elementData()->attributes().find(qName);
 }
 
 void Element::focus(bool restorePreviousSelection, WebFocusType type, InputDeviceCapabilities* sourceCapabilities)
 {
-    if (!inDocument())
+    if (!inActiveDocument())
         return;
 
     if (document().focusedElement() == this)
         return;
 
-    if (!document().isActive())
-        return;
-
     document().updateLayoutIgnorePendingStylesheets();
     if (!isFocusable())
         return;
 
     if (authorShadowRoot() && authorShadowRoot()->delegatesFocus()) {
         if (containsIncludingShadowDOM(document().focusedElement()))
             return;
 
         // Slide the focus to its inner node.
         Element* next = document().page()->focusController().findFocusableElement(WebFocusTypeForward, *this);
@@ skipping 258 matching lines @@
 
     RefPtrWillBeRawPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, contextElement.get(), AllowScriptingContent, "insertAdjacentHTML", exceptionState);
     if (!fragment)
         return;
     insertAdjacent(where, fragment.get(), exceptionState);
 }
 
 String Element::innerText()
 {
     // We need to update layout, since plainText uses line boxes in the layout tree.
-    document().updateLayoutIgnorePendingStylesheets();
+    if (inActiveDocument())
+        document().updateLayoutIgnorePendingStylesheets();
 
     if (!layoutObject())
         return textContent(true);
 
     return plainText(EphemeralRange::rangeOfContents(*this), TextIteratorForInnerText);
 }
 
 String Element::outerText()
 {
     // Getting outerText is the same as getting innerText, only
@@ skipping 927 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink