Rename (updateLayout/updateStyle).*.() to updateStyleAndLayout.*.()

third_party/WebKit/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 420 matching lines @@
     return nullAtom;
 }
 
 bool Element::shouldIgnoreAttributeCase() const
 {
     return isHTMLElement() && document().isHTMLDocument();
 }
 
 void Element::scrollIntoView(bool alignToTop)
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (!layoutObject())
         return;
 
     bool makeVisibleInVisualViewport = !document().page()->settings().inertVisualViewport();
 
     LayoutRect bounds = boundingBox();
     // Align to the top / bottom and to the closest edge.
     if (alignToTop)
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways, ProgrammaticScroll, makeVisibleInVisualViewport);
     else
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways, ProgrammaticScroll, makeVisibleInVisualViewport);
 
     document().setSequentialFocusNavigationStartingPoint(this);
 }
 
 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (!layoutObject())
         return;
 
     bool makeVisibleInVisualViewport = !document().page()->settings().inertVisualViewport();
 
     LayoutRect bounds = boundingBox();
     if (centerIfNeeded)
         layoutObject()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded, ProgrammaticScroll, makeVisibleInVisualViewport);
     else
@@ skipping 70 matching lines @@
     DCHECK(!layoutObject() || layoutObject()->isBox());
 
     if (scrollState.fullyConsumed())
         return;
 
     FloatSize delta(scrollState.deltaX(), scrollState.deltaY());
 
     if (delta.isZero())
         return;
 
-    // TODO(esprehn): This should use updateLayoutIgnorePendingStylesheetsForNode.
-    document().updateLayoutIgnorePendingStylesheets();
+    // TODO(esprehn): This should use updateStyleAndLayoutIgnorePendingStylesheetsForNode.
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     LayoutBox* boxToScroll = nullptr;
 
     // Handle the scrollingElement separately, as it should scroll the viewport.
     if (this == document().scrollingElement())
         boxToScroll = document().layoutView();
     else if (layoutObject())
         boxToScroll = toLayoutBox(layoutObject());
 
     if (!boxToScroll)
