reflow comments in core/paint

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.cpp

 /*
- * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
+ * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@gmail.com>
  *   Randall Jesup <rjesup@wgate.com>
  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
  *   Josh Soref <timeless@mac.com>
  *   Boris Zbarsky <bzbarsky@mit.edu>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  *
  * Alternatively, the contents of this file may be used under the terms
  * of either the Mozilla Public License Version 1.1, found at
  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
@@ skipping 66 matching lines @@
       m_scrollCorner(nullptr),
       m_resizer(nullptr),
       m_scrollAnchor(this)
 #if ENABLE(ASSERT)
       ,
       m_hasBeenDisposed(false)
 #endif
 {
   Node* node = box().node();
   if (node && node->isElementNode()) {
-    // We save and restore only the scrollOffset as the other scroll values are recalculated.
+    // We save and restore only the scrollOffset as the other scroll values are
+    // recalculated.
     Element* element = toElement(node);
     m_scrollOffset = element->savedLayerScrollOffset();
     if (!m_scrollOffset.isZero()) {
       scrollAnimator().setCurrentPosition(
           FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
     }
     element->setSavedLayerScrollOffset(IntSize());
   }
   updateResizerAreaSet();
 }
@@ skipping 41 matching lines @@
 
   m_scrollbarManager.dispose();
 
   if (m_scrollCorner)
     m_scrollCorner->destroy();
   if (m_resizer)
     m_resizer->destroy();
 
   clearScrollAnimators();
 
-  // Note: it is not safe to call ScrollAnchor::clear if the document is being destroyed,
-  // because LayoutObjectChildList::removeChildNode skips the call to willBeRemovedFromTree,
+  // Note: it is not safe to call ScrollAnchor::clear if the document is being
+  // destroyed, because LayoutObjectChildList::removeChildNode skips the call to
+  // willBeRemovedFromTree,
   // leaving the ScrollAnchor with a stale LayoutObject pointer.
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
       !box().documentBeingDestroyed())
     m_scrollAnchor.clear();
 
 #if ENABLE(ASSERT)
   m_hasBeenDisposed = true;
 #endif
 }
 
@@ skipping 69 matching lines @@
   return maxX - thickness - box.styleRef().borderRightWidth();
 }
 
 static IntRect cornerRect(const LayoutBox& box,
                           const Scrollbar* horizontalScrollbar,
                           const Scrollbar* verticalScrollbar,
                           const IntRect& bounds) {
   int horizontalThickness;
   int verticalThickness;
   if (!verticalScrollbar && !horizontalScrollbar) {
-    // FIXME: This isn't right. We need to know the thickness of custom scrollbars
-    // even when they don't exist in order to set the resizer square size properly.
+    // FIXME: This isn't right. We need to know the thickness of custom
+    // scrollbars even when they don't exist in order to set the resizer square
+    // size properly.
     horizontalThickness = ScrollbarTheme::theme().scrollbarThickness();
     verticalThickness = horizontalThickness;
   } else if (verticalScrollbar && !horizontalScrollbar) {
     horizontalThickness = verticalScrollbar->scrollbarThickness();
     verticalThickness = horizontalThickness;
   } else if (horizontalScrollbar && !verticalScrollbar) {
     verticalThickness = horizontalScrollbar->scrollbarThickness();
     horizontalThickness = verticalThickness;
   } else {
     horizontalThickness = verticalScrollbar->scrollbarThickness();
     verticalThickness = horizontalScrollbar->scrollbarThickness();
   }
   return IntRect(
       cornerStart(box, bounds.x(), bounds.maxX(), horizontalThickness),
       bounds.maxY() - verticalThickness - box.styleRef().borderBottomWidth(),
       horizontalThickness, verticalThickness);
 }
 
 IntRect PaintLayerScrollableArea::scrollCornerRect() const {
-  // We have a scrollbar corner when a scrollbar is visible and not filling the entire length of the box.
+  // We have a scrollbar corner when a scrollbar is visible and not filling the
+  // entire length of the box.
   // This happens when:
   // (a) A resizer is present and at least one scrollbar is present
   // (b) Both scrollbars are present.
   bool hasHorizontalBar = horizontalScrollbar();
   bool hasVerticalBar = verticalScrollbar();
   bool hasResizer = box().style()->resize() != RESIZE_NONE;
   if ((hasHorizontalBar && hasVerticalBar) ||
       (hasResizer && (hasHorizontalBar || hasVerticalBar)))
     return cornerRect(box(), horizontalScrollbar(), verticalScrollbar(),
                       box().pixelSnappedBorderBoxRect());
@@ skipping 71 matching lines @@
 
   FrameView* frameView = box().frameView();
 
   TRACE_EVENT1("devtools.timeline", "ScrollLayer", "data",
                InspectorScrollLayerEvent::data(&box()));
 
   // FIXME(420741): Resolve circular dependency between scroll offset and
   // compositing state, and remove this disabler.
   DisableCompositingQueryAsserts disabler;
 
-  // Update the positions of our child layers (if needed as only fixed layers should be impacted by a scroll).
-  // We don't update compositing layers, because we need to do a deep update from the compositing ancestor.
+  // Update the positions of our child layers (if needed as only fixed layers
+  // should be impacted by a scroll).  We don't update compositing layers,
+  // because we need to do a deep update from the compositing ancestor.
   if (!frameView->isInPerformLayout()) {
-    // If we're in the middle of layout, we'll just update layers once layout has finished.
+    // If we're in the middle of layout, we'll just update layers once layout
+    // has finished.
     layer()->updateLayerPositionsAfterOverflowScroll(scrollDelta);
     // Update regions, scrolling may change the clip of a particular region.
     frameView->updateDocumentAnnotatedRegions();
     frameView->setNeedsUpdateWidgetGeometries();
     updateCompositingLayersAfterScroll();
   }
 
   const LayoutBoxModelObject& paintInvalidationContainer =
       box().containerForPaintInvalidation();
   // The caret rect needs to be invalidated after scrolling
@@ skipping 40 matching lines @@
   }
 
   // Schedule the scroll DOM event.
   if (box().node())
     box().node()->document().enqueueScrollEventForNode(box().node());
 
   if (AXObjectCache* cache = box().document().existingAXObjectCache())
     cache->handleScrollPositionChanged(&box());
   box().view()->clearHitTestCache();
 
-  // Inform the FrameLoader of the new scroll position, so it can be restored when navigating back.
+  // Inform the FrameLoader of the new scroll position, so it can be restored
+  // when navigating back.
   if (layer()->isRootLayer()) {
     frameView->frame().loader().saveScrollState();
     frameView->didChangeScrollOffset();
   }
 
   // All scrolls clear the fragment anchor.
   frameView->clearFragmentAnchor();
 
   // Clear the scroll anchor, unless it is the reason for this scroll.
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
@@ skipping 160 matching lines @@
   return snapSizeToPixel(scrollWidth(),
                          box().clientLeft() + box().location().x());
 }
 
 int PaintLayerScrollableArea::pixelSnappedScrollHeight() const {
   return snapSizeToPixel(scrollHeight(),
                          box().clientTop() + box().location().y());
 }
 
 void PaintLayerScrollableArea::updateScrollOrigin() {
-  // This should do nothing prior to first layout; the if-clause will catch that.
+  // This should do nothing prior to first layout; the if-clause will catch
+  // that.
   if (overflowRect().isEmpty())
     return;
   LayoutPoint scrollableOverflow =
       m_overflowRect.location() -
       LayoutSize(box().borderLeft(), box().borderTop());
   setScrollOrigin(flooredIntPoint(-scrollableOverflow) +
                   box().originAdjustmentForScrollbars());
 }
 
 void PaintLayerScrollableArea::updateScrollDimensions() {
@@ skipping 26 matching lines @@
   bool hasHorizontalOverflow = this->hasHorizontalOverflow();
   bool hasVerticalOverflow = this->hasVerticalOverflow();
 
   // Don't add auto scrollbars if the box contents aren't visible.
   bool shouldHaveAutoHorizontalScrollbar =
       hasHorizontalOverflow && box().pixelSnappedClientHeight();
   bool shouldHaveAutoVerticalScrollbar =
       hasVerticalOverflow && box().pixelSnappedClientWidth();
 
   {
-    // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
+    // Hits in
+    // compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
     DisableCompositingQueryAsserts disabler;
 
     // overflow:scroll should just enable/disable.
     if (box().style()->overflowX() == OverflowScroll && horizontalScrollbar())
       horizontalScrollbar()->setEnabled(hasHorizontalOverflow);
     if (box().style()->overflowY() == OverflowScroll && verticalScrollbar())
       verticalScrollbar()->setEnabled(hasVerticalOverflow);
   }
 
-  // We need to layout again if scrollbars are added or removed by overflow:auto,
-  // or by changing between native and custom.
+  // We need to layout again if scrollbars are added or removed by
+  // overflow:auto, or by changing between native and custom.
   bool horizontalScrollbarShouldChange =
       (box().hasAutoHorizontalScrollbar() &&
        (hasHorizontalScrollbar() != shouldHaveAutoHorizontalScrollbar)) ||
       (box().style()->overflowX() == OverflowScroll && !horizontalScrollbar());
   bool verticalScrollbarShouldChange =
       (box().hasAutoVerticalScrollbar() &&
        (hasVerticalScrollbar() != shouldHaveAutoVerticalScrollbar)) ||
       (box().style()->overflowY() == OverflowScroll && !verticalScrollbar());
   bool scrollbarsWillChange =
       !scrollbarsAreFrozen && !visualViewportSuppliesScrollbars() &&
@@ skipping 25 matching lines @@
          box().style()->overflowX() != OverflowOverlay) ||
         (verticalScrollbarShouldChange &&
          box().style()->overflowY() != OverflowOverlay)) {
       if ((verticalScrollbarShouldChange && box().isHorizontalWritingMode()) ||
           (horizontalScrollbarShouldChange &&
            !box().isHorizontalWritingMode())) {
         box().setPreferredLogicalWidthsDirty();
       }
       if (relayoutIsPrevented) {
         // We're not doing re-layout right now, but we still want to
-        // add the scrollbar to the logical width now, to facilitate parent layout.
+        // add the scrollbar to the logical width now, to facilitate parent
+        // layout.
         box().updateLogicalWidth();
         PreventRelayoutScope::setBoxNeedsLayout(*this, hadHorizontalScrollbar,
                                                 hadVerticalScrollbar);
       } else {
         m_inOverflowRelayout = true;
         SubtreeLayoutScope layoutScope(box());
         layoutScope.setNeedsLayout(&box(),
                                    LayoutInvalidationReason::ScrollbarChanged);
         if (box().isLayoutBlock()) {
           LayoutBlock& block = toLayoutBlock(box());
           block.scrollbarsChanged(horizontalScrollbarShouldChange,
                                   verticalScrollbarShouldChange);
           block.layoutBlock(true);
         } else {
           box().layout();
         }
         m_inOverflowRelayout = false;
         m_scrollbarManager.destroyDetachedScrollbars();
       }
       LayoutObject* parent = box().parent();
       if (parent && parent->isFlexibleBox())
         toLayoutFlexibleBox(parent)->clearCachedMainSizeForChild(box());
     }
   }
 
   {
-    // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
+    // Hits in
+    // compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
     DisableCompositingQueryAsserts disabler;
 
     // Set up the range (and page step/line step).
     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
       int clientWidth = box().pixelSnappedClientWidth();
       horizontalScrollbar->setProportion(clientWidth,
                                          overflowRect().width().toInt());
     }
     if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
       int clientHeight = box().pixelSnappedClientHeight();
@@ skipping 15 matching lines @@
     bool hasOverflow =
         hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow();
     updateScrollableAreaSet(hasOverflow);
   }
 
   DisableCompositingQueryAsserts disabler;
   positionOverflowControls();
 }
 
 void PaintLayerScrollableArea::clampScrollPositionsAfterLayout() {
-  // If a vertical scrollbar was removed, the min/max scroll positions may have changed,
-  // so the scroll positions needs to be clamped.  If the scroll position did not change,
-  // but the scroll origin *did* change, we still need to notify the scrollbars to
-  // update their dimensions.
+  // If a vertical scrollbar was removed, the min/max scroll positions may have
+  // changed, so the scroll positions needs to be clamped.  If the scroll
+  // position did not change, but the scroll origin *did* change, we still need
+  // to notify the scrollbars to update their dimensions.
 
   if (DelayScrollPositionClampScope::clampingIsDelayed()) {
     DelayScrollPositionClampScope::setNeedsClamp(this);
     return;
   }
 
   // Restore before clamping because clamping clears the scroll anchor.
   if (shouldPerformScrollAnchoring())
     m_scrollAnchor.restore();
 
@@ skipping 69 matching lines @@
 void PaintLayerScrollableArea::updateAfterStyleChange(
     const ComputedStyle* oldStyle) {
   // Don't do this on first style recalc, before layout has ever happened.
   if (!overflowRect().size().isZero())
     updateScrollableAreaSet(hasScrollableHorizontalOverflow() ||
                             hasScrollableVerticalOverflow());
 
   if (!canHaveOverflowScrollbars(box()))
     return;
 
-  // Avoid drawing two sets of scrollbars when one is provided by the visual viewport.
+  // Avoid drawing two sets of scrollbars when one is provided by the visual
+  // viewport.
   if (visualViewportSuppliesScrollbars()) {
     setHasHorizontalScrollbar(false);
     setHasVerticalScrollbar(false);
     return;
   }
 
   EOverflow overflowX = box().style()->overflowX();
   EOverflow overflowY = box().style()->overflowY();
 
   bool needsHorizontalScrollbar =
       (hasHorizontalScrollbar() &&
        overflowDefinesAutomaticScrollbar(overflowX)) ||
       overflowRequiresScrollbar(overflowX);
   bool needsVerticalScrollbar =
       (hasVerticalScrollbar() &&
        overflowDefinesAutomaticScrollbar(overflowY)) ||
       overflowRequiresScrollbar(overflowY);
 
-  // Look for the scrollbarModes and reset the needs Horizontal & vertical Scrollbar values based on scrollbarModes, as during force style change
-  // StyleResolver::styleForDocument returns documentStyle with  no overflow values, due to which we are destorying the scrollbars that was
-  // already present.
+  // Look for the scrollbarModes and reset the needs Horizontal & vertical
+  // Scrollbar values based on scrollbarModes, as during force style change
+  // StyleResolver::styleForDocument returns documentStyle with  no overflow
+  // values, due to which we are destorying the scrollbars that was already
+  // present.
   if (box().isLayoutView()) {
     if (LocalFrame* frame = box().frame()) {
       if (FrameView* frameView = frame->view()) {
         ScrollbarMode hMode;
         ScrollbarMode vMode;
         frameView->calculateScrollbarModes(hMode, vMode);
         if (hMode == ScrollbarAlwaysOn && !needsHorizontalScrollbar)
           needsHorizontalScrollbar = true;
         if (vMode == ScrollbarAlwaysOn && !needsVerticalScrollbar)
           needsVerticalScrollbar = true;
@@ skipping 11 matching lines @@
     ASSERT(hasHorizontalScrollbar());
     horizontalScrollbar()->setEnabled(true);
   }
 
   if (needsVerticalScrollbar && oldStyle &&
       oldStyle->overflowY() == OverflowScroll && overflowY != OverflowScroll) {
     ASSERT(hasVerticalScrollbar());
     verticalScrollbar()->setEnabled(true);
   }
 
-  // FIXME: Need to detect a swap from custom to native scrollbars (and vice versa).
+  // FIXME: Need to detect a swap from custom to native scrollbars (and vice
+  // versa).
   if (horizontalScrollbar())
     horizontalScrollbar()->styleChanged();
   if (verticalScrollbar())
     verticalScrollbar()->styleChanged();
 
   updateScrollCornerStyle();
   updateResizerAreaSet();
   updateResizerStyle();
 
   // Whenever background changes on the scrollable element, the scroll bar
@@ skipping 185 matching lines @@
 
   if (hasScrollbar == hasHorizontalScrollbar())
     return;
 
   setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
 
   m_scrollbarManager.setHasHorizontalScrollbar(hasScrollbar);
 
   updateScrollOrigin();
 
-  // Destroying or creating one bar can cause our scrollbar corner to come and go. We need to update the opposite scrollbar's style.
+  // Destroying or creating one bar can cause our scrollbar corner to come and
+  // go. We need to update the opposite scrollbar's style.
   if (hasHorizontalScrollbar())
     horizontalScrollbar()->styleChanged();
   if (hasVerticalScrollbar())
     verticalScrollbar()->styleChanged();
 
   setScrollCornerNeedsPaintInvalidation();
 
   // Force an update since we know the scrollbars have changed things.
   if (box().document().hasAnnotatedRegions())
     box().document().setAnnotatedRegionsDirty(true);
 }
 
 void PaintLayerScrollableArea::setHasVerticalScrollbar(bool hasScrollbar) {
   if (FreezeScrollbarsScope::scrollbarsAreFrozen())
     return;
 
   DCHECK(box().frame()->settings());
   if (box().frame()->settings()->hideScrollbars())
     hasScrollbar = false;
 
   if (hasScrollbar == hasVerticalScrollbar())
     return;
 
   setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
 
   m_scrollbarManager.setHasVerticalScrollbar(hasScrollbar);
 
   updateScrollOrigin();
 
-  // Destroying or creating one bar can cause our scrollbar corner to come and go. We need to update the opposite scrollbar's style.
+  // Destroying or creating one bar can cause our scrollbar corner to come and
+  // go. We need to update the opposite scrollbar's style.
   if (hasHorizontalScrollbar())
     horizontalScrollbar()->styleChanged();
   if (hasVerticalScrollbar())
     verticalScrollbar()->styleChanged();
 
   setScrollCornerNeedsPaintInvalidation();
 
   // Force an update since we know the scrollbars have changed things.
   if (box().document().hasAnnotatedRegions())
     box().document().setAnnotatedRegionsDirty(true);
@@ skipping 33 matching lines @@
     horizontalScrollbar->setFrameRect(rectForHorizontalScrollbar(borderBox));
 
   const IntRect& scrollCorner = scrollCornerRect();
   if (m_scrollCorner)
     m_scrollCorner->setFrameRect(LayoutRect(scrollCorner));
 
   if (m_resizer)
     m_resizer->setFrameRect(
         LayoutRect(resizerCornerRect(borderBox, ResizerForPointer)));
 
-  // FIXME, this should eventually be removed, once we are certain that composited
-  // controls get correctly positioned on a compositor update. For now, conservatively
-  // leaving this unchanged.
+  // FIXME, this should eventually be removed, once we are certain that
+  // composited controls get correctly positioned on a compositor update. For
+  // now, conservatively leaving this unchanged.
   if (layer()->hasCompositedLayerMapping())
     layer()->compositedLayerMapping()->positionOverflowControlsLayers();
 }
 
 void PaintLayerScrollableArea::updateScrollCornerStyle() {
   if (!m_scrollCorner && !hasScrollbar())
     return;
   if (!m_scrollCorner && hasOverlayScrollbars())
     return;
 
@@ skipping 61 matching lines @@
          (hasVerticalScrollbar() ? verticalScrollbar()->scrollbarThickness()
                                  : resizeControlSize))
             .toInt(),
         horizontalScrollbar()->scrollbarThickness());
     if (hBarRect.contains(localPoint)) {
       result.setScrollbar(horizontalScrollbar());
       return true;
     }
   }
 
-  // FIXME: We should hit test the m_scrollCorner and pass it back through the result.
+  // FIXME: We should hit test the m_scrollCorner and pass it back through the
+  // result.
 
   return false;
 }
 
 IntRect PaintLayerScrollableArea::resizerCornerRect(
     const IntRect& bounds,
     ResizerHitTestType resizerHitTestType) const {
   if (box().style()->resize() == RESIZE_NONE)
     return IntRect();
   IntRect corner =
@@ skipping 106 matching lines @@
   if (PaintLayerScrollableAreaRareData* d = rareData()) {
     d->m_stickyConstraintsMap.remove(layer);
     if (needsCompositingUpdate &&
         layer->layoutObject()->style()->position() == StickyPosition)
       layer->setNeedsCompositingInputsUpdate();
   }
 }
 
 IntSize PaintLayerScrollableArea::offsetFromResizeCorner(
     const IntPoint& absolutePoint) const {
-  // Currently the resize corner is either the bottom right corner or the bottom left corner.
-  // FIXME: This assumes the location is 0, 0. Is this guaranteed to always be the case?
+  // Currently the resize corner is either the bottom right corner or the bottom
+  // left corner.
+  // FIXME: This assumes the location is 0, 0. Is this guaranteed to always be
+  // the case?
   IntSize elementSize = layer()->size();
   if (box().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     elementSize.setWidth(0);
   IntPoint resizerPoint = IntPoint(elementSize);
   IntPoint localPoint =
       roundedIntPoint(box().absoluteToLocal(absolutePoint, UseTransforms));
   return localPoint - resizerPoint;
 }
 
 void PaintLayerScrollableArea::resize(const PlatformEvent& evt,
@@ skipping 48 matching lines @@
 
   LayoutSize difference(
       (currentSize + newOffset - adjustedOldOffset).expandedTo(minimumSize) -
       currentSize);
 
   bool isBoxSizingBorder = box().style()->boxSizing() == BoxSizingBorderBox;
 
   EResize resize = box().style()->resize();
   if (resize != RESIZE_VERTICAL && difference.width()) {
     if (element->isFormControlElement()) {
-      // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
+      // Make implicit margins from the theme explicit (see
+      // <http://bugs.webkit.org/show_bug.cgi?id=9547>).
       element->setInlineStyleProperty(CSSPropertyMarginLeft,
                                       box().marginLeft() / zoomFactor,
                                       CSSPrimitiveValue::UnitType::Pixels);
       element->setInlineStyleProperty(CSSPropertyMarginRight,
                                       box().marginRight() / zoomFactor,
                                       CSSPrimitiveValue::UnitType::Pixels);
     }
     LayoutUnit baseWidth =
         box().size().width() -
         (isBoxSizingBorder ? LayoutUnit() : box().borderAndPaddingWidth());
     baseWidth = LayoutUnit(baseWidth / zoomFactor);
     element->setInlineStyleProperty(CSSPropertyWidth,
                                     roundToInt(baseWidth + difference.width()),
                                     CSSPrimitiveValue::UnitType::Pixels);
   }
 
   if (resize != RESIZE_HORIZONTAL && difference.height()) {
     if (element->isFormControlElement()) {
-      // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
+      // Make implicit margins from the theme explicit (see
+      // <http://bugs.webkit.org/show_bug.cgi?id=9547>).
       element->setInlineStyleProperty(CSSPropertyMarginTop,
                                       box().marginTop() / zoomFactor,
                                       CSSPrimitiveValue::UnitType::Pixels);
       element->setInlineStyleProperty(CSSPropertyMarginBottom,
                                       box().marginBottom() / zoomFactor,
                                       CSSPrimitiveValue::UnitType::Pixels);
     }
     LayoutUnit baseHeight =
         box().size().height() -
         (isBoxSizingBorder ? LayoutUnit() : box().borderAndPaddingHeight());
     baseHeight = LayoutUnit(baseHeight / zoomFactor);
     element->setInlineStyleProperty(
         CSSPropertyHeight, roundToInt(baseHeight + difference.height()),
         CSSPrimitiveValue::UnitType::Pixels);
   }
 
   document.updateStyleAndLayout();
 
-  // FIXME (Radar 4118564): We should also autoscroll the window as necessary to keep the point under the cursor in view.
+  // FIXME (Radar 4118564): We should also autoscroll the window as necessary to
+  // keep the point under the cursor in view.
 }
 
 LayoutRect PaintLayerScrollableArea::scrollIntoView(
     const LayoutRect& rect,
     const ScrollAlignment& alignX,
     const ScrollAlignment& alignY,
     ScrollType scrollType) {
   LayoutRect localExposeRect(
       box()
           .absoluteToLocalQuad(FloatQuad(FloatRect(rect)), UseTransforms)
@@ skipping 65 matching lines @@
           GraphicsLayerUpdateSubtree);
       compositor->setNeedsCompositingUpdate(
           CompositingUpdateAfterGeometryChange);
     } else {
       layer()->setNeedsCompositingInputsUpdate();
     }
   }
 }
 
 bool PaintLayerScrollableArea::usesCompositedScrolling() const {
-  // See https://codereview.chromium.org/176633003/ for the tests that fail without this disabler.
+  // See https://codereview.chromium.org/176633003/ for the tests that fail
+  // without this disabler.
   DisableCompositingQueryAsserts disabler;
   return layer()->hasCompositedLayerMapping() &&
          layer()->compositedLayerMapping()->scrollingLayer();
 }
 
 bool PaintLayerScrollableArea::shouldScrollOnMainThread() const {
   if (LocalFrame* frame = box().frame()) {
     if (Page* page = frame->page()) {
       if (page->scrollingCoordinator()
               ->shouldUpdateScrollLayerPositionOnMainThread())
         return true;
     }
   }
   return ScrollableArea::shouldScrollOnMainThread();
 }
 
 static bool layerNeedsCompositedScrolling(
     PaintLayerScrollableArea::LCDTextMode mode,
     const PaintLayer* layer) {
   if (!layer->scrollsOverflow())
     return false;
 
   Node* node = layer->enclosingNode();
   if (node && node->isElementNode() &&
       (toElement(node)->compositorMutableProperties() &
        (CompositorMutableProperty::kScrollTop |
         CompositorMutableProperty::kScrollLeft)))
     return true;
 
-  // TODO(schenney): LCD Text also requires integer scroll offsets for the layer. While we
-  // use integer scroll offsets locally when !layer->compositor()->preferCompositingToLCDTextEnabled(),
-  // we do not check offsets accumulated from the root (including translates). crbug.com/644833
+  // TODO(schenney): LCD Text also requires integer scroll offsets for the
+  // layer. While we use integer scroll offsets locally when
+  // !layer->compositor()->preferCompositingToLCDTextEnabled(), we do not check
+  // offsets accumulated from the root (including translates).  crbug.com/644833
   bool backgroundSupportsLCDText =
       RuntimeEnabledFeatures::compositeOpaqueScrollersEnabled() &&
       layer->canPaintBackgroundOntoScrollingContentsLayer() &&
       layer->backgroundIsKnownToBeOpaqueInRect(
           toLayoutBox(layer->layoutObject())->paddingBoxRect());
   if (mode == PaintLayerScrollableArea::ConsiderLCDText &&
       !layer->compositor()->preferCompositingToLCDTextEnabled() &&
       !backgroundSupportsLCDText)
     return false;
 
-  // TODO(schenney) Tests fail if we do not also exclude layer->layoutObject()->style()->hasBorderDecoration()
-  // (missing background behind dashed borders). Resolve this case, or not, and update this check with
-  // the results.
+  // TODO(schenney) Tests fail if we do not also exclude
+  // layer->layoutObject()->style()->hasBorderDecoration() (missing background
+  // behind dashed borders). Resolve this case, or not, and update this check
+  // with the results.
   return !(layer->size().isEmpty() || layer->hasDescendantWithClipPath() ||
            layer->hasAncestorWithClipPath() ||
            layer->layoutObject()->style()->hasBorderRadius());
 }
 
 void PaintLayerScrollableArea::updateNeedsCompositedScrolling(
     LCDTextMode mode) {
   const bool needsCompositedScrolling =
       layerNeedsCompositedScrolling(mode, layer());
   if (static_cast<bool>(m_needsCompositedScrolling) !=
@@ skipping 59 matching lines @@
   ASSERT(!m_vBarIsAttached || m_vBar);
   if (m_hBar && !m_hBarIsAttached)
     destroyScrollbar(HorizontalScrollbar);
   if (m_vBar && !m_vBarIsAttached)
     destroyScrollbar(VerticalScrollbar);
 }
 
 void PaintLayerScrollableArea::ScrollbarManager::setHasHorizontalScrollbar(
     bool hasScrollbar) {
   if (hasScrollbar) {
-    // This doesn't hit in any tests, but since the equivalent code in setHasVerticalScrollbar
-    // does, presumably this code does as well.
+    // This doesn't hit in any tests, but since the equivalent code in
+    // setHasVerticalScrollbar does, presumably this code does as well.
     DisableCompositingQueryAsserts disabler;
     if (!m_hBar) {
       m_hBar = createScrollbar(HorizontalScrollbar);
       m_hBarIsAttached = 1;
       if (!m_hBar->isCustomScrollbar())
         m_scrollableArea->didAddScrollbar(*m_hBar, HorizontalScrollbar);
     } else {
       m_hBarIsAttached = 1;
     }
   } else {
@@ skipping 183 matching lines @@
 
 void PaintLayerScrollableArea::DelayScrollPositionClampScope::
     clampScrollableAreas() {
   for (auto& scrollableArea : *s_needsClamp)
     scrollableArea->clampScrollPositionsAfterLayout();
   delete s_needsClamp;
   s_needsClamp = nullptr;
 }
 
 }  // namespace blink