@@ skipping 32 matching lines @@
     if (callback->nativeScrollBehavior() != WebNativeScrollBehavior::PerformAfterNativeScroll)
         callback->handleEvent(&scrollState);
     if (callback->nativeScrollBehavior() != WebNativeScrollBehavior::DisableNativeScroll)
         nativeApplyScroll(scrollState);
     if (callback->nativeScrollBehavior() == WebNativeScrollBehavior::PerformAfterNativeScroll)
         callback->handleEvent(&scrollState);
 };
 
 int Element::offsetLeft()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutObject->pixelSnappedOffsetLeft()), layoutObject->styleRef()).round();
     return 0;
 }
 
 int Element::offsetTop()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutObject->pixelSnappedOffsetTop()), layoutObject->styleRef()).round();
     return 0;
 }
 
 int Element::offsetWidth()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutObject->pixelSnappedOffsetWidth()), layoutObject->styleRef()).round();
     return 0;
 }
 
 int Element::offsetHeight()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     if (LayoutBoxModelObject* layoutObject = layoutBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutObject->pixelSnappedOffsetHeight()), layoutObject->styleRef()).round();
     return 0;
 }
 
 Element* Element::offsetParent()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     LayoutObject* layoutObject = this->layoutObject();
     if (!layoutObject)
         return nullptr;
 
     Element* element = layoutObject->offsetParent();
     if (!element)
         return nullptr;
 
     if (element->isInShadowTree() && !element->containingShadowRoot()->isOpenOrV0())
         return nullptr;
 
     return element;
 }
 
 int Element::clientLeft()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(layoutObject->clientLeft(), layoutObject->styleRef()).round();
     return 0;
 }
 
 int Element::clientTop()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(layoutObject->clientTop(), layoutObject->styleRef()).round();
     return 0;
 }
 
 int Element::clientWidth()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     // 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 (LayoutViewItem layoutView = LayoutViewItem(document().layoutView())) {
             if (document().page()->settings().forceZeroLayoutHeight())
                 return adjustLayoutUnitForAbsoluteZoom(layoutView.overflowClipRect(LayoutPoint()).width(), layoutView.styleRef()).round();
             return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutView.layoutSize().width()), layoutView.styleRef()).round();
         }
     }
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutObject->pixelSnappedClientWidth()), layoutObject->styleRef()).round();
     return 0;
 }
 
 int Element::clientHeight()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     // 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 (LayoutViewItem layoutView = LayoutViewItem(document().layoutView())) {
             if (document().page()->settings().forceZeroLayoutHeight())
                 return adjustLayoutUnitForAbsoluteZoom(layoutView.overflowClipRect(LayoutPoint()).height(), layoutView.styleRef()).round();
             return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutView.layoutSize().height()), layoutView.styleRef()).round();
         }
     }
 
     if (LayoutBox* layoutObject = layoutBox())
         return adjustLayoutUnitForAbsoluteZoom(LayoutUnit(layoutObject->pixelSnappedClientHeight()), layoutObject->styleRef()).round();
     return 0;
 }
 
 double Element::scrollLeft()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     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()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     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)
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     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)
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     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()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (document().scrollingElement() == this) {
         if (document().view())
             return adjustForAbsoluteZoom(document().view()->contentsWidth(), document().frame()->pageZoomFactor());
         return 0;
     }
 
     if (LayoutBox* box = layoutBox())
         return adjustForAbsoluteZoom(box->pixelSnappedScrollWidth(), box);
     return 0;
 }
 
 int Element::scrollHeight()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (document().scrollingElement() == this) {
         if (document().view())
             return adjustForAbsoluteZoom(document().view()->contentsHeight(), document().frame()->pageZoomFactor());
         return 0;
     }
 
     if (LayoutBox* box = layoutBox())
         return adjustForAbsoluteZoom(box->pixelSnappedScrollHeight(), box);
     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)
 {
     // FIXME: This should be removed once scroll updates are processed only after
     // the compositing update. See http://crbug.com/420741.
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     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)
 {
     // FIXME: This should be removed once scroll updates are processed only after
     // the compositing update. See http://crbug.com/420741.
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (document().scrollingElement() == this) {
         scrollFrameTo(scrollToOptions);
     } else {
         scrollLayoutBoxTo(scrollToOptions);
     }
 }
 
 void Element::scrollLayoutBoxBy(const ScrollToOptions& scrollToOptions)
 {
@@ skipping 100 matching lines @@
 {
     if (!hasRareData())
         return CompositorMutableProperty::kNone;
     if (CompositorProxiedPropertySet* set = elementRareData()->proxiedPropertyCounts())
         return set->proxiedProperties();
     return CompositorMutableProperty::kNone;
 }
 
 bool Element::hasNonEmptyLayoutSize() const
 {
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     if (LayoutBoxModelObject* box = layoutBoxModelObject())
         return box->hasNonEmptyLayoutSize();
     return false;
 }
 
 IntRect Element::boundsInViewport() const
 {
-    document().updateLayoutIgnorePendingStylesheets();
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     FrameView* view = document().view();
     if (!view)
         return IntRect();
 
     Vector<FloatQuad> quads;
     if (isSVGElement() && layoutObject()) {
         // Get the bounding rectangle from the SVG model.
         if (toSVGElement(this)->isSVGGraphicsElement())
             quads.append(layoutObject()->localToAbsoluteQuad(layoutObject()->objectBoundingBox()));
     } else {
         // Get the bounding rectangle from the box model.
         if (layoutBoxModelObject())
             layoutBoxModelObject()->absoluteQuads(quads);
     }
 
     if (quads.isEmpty())
         return IntRect();
 
     IntRect result = quads[0].enclosingBoundingBox();
     for (size_t i = 1; i < quads.size(); ++i)
         result.unite(quads[i].enclosingBoundingBox());
 
     return view->contentsToViewport(result);
 }
 
 ClientRectList* Element::getClientRects()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     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()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     Vector<FloatQuad> quads;
     LayoutObject* elementLayoutObject = layoutObject();
     if (elementLayoutObject) {
         if (isSVGElement() && !elementLayoutObject->isSVGRoot()) {
             // Get the bounding rectangle from the SVG model.
             if (toSVGElement(this)->isSVGGraphicsElement())
                 quads.append(elementLayoutObject->localToAbsoluteQuad(elementLayoutObject->objectBoundingBox()));
         } else if (elementLayoutObject->isBoxModelObject() || elementLayoutObject->isBR()) {
             elementLayoutObject->absoluteQuads(quads);
         }
     }
 
     if (quads.isEmpty())
         return ClientRect::create();
 
     FloatRect result = quads[0].boundingBox();
     for (size_t i = 1; i < quads.size(); ++i)
         result.unite(quads[i].boundingBox());
 
     DCHECK(elementLayoutObject);
     document().adjustFloatRectForScrollAndAbsoluteZoom(result, *elementLayoutObject);
     return ClientRect::create(result);
 }
 
 const AtomicString& Element::computedRole()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     OwnPtr<ScopedAXObjectCache> cache = ScopedAXObjectCache::create(document());
     return cache->get()->computedRoleForNode(this);
 }
 
 String Element::computedName()
 {
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     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 1303 matching lines @@
 {
     if (!inShadowIncludingDocument())
         return;
 
     if (document().focusedElement() == this)
         return;
 
     if (!document().isActive())
         return;
 
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
     if (!isFocusable())
         return;
 
     if (authorShadowRoot() && authorShadowRoot()->delegatesFocus()) {
         if (isShadowIncludingInclusiveAncestorOf(document().focusedElement()))
             return;
 
         // Slide the focus to its inner node.
         Element* found = document().page()->focusController().findFocusableElementInShadowHost(*this);
         if (found && isShadowIncludingInclusiveAncestorOf(found)) {
@@ skipping 298 matching lines @@
         else if (document().frame()->eventHandler().getPointerEventType(pointerId) == WebPointerProperties::PointerType::Touch)
             exceptionState.throwDOMException(InvalidPointerId, "InvalidPointerId");
         else
             document().frame()->eventHandler().releasePointerCapture(pointerId, this);
     }
 }
 
 String Element::innerText()
 {
     // We need to update layout, since plainText uses line boxes in the layout tree.
-    document().updateLayoutIgnorePendingStylesheetsForNode(this);
+    document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
     if (!layoutObject())
         return textContent(true);
 
     return plainText(EphemeralRange::rangeOfContents(*this), TextIteratorForInnerText);
 }
 
 String Element::outerText()
 {
     // Getting outerText is the same as getting innerText, only
@@ skipping 989 matching lines @@
 
 DEFINE_TRACE(Element)
 {
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink