Reformat comments in core/layout up until LayoutBox

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
+ *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 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
@@ skipping 78 matching lines @@
 LayoutBox::LayoutBox(ContainerNode* node)
     : LayoutBoxModelObject(node),
       m_intrinsicContentLogicalHeight(-1),
       m_minPreferredLogicalWidth(-1),
       m_maxPreferredLogicalWidth(-1),
       m_inlineBoxWrapper(nullptr) {
   setIsBox();
 }
 
 PaintLayerType LayoutBox::layerTypeRequired() const {
-  // hasAutoZIndex only returns true if the element is positioned or a flex-item since
-  // position:static elements that are not flex-items get their z-index coerced to auto.
+  // hasAutoZIndex only returns true if the element is positioned or a flex-item
+  // since position:static elements that are not flex-items get their z-index
+  // coerced to auto.
   if (isPositioned() || createsGroup() || hasClipPath() ||
       hasTransformRelatedProperty() || style()->hasCompositorProxy() ||
       hasHiddenBackface() || hasReflection() || style()->specifiesColumns() ||
       style()->isStackingContext() ||
       style()->shouldCompositeForCurrentAnimations())
     return NormalPaintLayer;
 
   if (hasOverflowClip())
     return OverflowClipPaintLayer;
 
@@ skipping 61 matching lines @@
 }
 
 void LayoutBox::styleWillChange(StyleDifference diff,
                                 const ComputedStyle& newStyle) {
   const ComputedStyle* oldStyle = style();
   if (oldStyle) {
     LayoutFlowThread* flowThread = flowThreadContainingBlock();
     if (flowThread && flowThread != this)
       flowThread->flowThreadDescendantStyleWillChange(this, diff, newStyle);
 
-    // The background of the root element or the body element could propagate up to
-    // the canvas. Just dirty the entire canvas when our style changes substantially.
+    // The background of the root element or the body element could propagate up
+    // to the canvas. Just dirty the entire canvas when our style changes
+    // substantially.
     if ((diff.needsPaintInvalidation() || diff.needsLayout()) && node() &&
         (isHTMLHtmlElement(*node()) || isHTMLBodyElement(*node()))) {
       view()->setShouldDoFullPaintInvalidation();
 
       if (oldStyle->hasEntirelyFixedBackground() !=
           newStyle.hasEntirelyFixedBackground())
         view()->compositor()->setNeedsUpdateFixedBackground();
     }
 
-    // When a layout hint happens and an object's position style changes, we have to do a layout
-    // to dirty the layout tree using the old position value now.
+    // When a layout hint happens and an object's position style changes, we
+    // have to do a layout to dirty the layout tree using the old position
+    // value now.
     if (diff.needsFullLayout() && parent() &&
         oldStyle->position() != newStyle.position()) {
       if (!oldStyle->hasOutOfFlowPosition() &&
           newStyle.hasOutOfFlowPosition()) {
-        // We're about to go out of flow. Before that takes place, we need to mark the
-        // current containing block chain for preferred widths recalculation.
+        // We're about to go out of flow. Before that takes place, we need to
+        // mark the current containing block chain for preferred widths
+        // recalculation.
         setNeedsLayoutAndPrefWidthsRecalc(
             LayoutInvalidationReason::StyleChange);
       } else {
         markContainerChainForLayout();
       }
       if (oldStyle->position() == StaticPosition)
         setShouldDoFullPaintInvalidation();
       else if (newStyle.hasOutOfFlowPosition())
         parent()->setChildNeedsLayout();
       if (isFloating() && !isOutOfFlowPositioned() &&
           newStyle.hasOutOfFlowPosition())
         removeFloatingOrPositionedChildFromBlockLists();
     }
-    // FIXME: This branch runs when !oldStyle, which means that layout was never called
-    // so what's the point in invalidating the whole view that we never painted?
+    // FIXME: This branch runs when !oldStyle, which means that layout was never
+    // called so what's the point in invalidating the whole view that we never
+    // painted?
   } else if (isBody()) {
     view()->setShouldDoFullPaintInvalidation();
   }
 
   LayoutBoxModelObject::styleWillChange(diff, newStyle);
 }
 
 void LayoutBox::styleDidChange(StyleDifference diff,
                                const ComputedStyle* oldStyle) {
-  // Horizontal writing mode definition is updated in LayoutBoxModelObject::updateFromStyle,
-  // (as part of the LayoutBoxModelObject::styleDidChange call below). So, we can safely cache the horizontal
-  // writing mode value before style change here.
+  // Horizontal writing mode definition is updated in LayoutBoxModelObject::
+  // updateFromStyle, (as part of the LayoutBoxModelObject::styleDidChange call
+  // below). So, we can safely cache the horizontal writing mode value before
+  // style change here.
   bool oldHorizontalWritingMode = isHorizontalWritingMode();
 
   LayoutBoxModelObject::styleDidChange(diff, oldStyle);
 
   if (isFloatingOrOutOfFlowPositioned() && oldStyle &&
       !oldStyle->isFloating() && !oldStyle->hasOutOfFlowPosition() &&
       parent() && parent()->isLayoutBlockFlow())
     toLayoutBlockFlow(parent())->childBecameFloatingOrOutOfFlow(this);
 
   const ComputedStyle& newStyle = styleRef();
   if (needsLayout() && oldStyle)
     removeFromPercentHeightContainer();
 
   if (oldHorizontalWritingMode != isHorizontalWritingMode()) {
     if (oldStyle) {
       if (isOrthogonalWritingModeRoot())
         markOrthogonalWritingModeRoot();
       else
         unmarkOrthogonalWritingModeRoot();
     }
 
     clearPercentHeightDescendants();
   }
 
-  // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
-  // new zoomed coordinate space.
+  // If our zoom factor changes and we have a defined scrollLeft/Top, we need to
+  // adjust that value into the new zoomed coordinate space.
   if (hasOverflowClip() && oldStyle &&
       oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
     PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
     ASSERT(scrollableArea);
     if (int left = scrollableArea->scrollXOffset()) {
       left = (left / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
       scrollableArea->scrollToXOffset(left);
     }
     if (int top = scrollableArea->scrollYOffset()) {
       top = (top / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
@@ skipping 37 matching lines @@
   updateBackgroundAttachmentFixedStatusAfterStyleChange();
 
   if (oldStyle) {
     LayoutFlowThread* flowThread = flowThreadContainingBlock();
     if (flowThread && flowThread != this)
       flowThread->flowThreadDescendantStyleDidChange(this, diff, *oldStyle);
 
     updateScrollSnapMappingAfterStyleChange(&newStyle, oldStyle);
   }
 
-  ASSERT(
-      !isInline() ||
-      isAtomicInlineLevel());  // Non-atomic inlines should be LayoutInline or LayoutText, not LayoutBox.
+  // Non-atomic inlines should be LayoutInline or LayoutText, not LayoutBox.
+  DCHECK(!isInline() || isAtomicInlineLevel());
 }
 
 void LayoutBox::updateBackgroundAttachmentFixedStatusAfterStyleChange() {
   if (!frameView())
     return;
 
-  // On low-powered/mobile devices, preventing blitting on a scroll can cause noticeable delays
-  // when scrolling a page with a fixed background image. As an optimization, assuming there are
-  // no fixed positoned elements on the page, we can acclerate scrolling (via blitting) if we
-  // ignore the CSS property "background-attachment: fixed".
+  // On low-powered/mobile devices, preventing blitting on a scroll can cause
+  // noticeable delays when scrolling a page with a fixed background image. As
+  // an optimization, assuming there are no fixed positoned elements on the
+  // page, we can acclerate scrolling (via blitting) if we ignore the CSS
+  // property "background-attachment: fixed".
   bool ignoreFixedBackgroundAttachment =
       RuntimeEnabledFeatures::fastMobileScrollingEnabled();
   if (ignoreFixedBackgroundAttachment)
     return;
 
-  // An object needs to be repainted on frame scroll when it has background-attachment:fixed.
-  // LayoutView is responsible for painting root background, thus the root element (and the
-  // body element if html element has no background) skips painting backgrounds.
+  // An object needs to be repainted on frame scroll when it has background-
+  // attachment:fixed. LayoutView is responsible for painting root background,
+  // thus the root element (and the body element if html element has no
+  // background) skips painting backgrounds.
   bool isBackgroundAttachmentFixedObject = !isDocumentElement() &&
                                            !backgroundStolenForBeingBody() &&
                                            styleRef().hasFixedBackgroundImage();
   if (isLayoutView() &&
       view()->compositor()->supportsFixedRootBackgroundCompositing()) {
     if (styleRef().hasEntirelyFixedBackground())
       isBackgroundAttachmentFixedObject = false;
   }
 
   setIsBackgroundAttachmentFixedObject(isBackgroundAttachmentFixedObject);
 }
 
 void LayoutBox::updateShapeOutsideInfoAfterStyleChange(
     const ComputedStyle& style,
     const ComputedStyle* oldStyle) {
   const ShapeValue* shapeOutside = style.shapeOutside();
   const ShapeValue* oldShapeOutside =
       oldStyle ? oldStyle->shapeOutside()
                : ComputedStyle::initialShapeOutside();
 
   Length shapeMargin = style.shapeMargin();
   Length oldShapeMargin =
       oldStyle ? oldStyle->shapeMargin() : ComputedStyle::initialShapeMargin();
 
   float shapeImageThreshold = style.shapeImageThreshold();
   float oldShapeImageThreshold =
       oldStyle ? oldStyle->shapeImageThreshold()
                : ComputedStyle::initialShapeImageThreshold();
 
-  // FIXME: A future optimization would do a deep comparison for equality. (bug 100811)
+  // FIXME: A future optimization would do a deep comparison for equality. (bug
+  // 100811)
   if (shapeOutside == oldShapeOutside && shapeMargin == oldShapeMargin &&
       shapeImageThreshold == oldShapeImageThreshold)
     return;
 
   if (!shapeOutside)
     ShapeOutsideInfo::removeInfo(*this);
   else
     ShapeOutsideInfo::ensureInfo(*this).markShapeAsDirty();
 
   if (shapeOutside || shapeOutside != oldShapeOutside)
     markShapeOutsideDependentsForLayout();
 }
 
 void LayoutBox::updateGridPositionAfterStyleChange(
     const ComputedStyle* oldStyle) {
   if (!oldStyle || !parent() || !parent()->isLayoutGrid())
     return;
 
   if (oldStyle->gridColumnStart() == style()->gridColumnStart() &&
       oldStyle->gridColumnEnd() == style()->gridColumnEnd() &&
       oldStyle->gridRowStart() == style()->gridRowStart() &&
       oldStyle->gridRowEnd() == style()->gridRowEnd() &&
       oldStyle->order() == style()->order() &&
       oldStyle->hasOutOfFlowPosition() == style()->hasOutOfFlowPosition())
     return;
 
-  // It should be possible to not dirty the grid in some cases (like moving an explicitly placed grid item).
+  // It should be possible to not dirty the grid in some cases (like moving an
+  // explicitly placed grid item).
   // For now, it's more simple to just always recompute the grid.
   toLayoutGrid(parent())->dirtyGrid();
 }
 
 void LayoutBox::updateScrollSnapMappingAfterStyleChange(
     const ComputedStyle* newStyle,
     const ComputedStyle* oldStyle) {
   SnapCoordinator* snapCoordinator = document().snapCoordinator();
   if (!snapCoordinator)
     return;
@@ skipping 49 matching lines @@
   LayoutState state(*this, locationOffset());
   while (child) {
     child->layoutIfNeeded();
     ASSERT(!child->needsLayout());
     child = child->nextSibling();
   }
   invalidateBackgroundObscurationStatus();
   clearNeedsLayout();
 }
 
-// More IE extensions.  clientWidth and clientHeight represent the interior of an object
-// excluding border and scrollbar.
+// More IE extensions.  clientWidth and clientHeight represent the interior of
+// an object excluding border and scrollbar.
 DISABLE_CFI_PERF
 LayoutUnit LayoutBox::clientWidth() const {
   return m_frameRect.width() - borderLeft() - borderRight() -
          verticalScrollbarWidth();
 }
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutBox::clientHeight() const {
   return m_frameRect.height() - borderTop() - borderBottom() -
          horizontalScrollbarHeight();
@@ skipping 52 matching lines @@
 int LayoutBox::pixelSnappedScrollHeight() const {
   if (hasOverflowClip())
     return snapSizeToPixel(getScrollableArea()->scrollHeight(),
                            location().y() + clientTop());
   // For objects with visible overflow, this matches IE.
   // FIXME: Need to work right with writing modes.
   return snapSizeToPixel(scrollHeight(), location().y() + clientTop());
 }
 
 void LayoutBox::setScrollLeft(LayoutUnit newLeft) {
-  // This doesn't hit in any tests, but since the equivalent code in setScrollTop
-  // does, presumably this code does as well.
+  // This doesn't hit in any tests, but since the equivalent code in
+  // setScrollTop does, presumably this code does as well.
   DisableCompositingQueryAsserts disabler;
 
   if (hasOverflowClip())
     getScrollableArea()->scrollToXOffset(newLeft, ScrollOffsetClamped,
                                          ScrollBehaviorAuto);
 }
 
 void LayoutBox::setScrollTop(LayoutUnit newTop) {
-  // Hits in compositing/overflow/do-not-assert-on-invisible-composited-layers.html
+  // Hits in
+  // compositing/overflow/do-not-assert-on-invisible-composited-layers.html
   DisableCompositingQueryAsserts disabler;
 
   if (hasOverflowClip())
     getScrollableArea()->scrollToYOffset(newTop, ScrollOffsetClamped,
                                          ScrollBehaviorAuto);
 }
 
 void LayoutBox::scrollToOffset(const DoubleSize& offset,
                                ScrollBehavior scrollBehavior) {
-  // This doesn't hit in any tests, but since the equivalent code in setScrollTop
-  // does, presumably this code does as well.
+  // This doesn't hit in any tests, but since the equivalent code in
+  // setScrollTop does, presumably this code does as well.
   DisableCompositingQueryAsserts disabler;
 
   if (hasOverflowClip())
     getScrollableArea()->scrollToOffset(offset, ScrollOffsetClamped,
                                         scrollBehavior);
 }
 
-// Returns true iff we are attempting an autoscroll inside an iframe with scrolling="no".
+// Returns true iff we are attempting an autoscroll inside an iframe with
+// scrolling="no".
 static bool isDisallowedAutoscroll(HTMLFrameOwnerElement* ownerElement,
                                    FrameView* frameView) {
   if (ownerElement && isHTMLFrameElementBase(*ownerElement)) {
     HTMLFrameElementBase* frameElementBase =
         toHTMLFrameElementBase(ownerElement);
     if (Page* page = frameView->frame().page()) {
       return page->autoscrollController().autoscrollInProgress() &&
              frameElementBase->scrollingMode() == ScrollbarAlwaysOff;
     }
   }
@@ skipping 18 matching lines @@
   LayoutBox* parentBox = nullptr;
   LayoutRect newRect = rectToScroll;
 
   bool restrictedByLineClamp = false;
   if (containingBlock()) {
     parentBox = containingBlock();
     restrictedByLineClamp = !containingBlock()->style()->lineClamp().isNone();
   }
 
   if (hasOverflowClip() && !restrictedByLineClamp) {
-    // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
-    // This will prevent us from revealing text hidden by the slider in Safari RSS.
+    // Don't scroll to reveal an overflow layer that is restricted by the
+    // -webkit-line-clamp property. This will prevent us from revealing text
+    // hidden by the slider in Safari RSS.
+    // TODO(eae): We probably don't need this any more as we don't share any
+    //            code with the Safari RSS reeder.
     newRect = getScrollableArea()->scrollIntoView(rectToScroll, alignX, alignY,
                                                   scrollType);
     if (newRect.isEmpty())
       return;
   } else if (!parentBox && canBeProgramaticallyScrolled()) {
     if (FrameView* frameView = this->frameView()) {
       HTMLFrameOwnerElement* ownerElement = document().localOwner();
       if (!isDisallowedAutoscroll(ownerElement, frameView)) {
         if (makeVisibleInVisualViewport) {
           frameView->getScrollableArea()->scrollIntoView(rectToScroll, alignX,
@@ skipping 45 matching lines @@
   quads.append(localToAbsoluteQuad(FloatRect(
       0, 0, m_frameRect.width().toFloat(), m_frameRect.height().toFloat())));
 }
 
 FloatRect LayoutBox::localBoundingBoxRectForAccessibility() const {
   return FloatRect(0, 0, m_frameRect.width().toFloat(),
                    m_frameRect.height().toFloat());
 }
 
 void LayoutBox::updateLayerTransformAfterLayout() {
-  // Transform-origin depends on box size, so we need to update the layer transform after layout.
+  // Transform-origin depends on box size, so we need to update the layer
+  // transform after layout.
   if (hasLayer())
     layer()->updateTransformationMatrix();
 }
 
 LayoutUnit LayoutBox::constrainLogicalWidthByMinMax(LayoutUnit logicalWidth,
                                                     LayoutUnit availableWidth,
                                                     LayoutBlock* cb) const {
   const ComputedStyle& styleToUse = styleRef();
   if (!styleToUse.logicalMaxWidth().isMaxSizeNone())
     logicalWidth =
@@ skipping 16 matching lines @@
       logicalHeight = std::min(logicalHeight, maxH);
   }
   return std::max(logicalHeight, computeLogicalHeightUsing(
                                      MinSize, styleToUse.logicalMinHeight(),
                                      intrinsicContentHeight));
 }
 
 LayoutUnit LayoutBox::constrainContentBoxLogicalHeightByMinMax(
     LayoutUnit logicalHeight,
     LayoutUnit intrinsicContentHeight) const {
-  // If the min/max height and logical height are both percentages we take advantage of already knowing the current resolved percentage height
+  // If the min/max height and logical height are both percentages we take
+  // advantage of already knowing the current resolved percentage height
   // to avoid recursing up through our containing blocks again to determine it.
   const ComputedStyle& styleToUse = styleRef();
   if (!styleToUse.logicalMaxHeight().isMaxSizeNone()) {
     if (styleToUse.logicalMaxHeight().type() == Percent &&
         styleToUse.logicalHeight().type() == Percent) {
       LayoutUnit availableLogicalHeight(
           logicalHeight / styleToUse.logicalHeight().value() * 100);
       logicalHeight =
           std::min(logicalHeight, valueForLength(styleToUse.logicalMaxHeight(),
                                                  availableLogicalHeight));
@@ skipping 87 matching lines @@
         // If neither the image nor the color are opaque then skip this layer.
         if (!layerKnownOpaque)
           continue;
       }
       EFillBox currentClip = cur->clip();
       // Restrict clip if attachment is local.
       if (currentClip == BorderFillBox &&
           cur->attachment() == LocalBackgroundAttachment)
         currentClip = PaddingFillBox;
 
-      // If we're asking for the clip rect, a content-box clipped fill layer can be scrolled
-      // into the padding box of the overflow container.
+      // If we're asking for the clip rect, a content-box clipped fill layer can
+      // be scrolled into the padding box of the overflow container.
       if (rectType == BackgroundClipRect && currentClip == ContentFillBox &&
           cur->attachment() == LocalBackgroundAttachment) {
         currentClip = PaddingFillBox;
       }
 
       backgroundBox = enclosingFillBox(backgroundBox, currentClip);
     } while (current);
   }
   switch (backgroundBox) {
     case BorderFillBox:
@@ skipping 220 matching lines @@
 }
 
 void LayoutBox::middleClickAutoscroll(const IntPoint& sourcePoint) {
   LocalFrame* frame = this->frame();
   if (!frame)
     return;
 
   IntPoint lastKnownMousePosition =
       frame->eventHandler().lastKnownMousePosition();
 
-  // We need to check if the last known mouse position is out of the window. When the mouse is out of the window, the position is incoherent
+  // We need to check if the last known mouse position is out of the window.
+  // When the mouse is out of the window, the position is incoherent
   static IntPoint previousMousePosition;
   if (lastKnownMousePosition.x() < 0 || lastKnownMousePosition.y() < 0)
     lastKnownMousePosition = previousMousePosition;
   else
     previousMousePosition = lastKnownMousePosition;
 
   IntSize delta = lastKnownMousePosition - sourcePoint;
 
   if (abs(delta.width()) <=
-      AutoscrollController::
-          noMiddleClickAutoscrollRadius)  // at the center we let the space for the icon
+      AutoscrollController::noMiddleClickAutoscrollRadius)  // at the center we

[ikilpatrick, 2016/10/04 16:39:02]

icky.

+                                                            // let the space for
+                                                            // the icon
     delta.setWidth(0);
   if (abs(delta.height()) <=
       AutoscrollController::noMiddleClickAutoscrollRadius)
     delta.setHeight(0);
   scroll(ScrollByPixel, FloatSize(adjustedScrollDelta(delta)));
 }
 
 void LayoutBox::scrollByRecursively(const DoubleSize& delta,
                                     ScrollOffsetClamping clamp) {
   if (delta.isZero())
     return;
 
   bool restrictedByLineClamp = false;
   if (parent())
     restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
 
   if (hasOverflowClip() && !restrictedByLineClamp) {
     PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
     ASSERT(scrollableArea);
 
     DoubleSize newScrollOffset = scrollableArea->adjustedScrollOffset() + delta;
     scrollableArea->scrollToOffset(newScrollOffset, clamp);
 
-    // If this layer can't do the scroll we ask the next layer up that can scroll to try
+    // If this layer can't do the scroll we ask the next layer up that can
+    // scroll to try.
     DoubleSize remainingScrollOffset =
         newScrollOffset - scrollableArea->adjustedScrollOffset();
     if (!remainingScrollOffset.isZero() && parent()) {
       if (LayoutBox* scrollableBox = enclosingScrollableBox())
         scrollableBox->scrollByRecursively(remainingScrollOffset, clamp);
 
       LocalFrame* frame = this->frame();
       if (frame && frame->page())
         frame->page()->autoscrollController().updateAutoscrollLayoutObject();
     }
   } else if (view()->frameView()) {
-    // If we are here, we were called on a layoutObject that can be programmatically scrolled, but doesn't
-    // have an overflow clip. Which means that it is a document node that can be scrolled.
+    // If we are here, we were called on a layoutObject that can be
+    // programmatically scrolled, but doesn't have an overflow clip. Which means
+    // that it is a document node that can be scrolled.
     // FIXME: Pass in DoubleSize. crbug.com/414283.
     view()->frameView()->scrollBy(flooredIntSize(delta), UserScroll);
 
-    // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement?
+    // FIXME: If we didn't scroll the whole way, do we want to try looking at
+    // the frames ownerElement?
     // https://bugs.webkit.org/show_bug.cgi?id=28237
   }
 }
 
 bool LayoutBox::needsPreferredWidthsRecalculation() const {
   return style()->paddingStart().isPercentOrCalc() ||
          style()->paddingEnd().isPercentOrCalc();
 }
 
 IntSize LayoutBox::originAdjustmentForScrollbars() const {
@@ skipping 39 matching lines @@
     return true;
 
   if (applyOverflowClip == ApplyNonScrollOverflowClip)
     return true;
 
   if (hasOverflowClip()) {
     LayoutSize offset = LayoutSize(-scrolledContentOffset());
     rect.move(offset);
   }
 
-  // This won't work fully correctly for fixed-position elements, who should receive CSS clip but for whom the current object
-  // is not in the containing block chain.
+  // This won't work fully correctly for fixed-position elements, who should
+  // receive CSS clip but for whom the current object is not in the containing
+  // block chain.
   LayoutRect clipRect = clippingRect();
 
   bool doesIntersect;
   if (visualRectFlags & EdgeInclusive) {
     doesIntersect = rect.inclusiveIntersect(clipRect);
   } else {
     rect.intersect(clipRect);
     doesIntersect = !rect.isEmpty();
   }
 
@@ skipping 70 matching lines @@
 LayoutUnit LayoutBox::overrideLogicalContentWidth() const {
   ASSERT(hasOverrideLogicalContentWidth());
   return m_rareData->m_overrideLogicalContentWidth;
 }
 
 LayoutUnit LayoutBox::overrideLogicalContentHeight() const {
   ASSERT(hasOverrideLogicalContentHeight());
   return m_rareData->m_overrideLogicalContentHeight;
 }
 
-// TODO (lajava) Now that we have implemented these functions based on physical direction, we'd rather remove the logical ones.
+// TODO (lajava) Now that we have implemented these functions based on physical
+// direction, we'd rather remove the logical ones.
 LayoutUnit LayoutBox::overrideContainingBlockContentLogicalWidth() const {
   DCHECK(hasOverrideContainingBlockLogicalWidth());
   return m_rareData->m_overrideContainingBlockContentLogicalWidth;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 LayoutUnit LayoutBox::overrideContainingBlockContentLogicalHeight() const {
   DCHECK(hasOverrideContainingBlockLogicalHeight());
   return m_rareData->m_overrideContainingBlockContentLogicalHeight;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 bool LayoutBox::hasOverrideContainingBlockLogicalWidth() const {
   return m_rareData &&
          m_rareData->m_hasOverrideContainingBlockContentLogicalWidth;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 bool LayoutBox::hasOverrideContainingBlockLogicalHeight() const {
   return m_rareData &&
          m_rareData->m_hasOverrideContainingBlockContentLogicalHeight;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 void LayoutBox::setOverrideContainingBlockContentLogicalWidth(
     LayoutUnit logicalWidth) {
   DCHECK_GE(logicalWidth, LayoutUnit(-1));
   ensureRareData().m_overrideContainingBlockContentLogicalWidth = logicalWidth;
   ensureRareData().m_hasOverrideContainingBlockContentLogicalWidth = true;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 void LayoutBox::setOverrideContainingBlockContentLogicalHeight(
     LayoutUnit logicalHeight) {
   DCHECK_GE(logicalHeight, LayoutUnit(-1));
   ensureRareData().m_overrideContainingBlockContentLogicalHeight =
       logicalHeight;
   ensureRareData().m_hasOverrideContainingBlockContentLogicalHeight = true;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 void LayoutBox::clearContainingBlockOverrideSize() {
   if (!m_rareData)
     return;
   ensureRareData().m_hasOverrideContainingBlockContentLogicalWidth = false;
   ensureRareData().m_hasOverrideContainingBlockContentLogicalHeight = false;
 }
 
-// TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
+// TODO (lajava) Shouldn't we implement these functions based on physical
+// direction ?.
 void LayoutBox::clearOverrideContainingBlockContentLogicalHeight() {
   if (!m_rareData)
     return;
   ensureRareData().m_hasOverrideContainingBlockContentLogicalHeight = false;
 }
 
 LayoutUnit LayoutBox::extraInlineOffset() const {
   return gExtraInlineOffsetMap ? gExtraInlineOffsetMap->get(this)
                                : LayoutUnit();
 }
@@ skipping 179 matching lines @@
     return true;
   }
 
   if (!style()->backgroundLayers().image() ||
       style()->backgroundLayers().next()) {
     paintedExtent = backgroundRect;
     return true;
   }
 
   BackgroundImageGeometry geometry;
-  // TODO(jchaffraix): This function should be rethought as it's called during and outside
-  // of the paint phase. Potentially returning different results at different phases.
+  // TODO(jchaffraix): This function should be rethought as it's called during
+  // and outside of the paint phase. Potentially returning different results at
+  // different phases.
   geometry.calculate(*this, nullptr, GlobalPaintNormalPhase,
                      style()->backgroundLayers(), backgroundRect);
   if (geometry.hasNonLocalGeometry())
     return false;
   paintedExtent = LayoutRect(geometry.destRect());
   return true;
 }
 
 bool LayoutBox::backgroundIsKnownToBeOpaqueInRect(
     const LayoutRect& localRect) const {
@@ skipping 55 matching lines @@
       continue;
     LayoutBox* childBox = toLayoutBox(child);
     if (!isCandidateForOpaquenessTest(*childBox))
       continue;
     LayoutPoint childLocation = childBox->location();
     if (childBox->isInFlowPositioned())
       childLocation.move(childBox->offsetForInFlowPosition());
     LayoutRect childLocalRect = localRect;
     childLocalRect.moveBy(-childLocation);
     if (childLocalRect.y() < 0 || childLocalRect.x() < 0) {
-      // If there is unobscured area above/left of a static positioned box then the rect is probably not covered.
+      // If there is unobscured area above/left of a static positioned box then
+      // the rect is probably not covered.
       if (!childBox->isPositioned())
         return false;
       continue;
     }
     if (childLocalRect.maxY() > childBox->size().height() ||
         childLocalRect.maxX() > childBox->size().width())
       continue;
     if (childBox->backgroundIsKnownToBeOpaqueInRect(childLocalRect))
       return true;
     if (childBox->foregroundIsKnownToBeOpaqueInRect(childLocalRect,
@@ skipping 22 matching lines @@
   return foregroundIsKnownToBeOpaqueInRect(backgroundRect,
                                            backgroundObscurationTestMaxDepth);
 }
 
 void LayoutBox::paintMask(const PaintInfo& paintInfo,
                           const LayoutPoint& paintOffset) const {
   BoxPainter(*this).paintMask(paintInfo, paintOffset);
 }
 
 void LayoutBox::imageChanged(WrappedImagePtr image, const IntRect*) {
-  // TODO(chrishtr): support PaintInvalidationDelayedFull for animated border images.
+  // TODO(chrishtr): support PaintInvalidationDelayedFull for animated border
+  // images.
   if ((styleRef().borderImage().image() &&
        styleRef().borderImage().image()->data() == image) ||
       (styleRef().maskBoxImage().image() &&
        styleRef().maskBoxImage().image()->data() == image) ||
       (styleRef().boxReflect() && styleRef().boxReflect()->mask().image() &&
        styleRef().boxReflect()->mask().image()->data() == image)) {
     setShouldDoFullPaintInvalidation();
   } else {
     for (const FillLayer* layer = &styleRef().maskLayers(); layer;
          layer = layer->next()) {
@@ skipping 31 matching lines @@
       info.markShapeAsDirty();
       markShapeOutsideDependentsForLayout();
     }
   }
 }
 
 ResourcePriority LayoutBox::computeResourcePriority() const {
   LayoutRect viewBounds = viewRect();
   LayoutRect objectBounds = LayoutRect(absoluteContentBox());
 
-  // The object bounds might be empty right now, so intersects will fail since it doesn't deal
-  // with empty rects. Use LayoutRect::contains in that case.
+  // The object bounds might be empty right now, so intersects will fail since
+  // it doesn't deal with empty rects. Use LayoutRect::contains in that case.
   bool isVisible;
   if (!objectBounds.isEmpty())
     isVisible = viewBounds.intersects(objectBounds);
   else
     isVisible = viewBounds.contains(objectBounds);
 
   LayoutRect screenRect;
   if (!objectBounds.isEmpty()) {
     screenRect = viewBounds;
     screenRect.intersect(objectBounds);
@@ skipping 127 matching lines @@
     const LayoutBlockFlow* cb) const {
   LayoutUnit logicalTopPosition = logicalTop();
   LayoutUnit startOffsetForContent = cb->startOffsetForContent();
   LayoutUnit endOffsetForContent = cb->endOffsetForContent();
   LayoutUnit logicalHeight = cb->logicalHeightForChild(*this);
   LayoutUnit startOffsetForLine = cb->startOffsetForLine(
       logicalTopPosition, DoNotIndentText, logicalHeight);
   LayoutUnit endOffsetForLine =
       cb->endOffsetForLine(logicalTopPosition, DoNotIndentText, logicalHeight);
 
-  // If there aren't any floats constraining us then allow the margins to shrink/expand the width as much as they want.
+  // If there aren't any floats constraining us then allow the margins to
+  // shrink/expand the width as much as they want.
   if (startOffsetForContent == startOffsetForLine &&
       endOffsetForContent == endOffsetForLine)
     return cb->availableLogicalWidthForLine(logicalTopPosition, DoNotIndentText,
                                             logicalHeight) -
            childMarginStart - childMarginEnd;
 
   LayoutUnit width = cb->availableLogicalWidthForLine(
                          logicalTopPosition, DoNotIndentText, logicalHeight) -
                      std::max(LayoutUnit(), childMarginStart) -
                      std::max(LayoutUnit(), childMarginEnd);
-  // We need to see if margins on either the start side or the end side can contain the floats in question. If they can,
-  // then just using the line width is inaccurate. In the case where a float completely fits, we don't need to use the line
-  // offset at all, but can instead push all the way to the content edge of the containing block. In the case where the float
-  // doesn't fit, we can use the line offset, but we need to grow it by the margin to reflect the fact that the margin was
-  // "consumed" by the float. Negative margins aren't consumed by the float, and so we ignore them.
+  // We need to see if margins on either the start side or the end side can
+  // contain the floats in question. If they can, then just using the line width
+  // is inaccurate. In the case where a float completely fits, we don't need to
+  // use the line offset at all, but can instead push all the way to the content
+  // edge of the containing block. In the case where the float doesn't fit, we
+  // can use the line offset, but we need to grow it by the margin to reflect
+  // the fact that the margin was "consumed" by the float. Negative margins
+  // aren't consumed by the float, and so we ignore them.
   width += portionOfMarginNotConsumedByFloat(
       childMarginStart, startOffsetForContent, startOffsetForLine);
   width += portionOfMarginNotConsumedByFloat(
       childMarginEnd, endOffsetForContent, endOffsetForLine);
   return width;
 }
 
 LayoutUnit LayoutBox::containingBlockLogicalHeightForGetComputedStyle() const {
   if (hasOverrideContainingBlockLogicalHeight())
     return overrideContainingBlockContentLogicalHeight();
@@ skipping 40 matching lines @@
   if (hasOverrideContainingBlockLogicalHeight())
     return overrideContainingBlockContentLogicalHeight();
 
   LayoutBlock* cb = containingBlock();
   if (cb->hasOverrideLogicalContentHeight())
     return cb->overrideLogicalContentHeight();
 
   const ComputedStyle& containingBlockStyle = cb->styleRef();
   Length logicalHeightLength = containingBlockStyle.logicalHeight();
 
-  // FIXME: For now just support fixed heights.  Eventually should support percentage heights as well.
+  // FIXME: For now just support fixed heights.  Eventually should support
+  // percentage heights as well.
   if (!logicalHeightLength.isFixed()) {
     LayoutUnit fillFallbackExtent =
         LayoutUnit(containingBlockStyle.isHorizontalWritingMode()
                        ? view()->frameView()->visibleContentSize().height()
                        : view()->frameView()->visibleContentSize().width());
     LayoutUnit fillAvailableExtent =
         containingBlock()->availableLogicalHeight(ExcludeMarginBorderPadding);
     if (fillAvailableExtent == -1)
       return fillFallbackExtent;
     return std::min(fillAvailableExtent, fillFallbackExtent);
   }
 
   // Use the content box logical height as specified by the style.
   return cb->adjustContentBoxLogicalHeightForBoxSizing(
       LayoutUnit(logicalHeightLength.value()));
 }
 
 void LayoutBox::mapLocalToAncestor(const LayoutBoxModelObject* ancestor,
                                    TransformState& transformState,
                                    MapCoordinatesFlags mode) const {
   bool isFixedPos = style()->position() == FixedPosition;
 
-  // If this box has a transform or contains paint, it acts as a fixed position container for fixed descendants,
-  // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
+  // If this box has a transform or contains paint, it acts as a fixed position
+  // container for fixed descendants, and may itself also be fixed position. So
+  // propagate 'fixed' up only if this box is fixed position.
   if (style()->canContainFixedPositionObjects() && !isFixedPos)
     mode &= ~IsFixed;
   else if (isFixedPos)
     mode |= IsFixed;
 
   LayoutBoxModelObject::mapLocalToAncestor(ancestor, transformState, mode);
 }
 
 void LayoutBox::mapAncestorToLocal(const LayoutBoxModelObject* ancestor,
                                    TransformState& transformState,
                                    MapCoordinatesFlags mode) const {
   if (this == ancestor)
     return;
 
   bool isFixedPos = style()->position() == FixedPosition;
 
-  // If this box has a transform or contains paint, it acts as a fixed position container for fixed descendants,
-  // and may itself also be fixed position. So propagate 'fixed' up only if this box is fixed position.
+  // If this box has a transform or contains paint, it acts as a fixed position
+  // container for fixed descendants, and may itself also be fixed position. So
+  // propagate 'fixed' up only if this box is fixed position.
   if (style()->canContainFixedPositionObjects() && !isFixedPos)
     mode &= ~IsFixed;
   else if (isFixedPos)
     mode |= IsFixed;
 
   LayoutBoxModelObject::mapAncestorToLocal(ancestor, transformState, mode);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o) const {
   ASSERT(o == container());
@@ skipping 28 matching lines @@
     }
   }
 }
 
 void LayoutBox::positionLineBox(InlineBox* box) {
   if (isOutOfFlowPositioned()) {
     // Cache the x position only if we were an INLINE type originally.
     bool originallyInline = style()->isOriginalDisplayInlineType();
     if (originallyInline) {
       // The value is cached in the xPos of the box.  We only need this value if
-      // our object was inline originally, since otherwise it would have ended up underneath
-      // the inlines.
+      // our object was inline originally, since otherwise it would have ended
+      // up underneath the inlines.
       RootInlineBox& root = box->root();
       root.block().setStaticInlinePositionForChild(LineLayoutBox(this),
                                                    box->logicalLeft());
     } else {
-      // Our object was a block originally, so we make our normal flow position be
-      // just below the line box (as though all the inlines that came before us got
-      // wrapped in an anonymous block, which is what would have happened had we been
-      // in flow).  This value was cached in the y() of the box.
+      // Our object was a block originally, so we make our normal flow position
+      // be just below the line box (as though all the inlines that came before
+      // us got wrapped in an anonymous block, which is what would have happened
+      // had we been in flow). This value was cached in the y() of the box.
       layer()->setStaticBlockPosition(box->logicalTop());
     }
 
     if (container()->isLayoutInline())
       moveWithEdgeOfInlineContainerIfNecessary(box->isHorizontal());
 
     // Nuke the box.
     box->remove(DontMarkLineBoxes);
     box->destroy();
   } else if (isAtomicInlineLevel()) {
-    // FIXME: the call to roundedLayoutPoint() below is temporary and should be removed once
-    // the transition to LayoutUnit-based types is complete (crbug.com/321237)
+    // FIXME: the call to roundedLayoutPoint() below is temporary and should be
+    // removed once the transition to LayoutUnit-based types is complete
+    // (crbug.com/321237).
     setLocationAndUpdateOverflowControlsIfNeeded(box->topLeft());
     setInlineBoxWrapper(box);
   }
 }
 
 void LayoutBox::moveWithEdgeOfInlineContainerIfNecessary(bool isHorizontal) {
   ASSERT(isOutOfFlowPositioned() && container()->isLayoutInline() &&
          container()->isInFlowPositioned());
-  // If this object is inside a relative positioned inline and its inline position is an explicit offset from the edge of its container
-  // then it will need to move if its inline container has changed width. We do not track if the width has changed
-  // but if we are here then we are laying out lines inside it, so it probably has - mark our object for layout so that it can
+  // If this object is inside a relative positioned inline and its inline
+  // position is an explicit offset from the edge of its container then it will
+  // need to move if its inline container has changed width. We do not track if
+  // the width has changed but if we are here then we are laying out lines
+  // inside it, so it probably has - mark our object for layout so that it can
   // move to the new offset created by the new width.
   if (!normalChildNeedsLayout() &&
       !style()->hasStaticInlinePosition(isHorizontal))
     setChildNeedsLayout(MarkOnlyThis);
 }
 
 void LayoutBox::deleteLineBoxWrapper() {
   if (m_inlineBoxWrapper) {
     if (!documentBeingDestroyed())
       m_inlineBoxWrapper->remove();
     m_inlineBoxWrapper->destroy();
     m_inlineBoxWrapper = nullptr;
   }
 }
 
 void LayoutBox::setSpannerPlaceholder(
     LayoutMultiColumnSpannerPlaceholder& placeholder) {
-  RELEASE_ASSERT(
-      !m_rareData ||
-      !m_rareData
-           ->m_spannerPlaceholder);  // not expected to change directly from one spanner to another.
+  RELEASE_ASSERT(!m_rareData ||
+                 !m_rareData->m_spannerPlaceholder);  // not expected to change

[ikilpatrick, 2016/10/04 16:39:02]

more icky.

+                                                      // directly from one
+                                                      // spanner to another.
   ensureRareData().m_spannerPlaceholder = &placeholder;
 }
 
 void LayoutBox::clearSpannerPlaceholder() {
   if (!m_rareData)
     return;
   m_rareData->m_spannerPlaceholder = nullptr;
 }
 
 void LayoutBox::setPaginationStrut(LayoutUnit strut) {
   if (!strut && !m_rareData)
     return;
   ensureRareData().m_paginationStrut = strut;
 }
 
 bool LayoutBox::isBreakBetweenControllable(EBreak breakValue) const {
   if (breakValue == BreakAuto)
     return true;
-  // We currently only support non-auto break-before and break-after values on in-flow block
-  // level elements, which is the minimum requirement according to the spec.
+  // We currently only support non-auto break-before and break-after values on
+  // in-flow block level elements, which is the minimum requirement according to
+  // the spec.
   if (isInline() || isFloatingOrOutOfFlowPositioned())
     return false;
   const LayoutBlock* curr = containingBlock();
   if (!curr || !curr->isLayoutBlockFlow())
     return false;
   const LayoutView* layoutView = view();
   bool viewIsPaginated = layoutView->fragmentationContext();
   if (!viewIsPaginated && !flowThreadContainingBlock())
     return false;
   while (curr) {
     if (curr == layoutView)
       return viewIsPaginated && breakValue != BreakColumn &&
              breakValue != BreakAvoidColumn;
     if (curr->isLayoutFlowThread()) {
       if (breakValue ==
           BreakAvoid)  // Valid in any kind of fragmentation context.
         return true;
       bool isMulticolValue =
           breakValue == BreakColumn || breakValue == BreakAvoidColumn;
       if (toLayoutFlowThread(curr)->isLayoutPagedFlowThread())
         return !isMulticolValue;
       if (isMulticolValue)
         return true;
-      // If this is a flow thread for a multicol container, and we have a break value for
-      // paged, we need to keep looking.
+      // If this is a flow thread for a multicol container, and we have a break
+      // value for paged, we need to keep looking.
     }
     if (curr->isFloatingOrOutOfFlowPositioned())
       return false;
     curr = curr->containingBlock();
   }
   ASSERT_NOT_REACHED();
   return false;
 }
 
 bool LayoutBox::isBreakInsideControllable(EBreak breakValue) const {
   ASSERT(!isForcedFragmentainerBreakValue(breakValue));
   if (breakValue == BreakAuto)
     return true;
   // First check multicol.
   const LayoutFlowThread* flowThread = flowThreadContainingBlock();
   // 'avoid-column' is only valid in a multicol context.
   if (breakValue == BreakAvoidColumn)
     return flowThread && !flowThread->isLayoutPagedFlowThread();
   // 'avoid' is valid in any kind of fragmentation context.
   if (breakValue == BreakAvoid && flowThread)
     return true;
   ASSERT(breakValue == BreakAvoidPage || breakValue == BreakAvoid);
   if (view()->fragmentationContext())
     return true;  // The view is paginated, probably because we're printing.
   if (!flowThread)
     return false;  // We're not inside any pagination context
-  // We're inside a flow thread. We need to be contained by a flow thread for paged overflow in
-  // order for pagination values to be valid, though.
+  // We're inside a flow thread. We need to be contained by a flow thread for
+  // paged overflow in order for pagination values to be valid, though.
   for (const LayoutBlock* ancestor = flowThread; ancestor;
        ancestor = ancestor->containingBlock()) {
     if (ancestor->isLayoutFlowThread() &&
         toLayoutFlowThread(ancestor)->isLayoutPagedFlowThread())
       return true;
   }
   return false;
 }
 
 EBreak LayoutBox::breakAfter() const {
@@ skipping 10 matching lines @@
   return BreakAuto;
 }
 
 EBreak LayoutBox::breakInside() const {
   EBreak breakValue = style()->breakInside();
   if (breakValue == BreakAuto || isBreakInsideControllable(breakValue))
     return breakValue;
   return BreakAuto;
 }
 
-// At a class A break point [1], the break value with the highest precedence wins. If the two values
-// have the same precedence (e.g. "left" and "right"), the value specified on a latter object wins.
+// At a class A break point [1], the break value with the highest precedence
+// wins. If the two values have the same precedence (e.g. "left" and "right"),
+// the value specified on a latter object wins.
 //
 // [1] https://drafts.csswg.org/css-break/#possible-breaks
 static inline int fragmentainerBreakPrecedence(EBreak breakValue) {
   // "auto" has the lowest priority.
   // "avoid*" values win over "auto".
   // "avoid-page" wins over "avoid-column".
   // "avoid" wins over "avoid-page".
   // Forced break values win over "avoid".
   // Any forced page break value wins over "column" forced break.
-  // More specific break values (left, right, recto, verso) wins over generic "page" values.
+  // More specific break values (left, right, recto, verso) wins over generic
+  // "page" values.
 
   switch (breakValue) {
     default:
       ASSERT_NOT_REACHED();
     // fall-through
     case BreakAuto:
       return 0;
     case BreakAvoidColumn:
       return 1;
     case BreakAvoidPage:
@@ skipping 21 matching lines @@
 }
 
 EBreak LayoutBox::classABreakPointValue(EBreak previousBreakAfterValue) const {
   // First assert that we're at a class A break point.
   ASSERT(isBreakBetweenControllable(previousBreakAfterValue));
 
   return joinFragmentainerBreakValues(previousBreakAfterValue, breakBefore());
 }
 
 bool LayoutBox::needsForcedBreakBefore(EBreak previousBreakAfterValue) const {
-  // Forced break values are only honored when specified on in-flow objects, but floats and
-  // out-of-flow positioned objects may be affected by a break-after value of the previous
-  // in-flow object, even though we're not at a class A break point.
+  // Forced break values are only honored when specified on in-flow objects, but
+  // floats and out-of-flow positioned objects may be affected by a break-after
+  // value of the previous in-flow object, even though we're not at a class A
+  // break point.
   EBreak breakValue = isFloatingOrOutOfFlowPositioned()
                           ? previousBreakAfterValue
                           : classABreakPointValue(previousBreakAfterValue);
   return isForcedFragmentainerBreakValue(breakValue);
 }
 
 bool LayoutBox::paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
-  // In case scrollbars got repositioned (which will typically happen if the box got
-  // resized), we cannot skip invalidation.
+  // In case scrollbars got repositioned (which will typically happen if the box
+  // got resized), we cannot skip invalidation.
   if (hasNonCompositedScrollbars())
     return false;
 
   // Cannot skip paint invalidation if the box has real things to paint.
   if (getSelectionState() != SelectionNone || hasBoxDecorationBackground() ||
       styleRef().hasBoxDecorations() || styleRef().hasVisualOverflowingEffect())
     return false;
 
-  // If the box has clip, we need issue a paint invalidation to cover the changed part of
-  // children because of change of clip when the box got resized. In theory the children
-  // should invalidate themselves when ancestor clip changes, but for now this is missing
-  // and ensuring it may hurt performance.
-  // TODO(wangxianzhu): Paint invalidation for clip change will be different in spv2.
+  // If the box has clip, we need issue a paint invalidation to cover the
+  // changed part of children because of change of clip when the box got
+  // resized. In theory the children should invalidate themselves when ancestor
+  // clip changes, but for now this is missing and ensuring it may hurt
+  // performance.
+  // TODO(wangxianzhu): Paint invalidation for clip change will be different in
+  //                    spv2.
   if (hasClipRelatedProperty() || hasControlClip())
     return false;
 
   return true;
 }
 
 LayoutRect LayoutBox::localOverflowRectForPaintInvalidation() const {
   if (style()->visibility() != EVisibility::Visible)
     return LayoutRect();
 
   return selfVisualOverflowRect();
 }
 
 void LayoutBox::inflateVisualRectForFilterUnderContainer(
     LayoutRect& rect,
     const LayoutObject& container,
     const LayoutBoxModelObject* ancestorToStopAt) const {
-  // Apply visual overflow caused by reflections and filters defined on objects between this object
-  // and container (not included) or ancestorToStopAt (included).
+  // Apply visual overflow caused by reflections and filters defined on objects
+  // between this object and container (not included) or ancestorToStopAt
+  // (included).
   LayoutSize offsetFromContainer = this->offsetFromContainer(&container);
   rect.move(offsetFromContainer);
   for (LayoutObject* parent = this->parent(); parent && parent != container;
        parent = parent->parent()) {
     if (parent->isBox()) {
-      // Convert rect into coordinate space of parent to apply parent's reflection and filter.
+      // Convert rect into coordinate space of parent to apply parent's
+      // reflection and filter.
       LayoutSize parentOffset = parent->offsetFromAncestorContainer(&container);
       rect.move(-parentOffset);
       toLayoutBox(parent)->inflateVisualRectForFilter(rect);
       rect.move(parentOffset);
     }
     if (parent == ancestorToStopAt)
       break;
   }
   rect.move(-offsetFromContainer);
 }
 
 bool LayoutBox::mapToVisualRectInAncestorSpace(
     const LayoutBoxModelObject* ancestor,
     LayoutRect& rect,
     VisualRectFlags visualRectFlags) const {
   inflateVisualRectForFilter(rect);
 
   if (ancestor == this)
     return true;
 
   bool ancestorSkipped;
   bool filterSkipped;
   LayoutObject* container =
       this->container(ancestor, &ancestorSkipped, &filterSkipped);
   LayoutBox* tableRowContainer = nullptr;
   // Skip table row because cells and rows are in the same coordinate space
-  // (see below, however for more comments about when |ancestor| is the table row).
-  // The second and third conditionals below are to skip cases where content has display: table-row or display: table-cell but is not
-  // parented like a cell/row combo.
+  // (see below, however for more comments about when |ancestor| is the table
+  // row). The second and third conditionals below are to skip cases where
+  // content has display: table-row or display: table-cell but is not parented
+  // like a cell/row combo.
   if (container->isTableRow() && isTableCell() && parentBox() == container) {
     if (container != ancestor)
       container = container->parent();
     else
       tableRowContainer = toLayoutBox(container);
   }
   if (!container)
     return true;
 
   if (filterSkipped)
     inflateVisualRectForFilterUnderContainer(rect, *container, ancestor);
 
-  // We are now in our parent container's coordinate space.  Apply our transform to obtain a bounding box
-  // in the parent's coordinate space that encloses us.
+  // We are now in our parent container's coordinate space. Apply our transform
+  // to obtain a bounding box in the parent's coordinate space that encloses us.
   if (hasLayer() && layer()->transform()) {
-    // Use enclosingIntRect because we cannot properly compute pixel snapping for painted elements within
-    // the transform since we don't know the desired subpixel accumulation at this point, and the transform may
-    // include a scale.
+    // Use enclosingIntRect because we cannot properly compute pixel snapping
+    // for painted elements within the transform since we don't know the desired
+    // subpixel accumulation at this point, and the transform may include a
+    // scale.
     rect = LayoutRect(layer()->transform()->mapRect(enclosingIntRect(rect)));
   }
   LayoutPoint topLeft = rect.location();
   if (container->isBox()) {
     topLeft.moveBy(topLeftLocation(toLayoutBox(container)));
-    // If the row is the ancestor, however, add its offset back in. In effect, this passes from the joint <td> / <tr>
-    // coordinate space to the parent space, then back to <tr> / <td>.
+    // If the row is the ancestor, however, add its offset back in. In effect,
+    // this passes from the joint <td> / <tr> coordinate space to the parent
+    // space, then back to <tr> / <td>.
     if (tableRowContainer)
       topLeft.moveBy(
           -tableRowContainer->topLeftLocation(toLayoutBox(container)));
   } else if (container->isRuby()) {
-    // TODO(wkorman): Generalize Ruby specialization and/or document more clearly.
-    // See the accompanying specialization in LayoutInline::mapToVisualRectInAncestorSpace.
+    // TODO(wkorman): Generalize Ruby specialization and/or document more
+    // clearly. See the accompanying specialization in
+    // LayoutInline::mapToVisualRectInAncestorSpace.
     topLeft.moveBy(topLeftLocation());
   } else {
     topLeft.moveBy(location());
   }
 
   const ComputedStyle& styleToUse = styleRef();
   EPosition position = styleToUse.position();
   if (position == AbsolutePosition && container->isInFlowPositioned() &&
       container->isLayoutInline()) {
     topLeft +=
         toLayoutInline(container)->offsetForInFlowPositionedInline(*this);
   } else if (styleToUse.hasInFlowPosition() && layer()) {
-    // Apply the relative position offset when invalidating a rectangle.  The layer
-    // is translated, but the layout box isn't, so we need to do this to get the
-    // right dirty rect.  Since this is called from LayoutObject::setStyle, the relative position
-    // flag on the LayoutObject has been cleared, so use the one on the style().
+    // Apply the relative position offset when invalidating a rectangle. The
+    // layer is translated, but the layout box isn't, so we need to do this to
+    // get the right dirty rect.  Since this is called from
+    // LayoutObject::setStyle, the relative position flag on the LayoutObject
+    // has been cleared, so use the one on the style().
     topLeft += layer()->offsetForInFlowPosition();
   }
 
-  // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
-  // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
+  // FIXME: We ignore the lightweight clipping rect that controls use, since if
+  // |o| is in mid-layout, its controlClipRect will be wrong. For overflow clip
+  // we use the values cached by the layer.
   rect.setLocation(topLeft);
 
   if (container->isBox() &&
       !toLayoutBox(container)->mapScrollingContentsRectToBoxSpace(
           rect, container == ancestor ? ApplyNonScrollOverflowClip
                                       : ApplyOverflowClip,
           visualRectFlags))
     return false;
 
   if (ancestorSkipped) {
-    // If the ancestor is below the container, then we need to map the rect into ancestor's coordinates.
+    // If the ancestor is below the container, then we need to map the rect into
+    // ancestor's coordinates.
     LayoutSize containerOffset =
         ancestor->offsetFromAncestorContainer(container);
     rect.move(-containerOffset);
-    // If the ancestor is fixed, then the rect is already in its coordinates so doesn't need viewport-adjusting.
+    // If the ancestor is fixed, then the rect is already in its coordinates so
+    // doesn't need viewport-adjusting.
     if (ancestor->style()->position() != FixedPosition &&
         container->isLayoutView() && position == FixedPosition)
       toLayoutView(container)->adjustOffsetForFixedPosition(rect);
     return true;
   }
 
   if (container->isLayoutView())
     return toLayoutView(container)->mapToVisualRectInAncestorSpace(
         ancestor, rect, position == FixedPosition ? IsFixed : 0,
         visualRectFlags);
@@ skipping 73 matching lines @@
     computedValues.m_extent =
         overrideLogicalContentWidth() + borderAndPaddingLogicalWidth();
     return;
   }
 
   // FIXME: Account for writing-mode in flexible boxes.
   // https://bugs.webkit.org/show_bug.cgi?id=46418
   bool inVerticalBox = parent()->isDeprecatedFlexibleBox() &&
                        (parent()->style()->boxOrient() == VERTICAL);
   bool stretching = (parent()->style()->boxAlign() == BSTRETCH);
-  // TODO (lajava): Stretching is the only reason why we don't want the box to be treated as a replaced element, so we could perhaps
-  // refactor all this logic, not only for flex and grid since alignment is intended to be applied to any block.
+  // TODO (lajava): Stretching is the only reason why we don't want the box to
+  // be treated as a replaced element, so we could perhaps refactor all this
+  // logic, not only for flex and grid since alignment is intended to be applied
+  // to any block.
   bool treatAsReplaced = shouldComputeSizeAsReplaced() &&
                          (!inVerticalBox || !stretching) &&
                          (!isGridItem() || !hasStretchedLogicalWidth());
   const ComputedStyle& styleToUse = styleRef();
   Length logicalWidthLength = treatAsReplaced
                                   ? Length(computeReplacedLogicalWidth(), Fixed)
                                   : styleToUse.logicalWidth();
 
   LayoutBlock* cb = containingBlock();
   LayoutUnit containerLogicalWidth =
@@ skipping 60 matching lines @@
       computedValues.m_margins.m_start = newMargin;
     else
       computedValues.m_margins.m_end = newMargin;
   }
 
   if (styleToUse.textAutosizingMultiplier() != 1 &&
       styleToUse.marginStart().type() == Fixed) {
     Node* parentNode = generatingNode();
     if (parentNode &&
         (isHTMLOListElement(*parentNode) || isHTMLUListElement(*parentNode))) {
-      // Make sure the markers in a list are properly positioned (i.e. not chopped off) when autosized.
+      // Make sure the markers in a list are properly positioned (i.e. not
+      // chopped off) when autosized.
       const float adjustedMargin =
           (1 - 1.0 / styleToUse.textAutosizingMultiplier()) *
           getMaxWidthListMarker(this);
       bool hasInvertedDirection = cb->style()->isLeftToRightDirection() !=
                                   style()->isLeftToRightDirection();
       if (hasInvertedDirection)
         computedValues.m_margins.m_end += adjustedMargin;
       else
         computedValues.m_margins.m_start += adjustedMargin;
     }
@@ skipping 55 matching lines @@
 LayoutUnit LayoutBox::computeLogicalWidthUsing(SizeType widthType,
                                                const Length& logicalWidth,
                                                LayoutUnit availableLogicalWidth,
                                                const LayoutBlock* cb) const {
   ASSERT(widthType == MinSize || widthType == MainOrPreferredSize ||
          !logicalWidth.isAuto());
   if (widthType == MinSize && logicalWidth.isAuto())
     return adjustBorderBoxLogicalWidthForBoxSizing(0);
 
   if (!logicalWidth.isIntrinsicOrAuto()) {
-    // FIXME: If the containing block flow is perpendicular to our direction we need to use the available logical height instead.
+    // FIXME: If the containing block flow is perpendicular to our direction we
+    // need to use the available logical height instead.
     return adjustBorderBoxLogicalWidthForBoxSizing(
         valueForLength(logicalWidth, availableLogicalWidth));
   }
 
   if (logicalWidth.isIntrinsic())
     return computeIntrinsicLogicalWidthUsing(
         logicalWidth, availableLogicalWidth, borderAndPaddingLogicalWidth());
 
   LayoutUnit marginStart;
   LayoutUnit marginEnd;
   LayoutUnit logicalWidthResult =
       fillAvailableMeasure(availableLogicalWidth, marginStart, marginEnd);
 
   if (shrinkToAvoidFloats() && cb->isLayoutBlockFlow() &&
       toLayoutBlockFlow(cb)->containsFloats())
     logicalWidthResult = std::min(
         logicalWidthResult, shrinkLogicalWidthToAvoidFloats(
                                 marginStart, marginEnd, toLayoutBlockFlow(cb)));
 
   if (widthType == MainOrPreferredSize &&
       sizesLogicalWidthToFitContent(logicalWidth))
     return std::max(minPreferredLogicalWidth(),
                     std::min(maxPreferredLogicalWidth(), logicalWidthResult));
   return logicalWidthResult;
 }
 
 bool LayoutBox::columnFlexItemHasStretchAlignment() const {
-  // auto margins mean we don't stretch. Note that this function will only be used for
-  // widths, so we don't have to check marginBefore/marginAfter.
+  // auto margins mean we don't stretch. Note that this function will only be
+  // used for widths, so we don't have to check marginBefore/marginAfter.
   const auto& parentStyle = parent()->styleRef();
   DCHECK(parentStyle.isColumnFlexDirection());
   if (styleRef().marginStart().isAuto() || styleRef().marginEnd().isAuto())
     return false;
   return styleRef()
              .resolvedAlignSelf(
                  containingBlock()->selfAlignmentNormalBehavior(),
                  isAnonymous() ? &parentStyle : nullptr)
              .position() == ItemPositionStretch;
 }
 
 bool LayoutBox::isStretchingColumnFlexItem() const {
   LayoutObject* parent = this->parent();
   if (parent->isDeprecatedFlexibleBox() &&
       parent->style()->boxOrient() == VERTICAL &&
       parent->style()->boxAlign() == BSTRETCH)
     return true;
 
-  // We don't stretch multiline flexboxes because they need to apply line spacing (align-content) first.
+  // We don't stretch multiline flexboxes because they need to apply line
+  // spacing (align-content) first.
   if (parent->isFlexibleBox() && parent->style()->flexWrap() == FlexNoWrap &&
       parent->style()->isColumnFlexDirection() &&
       columnFlexItemHasStretchAlignment())
     return true;
   return false;
 }
 
-// TODO (lajava) Can/Should we move this inside specific layout classes (flex. grid)? Can we refactor columnFlexItemHasStretchAlignment logic?
+// TODO (lajava) Can/Should we move this inside specific layout classes (flex.
+// grid)? Can we refactor columnFlexItemHasStretchAlignment logic?
 bool LayoutBox::hasStretchedLogicalWidth() const {
   const ComputedStyle& style = styleRef();
   if (!style.logicalWidth().isAuto() || style.marginStart().isAuto() ||
       style.marginEnd().isAuto())
     return false;
   LayoutBlock* cb = containingBlock();
   if (!cb) {
-    // We are evaluating align-self/justify-self, which default to 'normal' for the root element.
-    // The 'normal' value behaves like 'start' except for Flexbox Items, which obviously should have a container.
+    // We are evaluating align-self/justify-self, which default to 'normal' for
+    // the root element. The 'normal' value behaves like 'start' except for
+    // Flexbox Items, which obviously should have a container.
     return false;
   }
   const ComputedStyle* parentStyle = isAnonymous() ? cb->style() : nullptr;
   if (cb->isHorizontalWritingMode() != isHorizontalWritingMode())
     return style
                .resolvedAlignSelf(cb->selfAlignmentNormalBehavior(),
                                   parentStyle)
                .position() == ItemPositionStretch;
   return style
              .resolvedJustifySelf(cb->selfAlignmentNormalBehavior(),
                                   parentStyle)
              .position() == ItemPositionStretch;
 }
 
 bool LayoutBox::sizesLogicalWidthToFitContent(
     const Length& logicalWidth) const {
   if (isFloating() || isInlineBlockOrInlineTable())
     return true;
 
   if (isGridItem())
     return !hasStretchedLogicalWidth();
 
-  // Flexible box items should shrink wrap, so we lay them out at their intrinsic widths.
-  // In the case of columns that have a stretch alignment, we go ahead and layout at the
-  // stretched size to avoid an extra layout when applying alignment.
+  // Flexible box items should shrink wrap, so we lay them out at their
+  // intrinsic widths. In the case of columns that have a stretch alignment, we
+  // go ahead and layout at the stretched size to avoid an extra layout when
+  // applying alignment.
   if (parent()->isFlexibleBox()) {
-    // For multiline columns, we need to apply align-content first, so we can't stretch now.
+    // For multiline columns, we need to apply align-content first, so we can't
+    // stretch now.
     if (!parent()->style()->isColumnFlexDirection() ||
         parent()->style()->flexWrap() != FlexNoWrap)
       return true;
     if (!columnFlexItemHasStretchAlignment())
       return true;
   }
 
-  // Flexible horizontal boxes lay out children at their intrinsic widths.  Also vertical boxes
-  // that don't stretch their kids lay out their children at their intrinsic widths.
+  // Flexible horizontal boxes lay out children at their intrinsic widths. Also
+  // vertical boxes that don't stretch their kids lay out their children at
+  // their intrinsic widths.
   // FIXME: Think about writing-mode here.
   // https://bugs.webkit.org/show_bug.cgi?id=46473
   if (parent()->isDeprecatedFlexibleBox() &&
       (parent()->style()->boxOrient() == HORIZONTAL ||
        parent()->style()->boxAlign() != BSTRETCH))
     return true;
 
-  // Button, input, select, textarea, and legend treat width value of 'auto' as 'intrinsic' unless it's in a
-  // stretching column flexbox.
+  // Button, input, select, textarea, and legend treat width value of 'auto' as
+  // 'intrinsic' unless it's in a stretching column flexbox.
   // FIXME: Think about writing-mode here.
   // https://bugs.webkit.org/show_bug.cgi?id=46473
   if (logicalWidth.isAuto() && !isStretchingColumnFlexItem() &&
       autoWidthShouldFitContent())
     return true;
 
   if (isHorizontalWritingMode() != containingBlock()->isHorizontalWritingMode())
     return true;
 
   return false;
 }
 
 bool LayoutBox::autoWidthShouldFitContent() const {
   return node() &&
          (isHTMLInputElement(*node()) || isHTMLSelectElement(*node()) ||
           isHTMLButtonElement(*node()) || isHTMLTextAreaElement(*node()) ||
           (isHTMLLegendElement(*node()) && !style()->hasOutOfFlowPosition()));
 }
 
 void LayoutBox::computeMarginsForDirection(MarginDirection flowDirection,
                                            const LayoutBlock* containingBlock,
                                            LayoutUnit containerWidth,
                                            LayoutUnit childWidth,
                                            LayoutUnit& marginStart,
                                            LayoutUnit& marginEnd,
                                            Length marginStartLength,
                                            Length marginEndLength) const {
-  // First assert that we're not calling this method on box types that don't support margins.
+  // First assert that we're not calling this method on box types that don't
+  // support margins.
   ASSERT(!isTableCell());
   ASSERT(!isTableRow());
   ASSERT(!isTableSection());
   ASSERT(!isLayoutTableCol());
   if (flowDirection == BlockDirection || isFloating() || isInline()) {
     // Margins are calculated with respect to the logical width of
     // the containing block (8.3)
     // Inline blocks/tables and floats don't have their margins increased.
     marginStart = minimumValueForLength(marginStartLength, containerWidth);
     marginEnd = minimumValueForLength(marginEndLength, containerWidth);
     return;
   }
 
   if (containingBlock->isFlexibleBox()) {
     // We need to let flexbox handle the margin adjustment - otherwise, flexbox
-    // will think we're wider than we actually are and calculate line sizes wrong.
-    // See also http://dev.w3.org/csswg/css-flexbox/#auto-margins
+    // will think we're wider than we actually are and calculate line sizes
+    // wrong. See also http://dev.w3.org/csswg/css-flexbox/#auto-margins
     if (marginStartLength.isAuto())
       marginStartLength.setValue(0);
     if (marginEndLength.isAuto())
       marginEndLength.setValue(0);
   }
 
   LayoutUnit marginStartWidth =
       minimumValueForLength(marginStartLength, containerWidth);
   LayoutUnit marginEndWidth =
       minimumValueForLength(marginEndLength, containerWidth);
 
   LayoutUnit availableWidth = containerWidth;
   if (avoidsFloats() && containingBlock->isLayoutBlockFlow() &&
       toLayoutBlockFlow(containingBlock)->containsFloats()) {
     availableWidth = containingBlockAvailableLineWidth();
     if (shrinkToAvoidFloats() && availableWidth < containerWidth) {
       marginStart = std::max(LayoutUnit(), marginStartWidth);
       marginEnd = std::max(LayoutUnit(), marginEndWidth);
     }
   }
 
-  // CSS 2.1 (10.3.3): "If 'width' is not 'auto' and 'border-left-width' + 'padding-left' + 'width' + 'padding-right' + 'border-right-width'
-  // (plus any of 'margin-left' or 'margin-right' that are not 'auto') is larger than the width of the containing block, then any 'auto'
-  // values for 'margin-left' or 'margin-right' are, for the following rules, treated as zero.
+  // CSS 2.1 (10.3.3): "If 'width' is not 'auto' and 'border-left-width' +
+  // 'padding-left' + 'width' + 'padding-right' + 'border-right-width' (plus any
+  // of 'margin-left' or 'margin-right' that are not 'auto') is larger than the
+  // width of the containing block, then any 'auto' values for 'margin-left' or
+  // 'margin-right' are, for the following rules, treated as zero.
   LayoutUnit marginBoxWidth =
       childWidth + (!style()->width().isAuto()
                         ? marginStartWidth + marginEndWidth
                         : LayoutUnit());
 
   if (marginBoxWidth < availableWidth) {
-    // CSS 2.1: "If both 'margin-left' and 'margin-right' are 'auto', their used values are equal. This horizontally centers the element
-    // with respect to the edges of the containing block."
+    // CSS 2.1: "If both 'margin-left' and 'margin-right' are 'auto', their used
+    // values are equal. This horizontally centers the element with respect to
+    // the edges of the containing block."
     const ComputedStyle& containingBlockStyle = containingBlock->styleRef();
     if ((marginStartLength.isAuto() && marginEndLength.isAuto()) ||
         (!marginStartLength.isAuto() && !marginEndLength.isAuto() &&
          containingBlockStyle.textAlign() == WEBKIT_CENTER)) {
-      // Other browsers center the margin box for align=center elements so we match them here.
+      // Other browsers center the margin box for align=center elements so we
+      // match them here.
       LayoutUnit centeredMarginBoxStart = std::max(
           LayoutUnit(),
           (availableWidth - childWidth - marginStartWidth - marginEndWidth) /
               2);
       marginStart = centeredMarginBoxStart + marginStartWidth;
       marginEnd = availableWidth - childWidth - marginStart + marginEndWidth;
       return;
     }
 
     // Adjust margins for the align attribute
     if ((!containingBlockStyle.isLeftToRightDirection() &&
          containingBlockStyle.textAlign() == WEBKIT_LEFT) ||
         (containingBlockStyle.isLeftToRightDirection() &&
          containingBlockStyle.textAlign() == WEBKIT_RIGHT)) {
       if (containingBlockStyle.isLeftToRightDirection() !=
           styleRef().isLeftToRightDirection()) {
         if (!marginStartLength.isAuto())
           marginEndLength = Length(Auto);
       } else {
         if (!marginEndLength.isAuto())
           marginStartLength = Length(Auto);
       }
     }
 
-    // CSS 2.1: "If there is exactly one value specified as 'auto', its used value follows from the equality."
+    // CSS 2.1: "If there is exactly one value specified as 'auto', its used
+    // value follows from the equality."
     if (marginEndLength.isAuto()) {
       marginStart = marginStartWidth;
       marginEnd = availableWidth - childWidth - marginStart;
       return;
     }
 
     if (marginStartLength.isAuto()) {
       marginEnd = marginEndWidth;
       marginStart = availableWidth - childWidth - marginEnd;
       return;
     }
   }
 
-  // Either no auto margins, or our margin box width is >= the container width, auto margins will just turn into 0.
+  // Either no auto margins, or our margin box width is >= the container width,
+  // auto margins will just turn into 0.
   marginStart = marginStartWidth;
   marginEnd = marginEndWidth;
 }
 
 DISABLE_CFI_PERF
 void LayoutBox::updateLogicalHeight() {
   m_intrinsicContentLogicalHeight = contentLogicalHeight();
 
   LogicalExtentComputedValues computedValues;
   LayoutUnit height = style()->containsSize() ? borderAndPaddingLogicalHeight()
@@ skipping 16 matching lines @@
   // Cell height is managed by the table.
   if (isTableCell())
     return;
 
   Length h;
   if (isOutOfFlowPositioned()) {
     computePositionedLogicalHeight(computedValues);
   } else {
     LayoutBlock* cb = containingBlock();
 
-    // If we are perpendicular to our containing block then we need to resolve our block-start and block-end margins so that if they
-    // are 'auto' we are centred or aligned within the inline flow containing block: this is done by computing the margins as though they are inline.
-    // Note that as this is the 'sizing phase' we are using our own writing mode rather than the containing block's. We use the containing block's
-    // writing mode when figuring out the block-direction margins for positioning in |computeAndSetBlockDirectionMargins| (i.e. margin collapsing etc.).
-    // See http://www.w3.org/TR/2014/CR-css-writing-modes-3-20140320/#orthogonal-flows
+    // If we are perpendicular to our containing block then we need to resolve
+    // our block-start and block-end margins so that if they are 'auto' we are
+    // centred or aligned within the inline flow containing block: this is done
+    // by computing the margins as though they are inline.
+    // Note that as this is the 'sizing phase' we are using our own writing mode
+    // rather than the containing block's. We use the containing block's writing
+    // mode when figuring out the block-direction margins for positioning in
+    // |computeAndSetBlockDirectionMargins| (i.e. margin collapsing etc.).
+    // http://www.w3.org/TR/2014/CR-css-writing-modes-3-20140320/#orthogonal-flows
     MarginDirection flowDirection =
         isHorizontalWritingMode() != cb->isHorizontalWritingMode()
             ? InlineDirection
             : BlockDirection;
 
     // For tables, calculate margins only.
     if (isTable()) {
       computeMarginsForDirection(
           flowDirection, cb, containingBlockLogicalWidthForContent(),
           computedValues.m_extent, computedValues.m_margins.m_before,
           computedValues.m_margins.m_after, style()->marginBefore(),
           style()->marginAfter());
       return;
     }
 
     // FIXME: Account for writing-mode in flexible boxes.
     // https://bugs.webkit.org/show_bug.cgi?id=46418
     bool inHorizontalBox = parent()->isDeprecatedFlexibleBox() &&
                            parent()->style()->boxOrient() == HORIZONTAL;
     bool stretching = parent()->style()->boxAlign() == BSTRETCH;
     bool treatAsReplaced =
         shouldComputeSizeAsReplaced() && (!inHorizontalBox || !stretching);
     bool checkMinMaxHeight = false;
 
-    // The parent box is flexing us, so it has increased or decreased our height.  We have to
-    // grab our cached flexible height.
+    // The parent box is flexing us, so it has increased or decreased our
+    // height. We have to grab our cached flexible height.
     // FIXME: Account for writing-mode in flexible boxes.
     // https://bugs.webkit.org/show_bug.cgi?id=46418
     if (hasOverrideLogicalContentHeight()) {
       LayoutUnit contentHeight = overrideLogicalContentHeight();
       if (parent()->isLayoutGrid() && style()->logicalMinHeight().isAuto() &&
           style()->overflowY() == OverflowVisible) {
         ASSERT(style()->logicalHeight().isAuto());
         LayoutUnit minContentHeight = computeContentLogicalHeight(
             MinSize, Length(MinContent),
             computedValues.m_extent - borderAndPaddingLogicalHeight());
@@ skipping 26 matching lines @@
     if (checkMinMaxHeight) {
       heightResult = computeLogicalHeightUsing(
           MainOrPreferredSize, style()->logicalHeight(),
           computedValues.m_extent - borderAndPaddingLogicalHeight());
       if (heightResult == -1)
         heightResult = computedValues.m_extent;
       heightResult = constrainLogicalHeightByMinMax(
           heightResult,
           computedValues.m_extent - borderAndPaddingLogicalHeight());
     } else {
-      // The only times we don't check min/max height are when a fixed length has
-      // been given as an override.  Just use that.  The value has already been adjusted
-      // for box-sizing.
+      // The only times we don't check min/max height are when a fixed length
+      // has been given as an override.  Just use that.  The value has already
+      // been adjusted for box-sizing.
       ASSERT(h.isFixed());
       heightResult = LayoutUnit(h.value()) + borderAndPaddingLogicalHeight();
     }
 
     computedValues.m_extent = heightResult;
     computeMarginsForDirection(
         flowDirection, cb, containingBlockLogicalWidthForContent(),
         computedValues.m_extent, computedValues.m_margins.m_before,
         computedValues.m_margins.m_after, style()->marginBefore(),
         style()->marginAfter());
   }
 
-  // WinIE quirk: The <html> block always fills the entire canvas in quirks mode.  The <body> always fills the
-  // <html> block in quirks mode.  Only apply this quirk if the block is normal flow and no height
-  // is specified. When we're printing, we also need this quirk if the body or root has a percentage
-  // height since we don't set a height in LayoutView when we're printing. So without this quirk, the
-  // height has nothing to be a percentage of, and it ends up being 0. That is bad.
+  // WinIE quirk: The <html> block always fills the entire canvas in quirks
+  // mode. The <body> always fills the <html> block in quirks mode. Only apply
+  // this quirk if the block is normal flow and no height is specified. When
+  // we're printing, we also need this quirk if the body or root has a
+  // percentage height since we don't set a height in LayoutView when we're
+  // printing. So without this quirk, the height has nothing to be a percentage
+  // of, and it ends up being 0. That is bad.
   bool paginatedContentNeedsBaseHeight =
       document().printing() && h.isPercentOrCalc() &&
       (isDocumentElement() || (isBody() &&
                                document()
                                    .documentElement()
                                    ->layoutObject()
                                    ->style()
                                    ->logicalHeight()
                                    .isPercentOrCalc())) &&
       !isInline();
   if (stretchesToViewport() || paginatedContentNeedsBaseHeight) {
     LayoutUnit margins = collapsedMarginBefore() + collapsedMarginAfter();
     LayoutUnit visibleHeight = view()->viewLogicalHeightForPercentages();
     if (isDocumentElement()) {
       computedValues.m_extent =
           std::max(computedValues.m_extent, visibleHeight - margins);
     } else {
       LayoutUnit marginsBordersPadding =
           margins + parentBox()->marginBefore() + parentBox()->marginAfter() +
           parentBox()->borderAndPaddingLogicalHeight();
       computedValues.m_extent = std::max(computedValues.m_extent,
                                          visibleHeight - marginsBordersPadding);
     }
   }
 }
 
 LayoutUnit LayoutBox::computeLogicalHeightWithoutLayout() const {
-  // TODO(cbiesinger): We should probably return something other than just border + padding, but for now
-  // we have no good way to do anything else without layout, so we just use that.
+  // TODO(cbiesinger): We should probably return something other than just
+  // border + padding, but for now we have no good way to do anything else
+  // without layout, so we just use that.
   LogicalExtentComputedValues computedValues;
   computeLogicalHeight(borderAndPaddingLogicalHeight(), LayoutUnit(),
                        computedValues);
   return computedValues.m_extent;
 }
 
 LayoutUnit LayoutBox::computeLogicalHeightUsing(
     SizeType heightType,
     const Length& height,
     LayoutUnit intrinsicContentHeight) const {
@@ skipping 23 matching lines @@
     adjusted =
         adjustContentBoxLogicalHeightForBoxSizing(heightIncludingScrollbar);
   }
   return std::max(LayoutUnit(), adjusted - scrollbarLogicalHeight());
 }
 
 LayoutUnit LayoutBox::computeIntrinsicLogicalContentHeightUsing(
     const Length& logicalHeightLength,
     LayoutUnit intrinsicContentHeight,
     LayoutUnit borderAndPadding) const {
-  // FIXME(cbiesinger): The css-sizing spec is considering changing what min-content/max-content should resolve to.
+  // FIXME(cbiesinger): The css-sizing spec is considering changing what
+  // min-content/max-content should resolve to.
   // If that happens, this code will have to change.
   if (logicalHeightLength.isMinContent() ||
       logicalHeightLength.isMaxContent() ||
       logicalHeightLength.isFitContent()) {
     if (isAtomicInlineLevel())
       return intrinsicSize().height();
     return intrinsicContentHeight;
   }
   if (logicalHeightLength.isFillAvailable())
     return containingBlock()->availableLogicalHeight(
                ExcludeMarginBorderPadding) -
            borderAndPadding;
   ASSERT_NOT_REACHED();
   return LayoutUnit();
 }
 
 LayoutUnit LayoutBox::computeContentAndScrollbarLogicalHeightUsing(
     SizeType heightType,
     const Length& height,
     LayoutUnit intrinsicContentHeight) const {
   if (height.isAuto())
     return heightType == MinSize ? LayoutUnit() : LayoutUnit(-1);
-  // FIXME(cbiesinger): The css-sizing spec is considering changing what min-content/max-content should resolve to.
+  // FIXME(cbiesinger): The css-sizing spec is considering changing what
+  // min-content/max-content should resolve to.
   // If that happens, this code will have to change.
   if (height.isIntrinsic()) {
     if (intrinsicContentHeight == -1)
       return LayoutUnit(-1);  // Intrinsic height isn't available.
     return computeIntrinsicLogicalContentHeightUsing(
                height, intrinsicContentHeight,
                borderAndPaddingLogicalHeight()) +
            scrollbarLogicalHeight();
   }
   if (height.isFixed())
     return LayoutUnit(height.value());
   if (height.isPercentOrCalc())
     return computePercentageLogicalHeight(height);
   return LayoutUnit(-1);
 }
 
 bool LayoutBox::stretchesToViewportInQuirksMode() const {
   if (!isDocumentElement() && !isBody())
     return false;
   return style()->logicalHeight().isAuto() &&
          !isFloatingOrOutOfFlowPositioned() && !isInline() &&
          !flowThreadContainingBlock();
 }
 
 bool LayoutBox::skipContainingBlockForPercentHeightCalculation(
     const LayoutBox* containingBlock) const {
-  // If the writing mode of the containing block is orthogonal to ours, it means that we shouldn't
-  // skip anything, since we're going to resolve the percentage height against a containing block *width*.
+  // If the writing mode of the containing block is orthogonal to ours, it means
+  // that we shouldn't skip anything, since we're going to resolve the
+  // percentage height against a containing block *width*.
   if (isHorizontalWritingMode() != containingBlock->isHorizontalWritingMode())
     return false;
 
-  // Anonymous blocks should not impede percentage resolution on a child. Examples of such
-  // anonymous blocks are blocks wrapped around inlines that have block siblings (from the CSS
-  // spec) and multicol flow threads (an implementation detail). Another implementation detail,
-  // ruby runs, create anonymous inline-blocks, so skip those too. All other types of anonymous
-  // objects, such as table-cells, will be treated just as if they were non-anonymous.
+  // Anonymous blocks should not impede percentage resolution on a child.
+  // Examples of such anonymous blocks are blocks wrapped around inlines that
+  // have block siblings (from the CSS spec) and multicol flow threads (an
+  // implementation detail). Another implementation detail, ruby runs, create
+  // anonymous inline-blocks, so skip those too. All other types of anonymous
+  // objects, such as table-cells, will be treated just as if they were
+  // non-anonymous.
   if (containingBlock->isAnonymous()) {
     EDisplay display = containingBlock->styleRef().display();
     return display == EDisplay::Block || display == EDisplay::InlineBlock;
   }
 
-  // For quirks mode, we skip most auto-height containing blocks when computing percentages.
+  // For quirks mode, we skip most auto-height containing blocks when computing
+  // percentages.
   return document().inQuirksMode() && !containingBlock->isTableCell() &&
          !containingBlock->isOutOfFlowPositioned() &&
          !containingBlock->isLayoutGrid() &&
          containingBlock->style()->logicalHeight().isAuto();
 }
 
 LayoutUnit LayoutBox::computePercentageLogicalHeight(
     const Length& height) const {
   LayoutBlock* cb = containingBlock();
   const LayoutBox* containingBlockChild = this;
@@ skipping 11 matching lines @@
   cb->addPercentHeightDescendant(const_cast<LayoutBox*>(this));
 
   LayoutUnit availableHeight(-1);
   if (isHorizontalWritingMode() != cb->isHorizontalWritingMode()) {
     availableHeight =
         containingBlockChild->containingBlockLogicalWidthForContent();
   } else if (hasOverrideContainingBlockLogicalHeight()) {
     availableHeight = overrideContainingBlockContentLogicalHeight();
   } else if (cb->isTableCell()) {
     if (!skippedAutoHeightContainingBlock) {
-      // Table cells violate what the CSS spec says to do with heights. Basically we
-      // don't care if the cell specified a height or not. We just always make ourselves
-      // be a percentage of the cell's current content height.
+      // Table cells violate what the CSS spec says to do with heights.
+      // Basically we don't care if the cell specified a height or not. We just
+      // always make ourselves be a percentage of the cell's current content
+      // height.
       if (!cb->hasOverrideLogicalContentHeight()) {
-        // Normally we would let the cell size intrinsically, but scrolling overflow has to be
-        // treated differently, since WinIE lets scrolled overflow regions shrink as needed.
-        // While we can't get all cases right, we can at least detect when the cell has a specified
-        // height or when the table has a specified height. In these cases we want to initially have
-        // no size and allow the flexing of the table or the cell to its specified height to cause us
-        // to grow to fill the space. This could end up being wrong in some cases, but it is
-        // preferable to the alternative (sizing intrinsically and making the row end up too big).
+        // Normally we would let the cell size intrinsically, but scrolling
+        // overflow has to be treated differently, since WinIE lets scrolled
+        // overflow regions shrink as needed.
+        // While we can't get all cases right, we can at least detect when the
+        // cell has a specified height or when the table has a specified height.
+        // In these cases we want to initially have no size and allow the
+        // flexing of the table or the cell to its specified height to cause us
+        // to grow to fill the space. This could end up being wrong in some
+        // cases, but it is preferable to the alternative (sizing intrinsically
+        // and making the row end up too big).
         LayoutTableCell* cell = toLayoutTableCell(cb);
         if (scrollsOverflowY() &&
             (!cell->style()->logicalHeight().isAuto() ||
              !cell->table()->style()->logicalHeight().isAuto()))
           return LayoutUnit();
         return LayoutUnit(-1);
       }
       availableHeight = cb->overrideLogicalContentHeight();
     }
   } else {
     availableHeight = cb->availableLogicalHeightForPercentageComputation();
   }
 
   if (availableHeight == -1)
     return availableHeight;
 
   availableHeight -= rootMarginBorderPaddingHeight;
 
   if (isTable() && isOutOfFlowPositioned())
     availableHeight += cb->paddingLogicalHeight();
 
   LayoutUnit result = valueForLength(height, availableHeight);
   bool includeBorderPadding =
       isTable() || (cb->isTableCell() && !skippedAutoHeightContainingBlock &&
                     cb->hasOverrideLogicalContentHeight());
 
   if (includeBorderPadding) {
-    // FIXME: Table cells should default to box-sizing: border-box so we can avoid this hack.
+    // FIXME: Table cells should default to box-sizing: border-box so we can
+    // avoid this hack.
     // It is necessary to use the border-box to match WinIE's broken
     // box model. This is essential for sizing inside
     // table cells using percentage heights.
     result -= borderAndPaddingLogicalHeight();
     return std::max(LayoutUnit(), result);
   }
   return result;
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalWidth(
@@ skipping 39 matching lines @@
       LayoutUnit availableLogicalWidth;
       return computeIntrinsicLogicalWidthUsing(logicalWidth,
                                                availableLogicalWidth,
                                                borderAndPaddingLogicalWidth()) -
              borderAndPaddingLogicalWidth();
     }
     case FitContent:
     case FillAvailable:
     case Percent:
     case Calculated: {
-      // FIXME: containingBlockLogicalWidthForContent() is wrong if the replaced element's writing-mode is perpendicular to the
-      // containing block's writing-mode.
-      // https://bugs.webkit.org/show_bug.cgi?id=46496
+      // FIXME: containingBlockLogicalWidthForContent() is wrong if the replaced
+      // element's writing-mode is perpendicular to the containing block's
+      // writing-mode. https://bugs.webkit.org/show_bug.cgi?id=46496
       const LayoutUnit cw = isOutOfFlowPositioned()
                                 ? containingBlockLogicalWidthForPositioned(
                                       toLayoutBoxModelObject(container()))
                                 : containingBlockLogicalWidthForContent();
       Length containerLogicalWidth = containingBlock()->style()->logicalWidth();
-      // FIXME: Handle cases when containing block width is calculated or viewport percent.
-      // https://bugs.webkit.org/show_bug.cgi?id=91071
+      // FIXME: Handle cases when containing block width is calculated or
+      // viewport percent. https://bugs.webkit.org/show_bug.cgi?id=91071
       if (logicalWidth.isIntrinsic())
         return computeIntrinsicLogicalWidthUsing(
                    logicalWidth, cw, borderAndPaddingLogicalWidth()) -
                borderAndPaddingLogicalWidth();
       if (cw > 0 || (!cw && (containerLogicalWidth.isFixed() ||
                              containerLogicalWidth.isPercentOrCalc())))
         return adjustContentBoxLogicalWidthForBoxSizing(
             minimumValueForLength(logicalWidth, cw));
       return LayoutUnit();
     }
@@ skipping 27 matching lines @@
   if (logicalHeight == initialLogicalHeight)
     return true;
 
   if (LayoutBlock* cb = containingBlockForAutoHeightDetection(logicalHeight))
     return cb->hasAutoHeightOrContainingBlockWithAutoHeight();
   return false;
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalHeightRespectingMinMaxHeight(
     LayoutUnit logicalHeight) const {
-  // If the height of the containing block is not specified explicitly (i.e., it depends on content height), and this element is not absolutely positioned,
-  // the percentage value is treated as '0' (for 'min-height') or 'none' (for 'max-height').
+  // If the height of the containing block is not specified explicitly (i.e., it
+  // depends on content height), and this element is not absolutely positioned,
+  // the percentage value is treated as '0' (for 'min-height') or 'none' (for
+  // 'max-height').
   LayoutUnit minLogicalHeight;
   if (!logicalHeightComputesAsNone(MinSize))
     minLogicalHeight =
         computeReplacedLogicalHeightUsing(MinSize, style()->logicalMinHeight());
   LayoutUnit maxLogicalHeight = logicalHeight;
   if (!logicalHeightComputesAsNone(MaxSize))
     maxLogicalHeight =
         computeReplacedLogicalHeightUsing(MaxSize, style()->logicalMaxHeight());
   return std::max(minLogicalHeight, std::min(logicalHeight, maxLogicalHeight));
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalHeightUsing(
     SizeType sizeType,
     const Length& logicalHeight) const {
   ASSERT(sizeType == MinSize || sizeType == MainOrPreferredSize ||
          !logicalHeight.isAuto());
   if (sizeType == MinSize && logicalHeight.isAuto())
     return adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit());
 
   switch (logicalHeight.type()) {
     case Fixed:
       return adjustContentBoxLogicalHeightForBoxSizing(logicalHeight.value());
     case Percent:
     case Calculated: {
-      // TODO(rego): Check if we can somehow reuse LayoutBox::computePercentageLogicalHeight() and/or
-      // LayoutBlock::availableLogicalHeightForPercentageComputation() (see http://crbug.com/635655).
+      // TODO(rego): Check if we can somehow reuse
+      // LayoutBox::computePercentageLogicalHeight() and/or
+      // LayoutBlock::availableLogicalHeightForPercentageComputation() (see
+      // http://crbug.com/635655).
       LayoutObject* cb =
           isOutOfFlowPositioned() ? container() : containingBlock();
       while (cb->isAnonymous())
         cb = cb->containingBlock();
       LayoutUnit stretchedHeight(-1);
       if (cb->isLayoutBlock()) {
         LayoutBlock* block = toLayoutBlock(cb);
         block->addPercentHeightDescendant(const_cast<LayoutBox*>(this));
         if (block->isFlexItem())
           stretchedHeight =
@@ skipping 13 matching lines @@
                                     computedValues);
         LayoutUnit newContentHeight = computedValues.m_extent -
                                       block->borderAndPaddingLogicalHeight() -
                                       block->scrollbarLogicalHeight();
         LayoutUnit newHeight =
             block->adjustContentBoxLogicalHeightForBoxSizing(newContentHeight);
         return adjustContentBoxLogicalHeightForBoxSizing(
             valueForLength(logicalHeight, newHeight));
       }
 
-      // FIXME: availableLogicalHeight() is wrong if the replaced element's writing-mode is perpendicular to the
-      // containing block's writing-mode.
+      // FIXME: availableLogicalHeight() is wrong if the replaced element's
+      // writing-mode is perpendicular to the containing block's writing-mode.
       // https://bugs.webkit.org/show_bug.cgi?id=46496
       LayoutUnit availableHeight;
       if (isOutOfFlowPositioned()) {
         availableHeight = containingBlockLogicalHeightForPositioned(
             toLayoutBoxModelObject(cb));
       } else if (stretchedHeight != -1) {
         availableHeight = stretchedHeight;
       } else if (hasOverrideContainingBlockLogicalHeight()) {
         availableHeight = overrideContainingBlockContentLogicalHeight();
       } else {
         availableHeight =
             containingBlockLogicalHeightForContent(IncludeMarginBorderPadding);
         // It is necessary to use the border-box to match WinIE's broken
         // box model.  This is essential for sizing inside
         // table cells using percentage heights.
-        // FIXME: This needs to be made writing-mode-aware. If the cell and image are perpendicular writing-modes, this isn't right.
+        // FIXME: This needs to be made writing-mode-aware. If the cell and
+        // image are perpendicular writing-modes, this isn't right.
         // https://bugs.webkit.org/show_bug.cgi?id=46997
         while (cb && !cb->isLayoutView() &&
                (cb->style()->logicalHeight().isAuto() ||
                 cb->style()->logicalHeight().isPercentOrCalc())) {
           if (cb->isTableCell()) {
             // Don't let table cells squeeze percent-height replaced elements
             // <http://bugs.webkit.org/show_bug.cgi?id=15359>
             availableHeight =
                 std::max(availableHeight, intrinsicLogicalHeight());
             return valueForLength(
@@ skipping 16 matching lines @@
           computeIntrinsicLogicalContentHeightUsing(logicalHeight,
                                                     intrinsicLogicalHeight(),
                                                     borderAndPaddingHeight()));
     default:
       return intrinsicLogicalHeight();
   }
 }
 
 LayoutUnit LayoutBox::availableLogicalHeight(
     AvailableLogicalHeightType heightType) const {
-  // http://www.w3.org/TR/CSS2/visudet.html#propdef-height - We are interested in the content height.
+  // http://www.w3.org/TR/CSS2/visudet.html#propdef-height - We are interested
+  // in the content height.
   // FIXME: Should we pass intrinsicContentLogicalHeight() instead of -1 here?
   return constrainContentBoxLogicalHeightByMinMax(
       availableLogicalHeightUsing(style()->logicalHeight(), heightType),
       LayoutUnit(-1));
 }
 
 LayoutUnit LayoutBox::availableLogicalHeightUsing(
     const Length& h,
     AvailableLogicalHeightType heightType) const {
   if (isLayoutView()) {
     return LayoutUnit(
         isHorizontalWritingMode()
             ? toLayoutView(this)->frameView()->visibleContentSize().height()
             : toLayoutView(this)->frameView()->visibleContentSize().width());
   }
 
-  // We need to stop here, since we don't want to increase the height of the table
-  // artificially.  We're going to rely on this cell getting expanded to some new
-  // height, and then when we lay out again we'll use the calculation below.
+  // We need to stop here, since we don't want to increase the height of the
+  // table artificially.  We're going to rely on this cell getting expanded to
+  // some new height, and then when we lay out again we'll use the calculation
+  // below.
   if (isTableCell() && (h.isAuto() || h.isPercentOrCalc())) {
     if (hasOverrideLogicalContentHeight())
       return overrideLogicalContentHeight();
     return logicalHeight() - borderAndPaddingLogicalHeight();
   }
 
   if (isFlexItem()) {
     LayoutFlexibleBox& flexBox = toLayoutFlexibleBox(*parent());
     LayoutUnit stretchedHeight =
         flexBox.childLogicalHeightForPercentageResolution(*this);
     if (stretchedHeight != LayoutUnit(-1))
       return stretchedHeight;
   }
 
   if (h.isPercentOrCalc() && isOutOfFlowPositioned()) {
-    // FIXME: This is wrong if the containingBlock has a perpendicular writing mode.
+    // FIXME: This is wrong if the containingBlock has a perpendicular writing
+    // mode.
     LayoutUnit availableHeight =
         containingBlockLogicalHeightForPositioned(containingBlock());
     return adjustContentBoxLogicalHeightForBoxSizing(
         valueForLength(h, availableHeight));
   }
 
   // FIXME: Should we pass intrinsicContentLogicalHeight() instead of -1 here?
   LayoutUnit heightIncludingScrollbar =
       computeContentAndScrollbarLogicalHeightUsing(MainOrPreferredSize, h,
                                                    LayoutUnit(-1));
   if (heightIncludingScrollbar != -1)
     return std::max(LayoutUnit(), adjustContentBoxLogicalHeightForBoxSizing(
                                       heightIncludingScrollbar) -
                                       scrollbarLogicalHeight());
 
-  // FIXME: Check logicalTop/logicalBottom here to correctly handle vertical writing-mode.
+  // FIXME: Check logicalTop/logicalBottom here to correctly handle vertical
+  // writing-mode.
   // https://bugs.webkit.org/show_bug.cgi?id=46500
   if (isLayoutBlock() && isOutOfFlowPositioned() &&
       style()->height().isAuto() &&
       !(style()->top().isAuto() || style()->bottom().isAuto())) {
     LayoutBlock* block = const_cast<LayoutBlock*>(toLayoutBlock(this));
     LogicalExtentComputedValues computedValues;
     block->computeLogicalHeight(block->logicalHeight(), LayoutUnit(),
                                 computedValues);
     LayoutUnit newContentHeight = computedValues.m_extent -
                                   block->borderAndPaddingLogicalHeight() -
                                   block->scrollbarLogicalHeight();
     return adjustContentBoxLogicalHeightForBoxSizing(newContentHeight);
   }
 
-  // FIXME: This is wrong if the containingBlock has a perpendicular writing mode.
+  // FIXME: This is wrong if the containingBlock has a perpendicular writing
+  // mode.
   LayoutUnit availableHeight =
       containingBlockLogicalHeightForContent(heightType);
   if (heightType == ExcludeMarginBorderPadding) {
-    // FIXME: Margin collapsing hasn't happened yet, so this incorrectly removes collapsed margins.
+    // FIXME: Margin collapsing hasn't happened yet, so this incorrectly removes
+    // collapsed margins.
     availableHeight -=
         marginBefore() + marginAfter() + borderAndPaddingLogicalHeight();
   }
   return availableHeight;
 }
 
 void LayoutBox::computeAndSetBlockDirectionMargins(
     const LayoutBlock* containingBlock) {
   LayoutUnit marginBefore;
   LayoutUnit marginAfter;
   computeMarginsForDirection(
       BlockDirection, containingBlock, containingBlockLogicalWidthForContent(),
       logicalHeight(), marginBefore, marginAfter,
       style()->marginBeforeUsing(containingBlock->style()),
       style()->marginAfterUsing(containingBlock->style()));
-  // Note that in this 'positioning phase' of the layout we are using the containing block's writing mode rather than our own when calculating margins.
-  // See http://www.w3.org/TR/2014/CR-css-writing-modes-3-20140320/#orthogonal-flows
+  // Note that in this 'positioning phase' of the layout we are using the
+  // containing block's writing mode rather than our own when calculating
+  // margins.
+  // http://www.w3.org/TR/2014/CR-css-writing-modes-3-20140320/#orthogonal-flows
   containingBlock->setMarginBeforeForChild(*this, marginBefore);
   containingBlock->setMarginAfterForChild(*this, marginAfter);
 }
 
 LayoutUnit LayoutBox::containingBlockLogicalWidthForPositioned(
     const LayoutBoxModelObject* containingBlock,
     bool checkForPerpendicularWritingMode) const {
   if (checkForPerpendicularWritingMode &&
       containingBlock->isHorizontalWritingMode() != isHorizontalWritingMode())
     return containingBlockLogicalHeightForPositioned(containingBlock, false);
 
   // Use viewport as container for top-level fixed-position elements.
   if (style()->position() == FixedPosition && containingBlock->isLayoutView() &&
       !document().printing()) {
     const LayoutView* view = toLayoutView(containingBlock);
     if (FrameView* frameView = view->frameView()) {
-      // Don't use visibleContentRect since the PaintLayer's size has not been set yet.
+      // Don't use visibleContentRect since the PaintLayer's size has not been
+      // set yet.
       LayoutSize viewportSize(
           frameView->layoutViewportScrollableArea()->excludeScrollbars(
               frameView->frameRect().size()));
       return LayoutUnit(containingBlock->isHorizontalWritingMode()
                             ? viewportSize.width()
                             : viewportSize.height());
     }
   }
 
   if (hasOverrideContainingBlockLogicalWidth())
     return overrideContainingBlockContentLogicalWidth();
 
-  // Ensure we compute our width based on the width of our rel-pos inline container rather than any anonymous block
-  // created to manage a block-flow ancestor of ours in the rel-pos inline's inline flow.
+  // Ensure we compute our width based on the width of our rel-pos inline
+  // container rather than any anonymous block created to manage a block-flow
+  // ancestor of ours in the rel-pos inline's inline flow.
   if (containingBlock->isAnonymousBlock() && containingBlock->isRelPositioned())
     containingBlock = toLayoutBox(containingBlock)->continuation();
   else if (containingBlock->isBox())
     return std::max(LayoutUnit(),
                     toLayoutBox(containingBlock)->clientLogicalWidth());
 
   ASSERT(containingBlock->isLayoutInline() &&
          containingBlock->isInFlowPositioned());
 
   const LayoutInline* flow = toLayoutInline(containingBlock);
@@ skipping 24 matching lines @@
     bool checkForPerpendicularWritingMode) const {
   if (checkForPerpendicularWritingMode &&
       containingBlock->isHorizontalWritingMode() != isHorizontalWritingMode())
     return containingBlockLogicalWidthForPositioned(containingBlock, false);
 
   // Use viewport as container for top-level fixed-position elements.
   if (style()->position() == FixedPosition && containingBlock->isLayoutView() &&
       !document().printing()) {
     const LayoutView* view = toLayoutView(containingBlock);
     if (FrameView* frameView = view->frameView()) {
-      // Don't use visibleContentRect since the PaintLayer's size has not been set yet.
+      // Don't use visibleContentRect since the PaintLayer's size has not been
+      // set yet.
       LayoutSize viewportSize(
           frameView->layoutViewportScrollableArea()->excludeScrollbars(
               frameView->frameRect().size()));
       return containingBlock->isHorizontalWritingMode() ? viewportSize.height()
                                                         : viewportSize.width();
     }
   }
 
   if (hasOverrideContainingBlockLogicalHeight())
     return overrideContainingBlockContentLogicalHeight();
@@ skipping 30 matching lines @@
 static LayoutUnit accumulateStaticOffsetForFlowThread(
     LayoutBox& layoutBox,
     LayoutUnit inlinePosition,
     LayoutUnit& blockPosition) {
   if (layoutBox.isTableRow())
     return LayoutUnit();
   blockPosition += layoutBox.logicalTop();
   if (!layoutBox.isLayoutFlowThread())
     return LayoutUnit();
   LayoutUnit previousInlinePosition = inlinePosition;
-  // We're walking out of a flowthread here. This flow thread is not in the containing block
-  // chain, so we need to convert the position from the coordinate space of this flowthread to
-  // the containing coordinate space.
+  // We're walking out of a flowthread here. This flow thread is not in the
+  // containing block chain, so we need to convert the position from the
+  // coordinate space of this flowthread to the containing coordinate space.
   toLayoutFlowThread(layoutBox).flowThreadToContainingCoordinateSpace(
       blockPosition, inlinePosition);
   return inlinePosition - previousInlinePosition;
 }
 
 void LayoutBox::computeInlineStaticDistance(
     Length& logicalLeft,
     Length& logicalRight,
     const LayoutBox* child,
     const LayoutBoxModelObject* containerBlock,
     LayoutUnit containerLogicalWidth) {
   if (!logicalLeft.isAuto() || !logicalRight.isAuto())
     return;
 
-  // For multicol we also need to keep track of the block position, since that determines which
-  // column we're in and thus affects the inline position.
+  // For multicol we also need to keep track of the block position, since that
+  // determines which column we're in and thus affects the inline position.
   LayoutUnit staticBlockPosition = child->layer()->staticBlockPosition();
 
-  // FIXME: The static distance computation has not been patched for mixed writing modes yet.
+  // FIXME: The static distance computation has not been patched for mixed
+  // writing modes yet.
   if (child->parent()->style()->direction() == LTR) {
     LayoutUnit staticPosition = child->layer()->staticInlinePosition() -
                                 containerBlock->borderLogicalLeft();
     for (LayoutObject* curr = child->parent(); curr && curr != containerBlock;
          curr = curr->container()) {
       if (curr->isBox()) {
         staticPosition += toLayoutBox(curr)->logicalLeft();
         if (toLayoutBox(curr)->isInFlowPositioned())
           staticPosition +=
               toLayoutBox(curr)->offsetForInFlowPosition().width();
@@ skipping 47 matching lines @@
       if (curr == containerBlock)
         break;
     }
     logicalRight.setValue(Fixed, staticPosition);
   }
 }
 
 void LayoutBox::computePositionedLogicalWidth(
     LogicalExtentComputedValues& computedValues) const {
   // QUESTIONS
-  // FIXME 1: Should we still deal with these the cases of 'left' or 'right' having
-  // the type 'static' in determining whether to calculate the static distance?
+  // FIXME 1: Should we still deal with these the cases of 'left' or 'right'
+  // having the type 'static' in determining whether to calculate the static
+  // distance?
   // NOTE: 'static' is not a legal value for 'left' or 'right' as of CSS 2.1.
 
-  // FIXME 2: Can perhaps optimize out cases when max-width/min-width are greater
-  // than or less than the computed width().  Be careful of box-sizing and
-  // percentage issues.
+  // FIXME 2: Can perhaps optimize out cases when max-width/min-width are
+  // greater than or less than the computed width(). Be careful of box-sizing
+  // and percentage issues.
 
   // The following is based off of the W3C Working Draft from April 11, 2006 of
   // CSS 2.1: Section 10.3.7 "Absolutely positioned, non-replaced elements"
   // <http://www.w3.org/TR/CSS21/visudet.html#abs-non-replaced-width>
-  // (block-style-comments in this function and in computePositionedLogicalWidthUsing()
-  // correspond to text from the spec)
+  // (block-style-comments in this function and in
+  // computePositionedLogicalWidthUsing() correspond to text from the spec)
 
   // We don't use containingBlock(), since we may be positioned by an enclosing
   // relative positioned inline.
   const LayoutBoxModelObject* containerBlock =
       toLayoutBoxModelObject(container());
 
   const LayoutUnit containerLogicalWidth =
       containingBlockLogicalWidthForPositioned(containerBlock);
 
-  // Use the container block's direction except when calculating the static distance
-  // This conforms with the reference results for abspos-replaced-width-margin-000.htm
-  // of the CSS 2.1 test suite
+  // Use the container block's direction except when calculating the static
+  // distance. This conforms with the reference results for
+  // abspos-replaced-width-margin-000.htm of the CSS 2.1 test suite.
   TextDirection containerDirection = containerBlock->style()->direction();
 
   bool isHorizontal = isHorizontalWritingMode();
   const LayoutUnit bordersPlusPadding = borderAndPaddingLogicalWidth();
   const Length marginLogicalLeft =
       isHorizontal ? style()->marginLeft() : style()->marginTop();
   const Length marginLogicalRight =
       isHorizontal ? style()->marginRight() : style()->marginBottom();
 
   Length logicalLeftLength = style()->logicalLeft();
   Length logicalRightLength = style()->logicalRight();
-
-  /*---------------------------------------------------------------------------*\
-     * For the purposes of this section and the next, the term "static position"
-     * (of an element) refers, roughly, to the position an element would have had
-     * in the normal flow. More precisely:
-     *
-     * * The static position for 'left' is the distance from the left edge of the
-     *   containing block to the left margin edge of a hypothetical box that would
-     *   have been the first box of the element if its 'position' property had
-     *   been 'static' and 'float' had been 'none'. The value is negative if the
-     *   hypothetical box is to the left of the containing block.
-     * * The static position for 'right' is the distance from the right edge of the
-     *   containing block to the right margin edge of the same hypothetical box as
-     *   above. The value is positive if the hypothetical box is to the left of the
-     *   containing block's edge.
-     *
-     * But rather than actually calculating the dimensions of that hypothetical box,
-     * user agents are free to make a guess at its probable position.
-     *
-     * For the purposes of calculating the static position, the containing block of
-     * fixed positioned elements is the initial containing block instead of the
-     * viewport, and all scrollable boxes should be assumed to be scrolled to their
-     * origin.
-    \*---------------------------------------------------------------------------*/
-
+  // ---------------------------------------------------------------------------
+  //  For the purposes of this section and the next, the term "static position"
+  //  (of an element) refers, roughly, to the position an element would have had
+  //  in the normal flow. More precisely:
+  //
+  //  * The static position for 'left' is the distance from the left edge of the
+  //    containing block to the left margin edge of a hypothetical box that
+  //    would have been the first box of the element if its 'position' property
+  //    had been 'static' and 'float' had been 'none'. The value is negative if
+  //    the hypothetical box is to the left of the containing block.
+  //  * The static position for 'right' is the distance from the right edge of
+  //    the containing block to the right margin edge of the same hypothetical
+  //    box as above. The value is positive if the hypothetical box is to the
+  //    left of the containing block's edge.
+  //
+  //  But rather than actually calculating the dimensions of that hypothetical
+  //  box, user agents are free to make a guess at its probable position.
+  //
+  //  For the purposes of calculating the static position, the containing block
+  //  of fixed positioned elements is the initial containing block instead of
+  //  the viewport, and all scrollable boxes should be assumed to be scrolled to
+  //  their origin.
+  // ---------------------------------------------------------------------------
   // see FIXME 1
   // Calculate the static distance if needed.
   computeInlineStaticDistance(logicalLeftLength, logicalRightLength, this,
                               containerBlock, containerLogicalWidth);
 
   // Calculate constraint equation values for 'width' case.
   computePositionedLogicalWidthUsing(
       MainOrPreferredSize, style()->logicalWidth(), containerBlock,
       containerDirection, containerLogicalWidth, bordersPlusPadding,
       logicalLeftLength, logicalRightLength, marginLogicalLeft,
@@ skipping 39 matching lines @@
 
   computedValues.m_extent += bordersPlusPadding;
 }
 
 void LayoutBox::computeLogicalLeftPositionedOffset(
     LayoutUnit& logicalLeftPos,
     const LayoutBox* child,
     LayoutUnit logicalWidthValue,
     const LayoutBoxModelObject* containerBlock,
     LayoutUnit containerLogicalWidth) {
-  // Deal with differing writing modes here.  Our offset needs to be in the containing block's coordinate space. If the containing block is flipped
-  // along this axis, then we need to flip the coordinate.  This can only happen if the containing block is both a flipped mode and perpendicular to us.
+  // Deal with differing writing modes here. Our offset needs to be in the
+  // containing block's coordinate space. If the containing block is flipped
+  // along this axis, then we need to flip the coordinate. This can only happen
+  // if the containing block is both a flipped mode and perpendicular to us.
   if (containerBlock->isHorizontalWritingMode() !=
           child->isHorizontalWritingMode() &&
       containerBlock->style()->isFlippedBlocksWritingMode()) {
     logicalLeftPos = containerLogicalWidth - logicalWidthValue - logicalLeftPos;
     logicalLeftPos +=
         (child->isHorizontalWritingMode() ? containerBlock->borderRight()
                                           : containerBlock->borderBottom());
   } else {
     logicalLeftPos +=
         (child->isHorizontalWritingMode() ? containerBlock->borderLeft()
@@ skipping 36 matching lines @@
                                           bordersPlusPadding) -
         bordersPlusPadding;
   else
     logicalWidthValue = adjustContentBoxLogicalWidthForBoxSizing(
         valueForLength(logicalWidth, containerLogicalWidth));
 
   // 'left' and 'right' cannot both be 'auto' because one would of been
   // converted to the static position already
   ASSERT(!(logicalLeft.isAuto() && logicalRight.isAuto()));
 
-  // minimumValueForLength will convert 'auto' to 0 so that it doesn't impact the available space computation below.
+  // minimumValueForLength will convert 'auto' to 0 so that it doesn't impact
+  // the available space computation below.
   LayoutUnit logicalLeftValue =
       minimumValueForLength(logicalLeft, containerLogicalWidth);
   LayoutUnit logicalRightValue =
       minimumValueForLength(logicalRight, containerLogicalWidth);
 
   const LayoutUnit containerRelativeLogicalWidth =
       containingBlockLogicalWidthForPositioned(containerBlock, false);
 
   bool logicalWidthIsAuto = logicalWidth.isAuto();
   bool logicalLeftIsAuto = logicalLeft.isAuto();
   bool logicalRightIsAuto = logicalRight.isAuto();
   LayoutUnit& marginLogicalLeftValue = style()->isLeftToRightDirection()
                                            ? computedValues.m_margins.m_start
                                            : computedValues.m_margins.m_end;
   LayoutUnit& marginLogicalRightValue = style()->isLeftToRightDirection()
                                             ? computedValues.m_margins.m_end
                                             : computedValues.m_margins.m_start;
   if (!logicalLeftIsAuto && !logicalWidthIsAuto && !logicalRightIsAuto) {
-    /*-----------------------------------------------------------------------*\
-         * If none of the three is 'auto': If both 'margin-left' and 'margin-
-         * right' are 'auto', solve the equation under the extra constraint that
-         * the two margins get equal values, unless this would make them negative,
-         * in which case when direction of the containing block is 'ltr' ('rtl'),
-         * set 'margin-left' ('margin-right') to zero and solve for 'margin-right'
-         * ('margin-left'). If one of 'margin-left' or 'margin-right' is 'auto',
-         * solve the equation for that value. If the values are over-constrained,
-         * ignore the value for 'left' (in case the 'direction' property of the
-         * containing block is 'rtl') or 'right' (in case 'direction' is 'ltr')
-         * and solve for that value.
-        \*-----------------------------------------------------------------------*/
+    // -------------------------------------------------------------------------
+    // If none of the three is 'auto': If both 'margin-left' and 'margin-
+    // right' are 'auto', solve the equation under the extra constraint that
+    // the two margins get equal values, unless this would make them negative,
+    // in which case when direction of the containing block is 'ltr' ('rtl'),
+    // set 'margin-left' ('margin-right') to zero and solve for 'margin-right'
+    // ('margin-left'). If one of 'margin-left' or 'margin-right' is 'auto',
+    // solve the equation for that value. If the values are over-constrained,
+    // ignore the value for 'left' (in case the 'direction' property of the
+    // containing block is 'rtl') or 'right' (in case 'direction' is 'ltr')
+    // and solve for that value.
+    // -------------------------------------------------------------------------
     // NOTE:  It is not necessary to solve for 'right' in the over constrained
     // case because the value is not used for any further calculations.
 
     computedValues.m_extent = logicalWidthValue;
 
     const LayoutUnit availableSpace =
         containerLogicalWidth - (logicalLeftValue + computedValues.m_extent +
                                  logicalRightValue + bordersPlusPadding);
 
     // Margins are now the only unknown
@@ skipping 32 matching lines @@
       marginLogicalRightValue =
           valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
 
       // Use the containing block's direction rather than the parent block's
       // per CSS 2.1 reference test abspos-non-replaced-width-margin-000.
       if (containerDirection == RTL)
         logicalLeftValue = (availableSpace + logicalLeftValue) -
                            marginLogicalLeftValue - marginLogicalRightValue;
     }
   } else {
-    /*--------------------------------------------------------------------*\
-         * Otherwise, set 'auto' values for 'margin-left' and 'margin-right'
-         * to 0, and pick the one of the following six rules that applies.
-         *
-         * 1. 'left' and 'width' are 'auto' and 'right' is not 'auto', then the
-         *    width is shrink-to-fit. Then solve for 'left'
-         *
-         *              OMIT RULE 2 AS IT SHOULD NEVER BE HIT
-         * ------------------------------------------------------------------
-         * 2. 'left' and 'right' are 'auto' and 'width' is not 'auto', then if
-         *    the 'direction' property of the containing block is 'ltr' set
-         *    'left' to the static position, otherwise set 'right' to the
-         *    static position. Then solve for 'left' (if 'direction is 'rtl')
-         *    or 'right' (if 'direction' is 'ltr').
-         * ------------------------------------------------------------------
-         *
-         * 3. 'width' and 'right' are 'auto' and 'left' is not 'auto', then the
-         *    width is shrink-to-fit . Then solve for 'right'
-         * 4. 'left' is 'auto', 'width' and 'right' are not 'auto', then solve
-         *    for 'left'
-         * 5. 'width' is 'auto', 'left' and 'right' are not 'auto', then solve
-         *    for 'width'
-         * 6. 'right' is 'auto', 'left' and 'width' are not 'auto', then solve
-         *    for 'right'
-         *
-         * Calculation of the shrink-to-fit width is similar to calculating the
-         * width of a table cell using the automatic table layout algorithm.
-         * Roughly: calculate the preferred width by formatting the content
-         * without breaking lines other than where explicit line breaks occur,
-         * and also calculate the preferred minimum width, e.g., by trying all
-         * possible line breaks. CSS 2.1 does not define the exact algorithm.
-         * Thirdly, calculate the available width: this is found by solving
-         * for 'width' after setting 'left' (in case 1) or 'right' (in case 3)
-         * to 0.
-         *
-         * Then the shrink-to-fit width is:
-         * min(max(preferred minimum width, available width), preferred width).
-        \*--------------------------------------------------------------------*/
+    // -------------------------------------------------------------------------
+    // Otherwise, set 'auto' values for 'margin-left' and 'margin-right'
+    // to 0, and pick the one of the following six rules that applies.
+    //
+    // 1. 'left' and 'width' are 'auto' and 'right' is not 'auto', then the
+    //    width is shrink-to-fit. Then solve for 'left'
+    //
+    //              OMIT RULE 2 AS IT SHOULD NEVER BE HIT
+    // ------------------------------------------------------------------
+    // 2. 'left' and 'right' are 'auto' and 'width' is not 'auto', then if
+    //    the 'direction' property of the containing block is 'ltr' set
+    //    'left' to the static position, otherwise set 'right' to the
+    //    static position. Then solve for 'left' (if 'direction is 'rtl')
+    //    or 'right' (if 'direction' is 'ltr').
+    // ------------------------------------------------------------------
+    //
+    // 3. 'width' and 'right' are 'auto' and 'left' is not 'auto', then the
+    //    width is shrink-to-fit . Then solve for 'right'
+    // 4. 'left' is 'auto', 'width' and 'right' are not 'auto', then solve
+    //    for 'left'
+    // 5. 'width' is 'auto', 'left' and 'right' are not 'auto', then solve
+    //    for 'width'
+    // 6. 'right' is 'auto', 'left' and 'width' are not 'auto', then solve
+    //    for 'right'
+    //
+    // Calculation of the shrink-to-fit width is similar to calculating the
+    // width of a table cell using the automatic table layout algorithm.
+    // Roughly: calculate the preferred width by formatting the content without
+    // breaking lines other than where explicit line breaks occur, and also
+    // calculate the preferred minimum width, e.g., by trying all possible line
+    // breaks. CSS 2.1 does not define the exact algorithm.
+    // Thirdly, calculate the available width: this is found by solving for
+    // 'width' after setting 'left' (in case 1) or 'right' (in case 3) to 0.
+    //
+    // Then the shrink-to-fit width is:
+    // min(max(preferred minimum width, available width), preferred width).
+    // -------------------------------------------------------------------------
     // NOTE: For rules 3 and 6 it is not necessary to solve for 'right'
     // because the value is not used for any further calculations.
 
     // Calculate margins, 'auto' margins are ignored.
     marginLogicalLeftValue =
         minimumValueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
     marginLogicalRightValue = minimumValueForLength(
         marginLogicalRight, containerRelativeLogicalWidth);
 
     const LayoutUnit availableSpace =
@@ skipping 27 matching lines @@
         computedValues.m_extent = std::max(LayoutUnit(), availableSpace);
     } else if (!logicalLeftIsAuto && !logicalWidthIsAuto &&
                logicalRightIsAuto) {
       // RULE 6: (no need solve for right)
       computedValues.m_extent = logicalWidthValue;
     }
   }
 
   // Use computed values to calculate the horizontal position.
 
-  // FIXME: This hack is needed to calculate the  logical left position for a 'rtl' relatively
-  // positioned, inline because right now, it is using the logical left position
-  // of the first line box when really it should use the last line box.  When
-  // this is fixed elsewhere, this block should be removed.
+  // FIXME: This hack is needed to calculate the  logical left position for a
+  // 'rtl' relatively positioned, inline because right now, it is using the
+  // logical left position of the first line box when really it should use the
+  // last line box. When this is fixed elsewhere, this block should be removed.
   if (containerBlock->isLayoutInline() &&
       !containerBlock->style()->isLeftToRightDirection()) {
     const LayoutInline* flow = toLayoutInline(containerBlock);
     InlineFlowBox* firstLine = flow->firstLineBox();
     InlineFlowBox* lastLine = flow->lastLineBox();
     if (firstLine && lastLine && firstLine != lastLine) {
       computedValues.m_position =
           logicalLeftValue + marginLogicalLeftValue +
           lastLine->borderLogicalLeft() +
           (lastLine->logicalLeft() - firstLine->logicalLeft());
@@ skipping 16 matching lines @@
 }
 
 void LayoutBox::computeBlockStaticDistance(
     Length& logicalTop,
     Length& logicalBottom,
     const LayoutBox* child,
     const LayoutBoxModelObject* containerBlock) {
   if (!logicalTop.isAuto() || !logicalBottom.isAuto())
     return;
 
-  // FIXME: The static distance computation has not been patched for mixed writing modes.
+  // FIXME: The static distance computation has not been patched for mixed
+  // writing modes.
   LayoutUnit staticLogicalTop = child->layer()->staticBlockPosition();
   for (LayoutObject* curr = child->parent(); curr && curr != containerBlock;
        curr = curr->container()) {
     if (!curr->isBox() || curr->isTableRow())
       continue;
     const LayoutBox& box = *toLayoutBox(curr);
     staticLogicalTop += box.logicalTop();
     if (!box.isLayoutFlowThread())
       continue;
-    // We're walking out of a flowthread here. This flow thread is not in the containing block
-    // chain, so we need to convert the position from the coordinate space of this flowthread
-    // to the containing coordinate space. The inline position cannot affect the block
-    // position, so we don't bother calculating it.
+    // We're walking out of a flowthread here. This flow thread is not in the
+    // containing block chain, so we need to convert the position from the
+    // coordinate space of this flowthread to the containing coordinate space.
+    // The inline position cannot affect the block position, so we don't bother
+    // calculating it.
     LayoutUnit dummyInlinePosition;
     toLayoutFlowThread(box).flowThreadToContainingCoordinateSpace(
         staticLogicalTop, dummyInlinePosition);
   }
   logicalTop.setValue(Fixed, staticLogicalTop - containerBlock->borderBefore());
 }
 
 void LayoutBox::computePositionedLogicalHeight(
     LogicalExtentComputedValues& computedValues) const {
   // The following is based off of the W3C Working Draft from April 11, 2006 of
   // CSS 2.1: Section 10.6.4 "Absolutely positioned, non-replaced elements"
   // <http://www.w3.org/TR/2005/WD-CSS21-20050613/visudet.html#abs-non-replaced-height>
-  // (block-style-comments in this function and in computePositionedLogicalHeightUsing()
+  // (block-style-comments in this function and in
+  // computePositionedLogicalHeightUsing()
   // correspond to text from the spec)
 
-  // We don't use containingBlock(), since we may be positioned by an enclosing relpositioned inline.
+  // We don't use containingBlock(), since we may be positioned by an enclosing
+  // relpositioned inline.
   const LayoutBoxModelObject* containerBlock =
       toLayoutBoxModelObject(container());
 
   const LayoutUnit containerLogicalHeight =
       containingBlockLogicalHeightForPositioned(containerBlock);
 
   const ComputedStyle& styleToUse = styleRef();
   const LayoutUnit bordersPlusPadding = borderAndPaddingLogicalHeight();
   const Length marginBefore = styleToUse.marginBefore();
   const Length marginAfter = styleToUse.marginAfter();
   Length logicalTopLength = styleToUse.logicalTop();
   Length logicalBottomLength = styleToUse.logicalBottom();
 
-  /*---------------------------------------------------------------------------*\
-     * For the purposes of this section and the next, the term "static position"
-     * (of an element) refers, roughly, to the position an element would have had
-     * in the normal flow. More precisely, the static position for 'top' is the
-     * distance from the top edge of the containing block to the top margin edge
-     * of a hypothetical box that would have been the first box of the element if
-     * its 'position' property had been 'static' and 'float' had been 'none'. The
-     * value is negative if the hypothetical box is above the containing block.
-     *
-     * But rather than actually calculating the dimensions of that hypothetical
-     * box, user agents are free to make a guess at its probable position.
-     *
-     * For the purposes of calculating the static position, the containing block
-     * of fixed positioned elements is the initial containing block instead of
-     * the viewport.
-    \*---------------------------------------------------------------------------*/
-
+  // ---------------------------------------------------------------------------
+  // For the purposes of this section and the next, the term "static position"
+  // (of an element) refers, roughly, to the position an element would have had
+  // in the normal flow. More precisely, the static position for 'top' is the
+  // distance from the top edge of the containing block to the top margin edge
+  // of a hypothetical box that would have been the first box of the element if
+  // its 'position' property had been 'static' and 'float' had been 'none'. The
+  // value is negative if the hypothetical box is above the containing block.
+  //
+  // But rather than actually calculating the dimensions of that hypothetical
+  // box, user agents are free to make a guess at its probable position.
+  //
+  // For the purposes of calculating the static position, the containing block
+  // of fixed positioned elements is the initial containing block instead of
+  // the viewport.
+  // ---------------------------------------------------------------------------
   // see FIXME 1
   // Calculate the static distance if needed.
   computeBlockStaticDistance(logicalTopLength, logicalBottomLength, this,
                              containerBlock);
 
   // Calculate constraint equation values for 'height' case.
   LayoutUnit logicalHeight = computedValues.m_extent;
   computePositionedLogicalHeightUsing(
       MainOrPreferredSize, styleToUse.logicalHeight(), containerBlock,
       containerLogicalHeight, bordersPlusPadding, logicalHeight,
       logicalTopLength, logicalBottomLength, marginBefore, marginAfter,
       computedValues);
 
-  // Avoid doing any work in the common case (where the values of min-height and max-height are their defaults).
+  // Avoid doing any work in the common case (where the values of min-height and
+  // max-height are their defaults).
   // see FIXME 2
 
   // Calculate constraint equation values for 'max-height' case.
   if (!styleToUse.logicalMaxHeight().isMaxSizeNone()) {
     LogicalExtentComputedValues maxValues;
 
     computePositionedLogicalHeightUsing(MaxSize, styleToUse.logicalMaxHeight(),
                                         containerBlock, containerLogicalHeight,
                                         bordersPlusPadding, logicalHeight,
                                         logicalTopLength, logicalBottomLength,
@@ skipping 32 matching lines @@
   // Set final height value.
   computedValues.m_extent += bordersPlusPadding;
 }
 
 void LayoutBox::computeLogicalTopPositionedOffset(
     LayoutUnit& logicalTopPos,
     const LayoutBox* child,
     LayoutUnit logicalHeightValue,
     const LayoutBoxModelObject* containerBlock,
     LayoutUnit containerLogicalHeight) {
-  // Deal with differing writing modes here.  Our offset needs to be in the containing block's coordinate space. If the containing block is flipped
-  // along this axis, then we need to flip the coordinate.  This can only happen if the containing block is both a flipped mode and perpendicular to us.
+  // Deal with differing writing modes here. Our offset needs to be in the
+  // containing block's coordinate space. If the containing block is flipped
+  // along this axis, then we need to flip the coordinate.  This can only happen
+  // if the containing block is both a flipped mode and perpendicular to us.
   if ((child->style()->isFlippedBlocksWritingMode() &&
        child->isHorizontalWritingMode() !=
            containerBlock->isHorizontalWritingMode()) ||
       (child->style()->isFlippedBlocksWritingMode() !=
            containerBlock->style()->isFlippedBlocksWritingMode() &&
        child->isHorizontalWritingMode() ==
            containerBlock->isHorizontalWritingMode()))
     logicalTopPos = containerLogicalHeight - logicalHeightValue - logicalTopPos;
 
-  // Our offset is from the logical bottom edge in a flipped environment, e.g., right for vertical-rl.
+  // Our offset is from the logical bottom edge in a flipped environment, e.g.,
+  // right for vertical-rl.
   if (containerBlock->style()->isFlippedBlocksWritingMode() &&
       child->isHorizontalWritingMode() ==
           containerBlock->isHorizontalWritingMode()) {
     if (child->isHorizontalWritingMode())
       logicalTopPos += containerBlock->borderBottom();
     else
       logicalTopPos += containerBlock->borderRight();
   } else {
     if (child->isHorizontalWritingMode())
       logicalTopPos += containerBlock->borderTop();
@@ skipping 43 matching lines @@
   } else {
     if (logicalHeightLength.isIntrinsic())
       resolvedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(
           logicalHeightLength, contentLogicalHeight, bordersPlusPadding);
     else
       resolvedLogicalHeight = adjustContentBoxLogicalHeightForBoxSizing(
           valueForLength(logicalHeightLength, containerLogicalHeight));
   }
 
   if (!logicalTopIsAuto && !logicalHeightIsAuto && !logicalBottomIsAuto) {
-    /*-----------------------------------------------------------------------*\
-         * If none of the three are 'auto': If both 'margin-top' and 'margin-
-         * bottom' are 'auto', solve the equation under the extra constraint that
-         * the two margins get equal values. If one of 'margin-top' or 'margin-
-         * bottom' is 'auto', solve the equation for that value. If the values
-         * are over-constrained, ignore the value for 'bottom' and solve for that
-         * value.
-        \*-----------------------------------------------------------------------*/
+    // -------------------------------------------------------------------------
+    // If none of the three are 'auto': If both 'margin-top' and 'margin-bottom'
+    // are 'auto', solve the equation under the extra constraint that the two
+    // margins get equal values. If one of 'margin-top' or 'margin- bottom' is
+    // 'auto', solve the equation for that value. If the values are over-
+    // constrained, ignore the value for 'bottom' and solve for that value.
+    // -------------------------------------------------------------------------
     // NOTE:  It is not necessary to solve for 'bottom' in the over constrained
     // case because the value is not used for any further calculations.
 
     logicalHeightValue = resolvedLogicalHeight;
     logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
 
     const LayoutUnit availableSpace =
         containerLogicalHeight -
         (logicalTopValue + logicalHeightValue +
          valueForLength(logicalBottom, containerLogicalHeight) +
@@ skipping 22 matching lines @@
       computedValues.m_margins.m_after =
           availableSpace - computedValues.m_margins.m_before;
     } else {
       // Over-constrained, (no need solve for bottom)
       computedValues.m_margins.m_before =
           valueForLength(marginBefore, containerRelativeLogicalWidth);
       computedValues.m_margins.m_after =
           valueForLength(marginAfter, containerRelativeLogicalWidth);
     }
   } else {
-    /*--------------------------------------------------------------------*\
-         * Otherwise, set 'auto' values for 'margin-top' and 'margin-bottom'
-         * to 0, and pick the one of the following six rules that applies.
-         *
-         * 1. 'top' and 'height' are 'auto' and 'bottom' is not 'auto', then
-         *    the height is based on the content, and solve for 'top'.
-         *
-         *              OMIT RULE 2 AS IT SHOULD NEVER BE HIT
-         * ------------------------------------------------------------------
-         * 2. 'top' and 'bottom' are 'auto' and 'height' is not 'auto', then
-         *    set 'top' to the static position, and solve for 'bottom'.
-         * ------------------------------------------------------------------
-         *
-         * 3. 'height' and 'bottom' are 'auto' and 'top' is not 'auto', then
-         *    the height is based on the content, and solve for 'bottom'.
-         * 4. 'top' is 'auto', 'height' and 'bottom' are not 'auto', and
-         *    solve for 'top'.
-         * 5. 'height' is 'auto', 'top' and 'bottom' are not 'auto', and
-         *    solve for 'height'.
-         * 6. 'bottom' is 'auto', 'top' and 'height' are not 'auto', and
-         *    solve for 'bottom'.
-        \*--------------------------------------------------------------------*/
+    // -------------------------------------------------------------------------
+    // Otherwise, set 'auto' values for 'margin-top' and 'margin-bottom'
+    // to 0, and pick the one of the following six rules that applies.
+    //
+    // 1. 'top' and 'height' are 'auto' and 'bottom' is not 'auto', then
+    //    the height is based on the content, and solve for 'top'.
+    //
+    //              OMIT RULE 2 AS IT SHOULD NEVER BE HIT
+    // ------------------------------------------------------------------
+    // 2. 'top' and 'bottom' are 'auto' and 'height' is not 'auto', then
+    //    set 'top' to the static position, and solve for 'bottom'.
+    // ------------------------------------------------------------------
+    //
+    // 3. 'height' and 'bottom' are 'auto' and 'top' is not 'auto', then
+    //    the height is based on the content, and solve for 'bottom'.
+    // 4. 'top' is 'auto', 'height' and 'bottom' are not 'auto', and
+    //    solve for 'top'.
+    // 5. 'height' is 'auto', 'top' and 'bottom' are not 'auto', and
+    //    solve for 'height'.
+    // 6. 'bottom' is 'auto', 'top' and 'height' are not 'auto', and
+    //    solve for 'bottom'.
+    // -------------------------------------------------------------------------
     // NOTE: For rules 3 and 6 it is not necessary to solve for 'bottom'
     // because the value is not used for any further calculations.
 
     // Calculate margins, 'auto' margins are ignored.
     computedValues.m_margins.m_before =
         minimumValueForLength(marginBefore, containerRelativeLogicalWidth);
     computedValues.m_margins.m_after =
         minimumValueForLength(marginAfter, containerRelativeLogicalWidth);
 
     const LayoutUnit availableSpace =
@@ skipping 42 matching lines @@
   computedValues.m_position =
       logicalTopValue + computedValues.m_margins.m_before;
   computeLogicalTopPositionedOffset(computedValues.m_position, this,
                                     logicalHeightValue, containerBlock,
                                     containerLogicalHeight);
 }
 
 LayoutRect LayoutBox::localCaretRect(InlineBox* box,
                                      int caretOffset,
                                      LayoutUnit* extraWidthToEndOfLine) {
-  // VisiblePositions at offsets inside containers either a) refer to the positions before/after
-  // those containers (tables and select elements) or b) refer to the position inside an empty block.
+  // VisiblePositions at offsets inside containers either a) refer to the
+  // positions before/after those containers (tables and select elements) or
+  // b) refer to the position inside an empty block.
   // They never refer to children.
-  // FIXME: Paint the carets inside empty blocks differently than the carets before/after elements.
+  // FIXME: Paint the carets inside empty blocks differently than the carets
+  // before/after elements.
 
   LayoutRect rect(location(), LayoutSize(caretWidth(), size().height()));
   bool ltr =
       box ? box->isLeftToRightDirection() : style()->isLeftToRightDirection();
 
   if ((!caretOffset) ^ ltr)
     rect.move(LayoutSize(size().width() - caretWidth(), LayoutUnit()));
 
   if (box) {
     RootInlineBox& rootBox = box->root();
     LayoutUnit top = rootBox.lineTop();
     rect.setY(top);
     rect.setHeight(rootBox.lineBottom() - top);
   }
 
   // If height of box is smaller than font height, use the latter one,
   // otherwise the caret might become invisible.
   //
-  // Also, if the box is not an atomic inline-level element, always use the font height.
-  // This prevents the "big caret" bug described in:
-  // <rdar://problem/3777804> Deleting all content in a document can result in giant tall-as-window insertion point
+  // Also, if the box is not an atomic inline-level element, always use the font
+  // height. This prevents the "big caret" bug described in:
+  // <rdar://problem/3777804> Deleting all content in a document can result in
+  // giant tall-as-window insertion point
   //
   // FIXME: ignoring :first-line, missing good reason to take care of
   LayoutUnit fontHeight = LayoutUnit(style()->getFontMetrics().height());
   if (fontHeight > rect.height() || (!isAtomicInlineLevel() && !isTable()))
     rect.setHeight(fontHeight);
 
   if (extraWidthToEndOfLine)
     *extraWidthToEndOfLine = location().x() + size().width() - rect.maxX();
 
   // Move to local coords
   rect.moveBy(-location());
 
   // FIXME: Border/padding should be added for all elements but this workaround
   // is needed because we use offsets inside an "atomic" element to represent
   // positions before and after the element in deprecated editing offsets.
   if (node() &&
       !(editingIgnoresContent(node()) || isDisplayInsideTable(node()))) {
     rect.setX(rect.x() + borderLeft() + paddingLeft());
     rect.setY(rect.y() + paddingTop() + borderTop());
   }
 
   if (!isHorizontalWritingMode())
     return rect.transposedRect();
 
   return rect;
 }
 
 PositionWithAffinity LayoutBox::positionForPoint(const LayoutPoint& point) {
-  // no children...return this layout object's element, if there is one, and offset 0
+  // no children...return this layout object's element, if there is one, and
+  // offset 0
   LayoutObject* firstChild = slowFirstChild();
   if (!firstChild)
     return createPositionWithAffinity(
         nonPseudoNode() ? firstPositionInOrBeforeNode(nonPseudoNode())
                         : Position());
 
   if (isTable() && nonPseudoNode()) {
     LayoutUnit right = size().width() - verticalScrollbarWidth();
     LayoutUnit bottom = size().height() - horizontalScrollbarHeight();
 
@@ skipping 34 matching lines @@
     LayoutUnit right = left + layoutBox->contentWidth();
 
     if (point.x() <= right && point.x() >= left && point.y() <= top &&
         point.y() >= bottom) {
       if (layoutBox->isTableRow())
         return layoutBox->positionForPoint(point + adjustedPoint -
                                            layoutBox->locationOffset());
       return layoutBox->positionForPoint(point - layoutBox->locationOffset());
     }
 
-    // Find the distance from (x, y) to the box.  Split the space around the box into 8 pieces
-    // and use a different compare depending on which piece (x, y) is in.
+    // Find the distance from (x, y) to the box.  Split the space around the box
+    // into 8 pieces and use a different compare depending on which piece (x, y)
+    // is in.
     LayoutPoint cmp;
     if (point.x() > right) {
       if (point.y() < top)
         cmp = LayoutPoint(right, top);
       else if (point.y() > bottom)
         cmp = LayoutPoint(right, bottom);
       else
         cmp = LayoutPoint(right, point.y());
     } else if (point.x() < left) {
       if (point.y() < top)
@@ skipping 21 matching lines @@
 
   if (closestLayoutObject)
     return closestLayoutObject->positionForPoint(
         adjustedPoint - closestLayoutObject->locationOffset());
   return createPositionWithAffinity(
       firstPositionInOrBeforeNode(nonPseudoNode()));
 }
 
 DISABLE_CFI_PERF
 bool LayoutBox::shrinkToAvoidFloats() const {
-  // Floating objects don't shrink.  Objects that don't avoid floats don't shrink.
+  // Floating objects don't shrink.  Objects that don't avoid floats don't
+  // shrink.
   if (isInline() || !avoidsFloats() || isFloating())
     return false;
 
   // Only auto width objects can possibly shrink to avoid floats.
   return style()->width().isAuto();
 }
 
 static bool shouldBeConsideredAsReplaced(Node* node) {
-  // Checkboxes and radioboxes are not isAtomicInlineLevel() nor do they have their own layoutObject in which to override avoidFloats().
+  // Checkboxes and radioboxes are not isAtomicInlineLevel() nor do they have
+  // their own layoutObject in which to override avoidFloats().
   return node && node->isElementNode() &&
          (toElement(node)->isFormControlElement() ||
           isHTMLImageElement(toElement(node)));
 }
 
 DISABLE_CFI_PERF
 bool LayoutBox::avoidsFloats() const {
   return isAtomicInlineLevel() || shouldBeConsideredAsReplaced(node()) ||
          hasOverflowClip() || isHR() || isLegend() || isWritingModeRoot() ||
          isFlexItemIncludingDeprecated() || style()->containsPaint() ||
@@ skipping 65 matching lines @@
   }
 
   if (style()->hasBorderImageOutsets()) {
     LayoutRectOutsets borderOutsets = style()->borderImageOutsets();
     top = std::max(top, borderOutsets.top());
     right = std::max(right, borderOutsets.right());
     bottom = std::max(bottom, borderOutsets.bottom());
     left = std::max(left, borderOutsets.left());
   }
 
-  // Box-shadow and border-image-outsets are in physical direction. Flip into block direction.
+  // Box-shadow and border-image-outsets are in physical direction. Flip into
+  // block direction.
   if (UNLIKELY(hasFlippedBlocksWritingMode()))
     std::swap(left, right);
 
   if (style()->hasOutline()) {
     Vector<LayoutRect> outlineRects;
     // The result rects are in coordinates of this object's border box.
     addOutlineRects(outlineRects, LayoutPoint(),
                     outlineRectsShouldIncludeBlockVisualOverflow());
     LayoutRect rect = unionRectEvenIfEmpty(outlineRects);
     int outlineOutset = style()->outlineOutsetExtent();
     top = std::max(top, -rect.y() + outlineOutset);
     right = std::max(right, rect.maxX() - size().width() + outlineOutset);
     bottom = std::max(bottom, rect.maxY() - size().height() + outlineOutset);
     left = std::max(left, -rect.x() + outlineOutset);
   }
 
   return LayoutRectOutsets(top, right, bottom, left);
 }
 
 DISABLE_CFI_PERF
 void LayoutBox::addOverflowFromChild(LayoutBox* child,
                                      const LayoutSize& delta) {
   // Never allow flow threads to propagate overflow up to a parent.
   if (child->isLayoutFlowThread())
     return;
 
-  // Only propagate layout overflow from the child if the child isn't clipping its overflow.  If it is, then
-  // its overflow is internal to it, and we don't care about it.  layoutOverflowRectForPropagation takes care of this
-  // and just propagates the border box rect instead.
+  // Only propagate layout overflow from the child if the child isn't clipping
+  // its overflow.  If it is, then its overflow is internal to it, and we don't
+  // care about it. layoutOverflowRectForPropagation takes care of this and just
+  // propagates the border box rect instead.
   LayoutRect childLayoutOverflowRect =
       child->layoutOverflowRectForPropagation(styleRef());
   childLayoutOverflowRect.move(delta);
   addLayoutOverflow(childLayoutOverflowRect);
 
-  // Add in visual overflow from the child.  Even if the child clips its overflow, it may still
-  // have visual overflow of its own set from box shadows or reflections.  It is unnecessary to propagate this
-  // overflow if we are clipping our own overflow.
+  // Add in visual overflow from the child.  Even if the child clips its
+  // overflow, it may still have visual overflow of its own set from box shadows
+  // or reflections. It is unnecessary to propagate this overflow if we are
+  // clipping our own overflow.
   if (child->hasSelfPaintingLayer())
     return;
   LayoutRect childVisualOverflowRect =
       child->visualOverflowRectForPropagation(styleRef());
   childVisualOverflowRect.move(delta);
   addContentsVisualOverflow(childVisualOverflowRect);
 }
 
 bool LayoutBox::hasTopOverflow() const {
   return !style()->isLeftToRightDirection() && !isHorizontalWritingMode();
 }
 
 bool LayoutBox::hasLeftOverflow() const {
   return !style()->isLeftToRightDirection() && isHorizontalWritingMode();
 }
 
 DISABLE_CFI_PERF
 void LayoutBox::addLayoutOverflow(const LayoutRect& rect) {
   if (rect.isEmpty())
     return;
 
   LayoutRect clientBox = noOverflowRect();
   if (clientBox.contains(rect))
     return;
 
-  // For overflow clip objects, we don't want to propagate overflow into unreachable areas.
+  // For overflow clip objects, we don't want to propagate overflow into
+  // unreachable areas.
   LayoutRect overflowRect(rect);
   if (hasOverflowClip() || isLayoutView()) {
-    // Overflow is in the block's coordinate space and thus is flipped for vertical-rl writing
-    // mode.  At this stage that is actually a simplification, since we can treat vertical-lr/rl
+    // Overflow is in the block's coordinate space and thus is flipped for
+    // vertical-rl writing
+    // mode.  At this stage that is actually a simplification, since we can
+    // treat vertical-lr/rl
     // as the same.
     if (hasTopOverflow())
       overflowRect.shiftMaxYEdgeTo(
           std::min(overflowRect.maxY(), clientBox.maxY()));
     else
       overflowRect.shiftYEdgeTo(std::max(overflowRect.y(), clientBox.y()));
     if (hasLeftOverflow())
       overflowRect.shiftMaxXEdgeTo(
           std::min(overflowRect.maxX(), clientBox.maxX()));
     else
       overflowRect.shiftXEdgeTo(std::max(overflowRect.x(), clientBox.x()));
 
-    // Now re-test with the adjusted rectangle and see if it has become unreachable or fully
+    // Now re-test with the adjusted rectangle and see if it has become
+    // unreachable or fully
     // contained.
     if (clientBox.contains(overflowRect) || overflowRect.isEmpty())
       return;
   }
 
   if (!m_overflow)
     m_overflow = wrapUnique(new BoxOverflowModel(clientBox, borderBoxRect()));
 
   m_overflow->addLayoutOverflow(overflowRect);
 }
 
 void LayoutBox::addSelfVisualOverflow(const LayoutRect& rect) {
   if (rect.isEmpty())
     return;
 
   LayoutRect borderBox = borderBoxRect();
   if (borderBox.contains(rect))
     return;
 
   if (!m_overflow)
     m_overflow = wrapUnique(new BoxOverflowModel(noOverflowRect(), borderBox));
 
   m_overflow->addSelfVisualOverflow(rect);
 }
 
 void LayoutBox::addContentsVisualOverflow(const LayoutRect& rect) {
   if (rect.isEmpty())
     return;
 
-  // If hasOverflowClip() we always save contents visual overflow because we need it
+  // If hasOverflowClip() we always save contents visual overflow because we
+  // need it
   // e.g. to determine whether to apply rounded corner clip on contents.
-  // Otherwise we save contents visual overflow only if it overflows the border box.
+  // Otherwise we save contents visual overflow only if it overflows the border
+  // box.
   LayoutRect borderBox = borderBoxRect();
   if (!hasOverflowClip() && borderBox.contains(rect))
     return;
 
   if (!m_overflow)
     m_overflow = wrapUnique(new BoxOverflowModel(noOverflowRect(), borderBox));
   m_overflow->addContentsVisualOverflow(rect);
 }
 
 void LayoutBox::clearLayoutOverflow() {
   if (!m_overflow)
     return;
 
   if (!hasSelfVisualOverflow() && contentsVisualOverflowRect().isEmpty()) {
     clearAllOverflows();
     return;
   }
 
   m_overflow->setLayoutOverflow(noOverflowRect());
 }
 
 bool LayoutBox::percentageLogicalHeightIsResolvable() const {
   Length fakeLength(100, Percent);
   return computePercentageLogicalHeight(fakeLength) != -1;
 }
 
 DISABLE_CFI_PERF
 bool LayoutBox::hasUnsplittableScrollingOverflow() const {
-  // We will paginate as long as we don't scroll overflow in the pagination direction.
+  // We will paginate as long as we don't scroll overflow in the pagination
+  // direction.
   bool isHorizontal = isHorizontalWritingMode();
   if ((isHorizontal && !scrollsOverflowY()) ||
       (!isHorizontal && !scrollsOverflowX()))
     return false;
 
-  // Fragmenting scrollbars is only problematic in interactive media, e.g. multicol on a
-  // screen. If we're printing, which is non-interactive media, we should allow objects with
-  // non-visible overflow to be paginated as normally.
+  // Fragmenting scrollbars is only problematic in interactive media, e.g.
+  // multicol on a screen. If we're printing, which is non-interactive media, we
+  // should allow objects with non-visible overflow to be paginated as normally.
   if (document().printing())
     return false;
 
-  // We do have overflow. We'll still be willing to paginate as long as the block
-  // has auto logical height, auto or undefined max-logical-height and a zero or auto min-logical-height.
-  // Note this is just a heuristic, and it's still possible to have overflow under these
-  // conditions, but it should work out to be good enough for common cases. Paginating overflow
-  // with scrollbars present is not the end of the world and is what we used to do in the old model anyway.
+  // We do have overflow. We'll still be willing to paginate as long as the
+  // block has auto logical height, auto or undefined max-logical-height and a
+  // zero or auto min-logical-height.
+  // Note this is just a heuristic, and it's still possible to have overflow
+  // under these conditions, but it should work out to be good enough for common
+  // cases. Paginating overflow with scrollbars present is not the end of the
+  // world and is what we used to do in the old model anyway.
   return !style()->logicalHeight().isIntrinsicOrAuto() ||
          (!style()->logicalMaxHeight().isIntrinsicOrAuto() &&
           !style()->logicalMaxHeight().isMaxSizeNone() &&
           (!style()->logicalMaxHeight().isPercentOrCalc() ||
            percentageLogicalHeightIsResolvable())) ||
          (!style()->logicalMinHeight().isIntrinsicOrAuto() &&
           style()->logicalMinHeight().isPositive() &&
           (!style()->logicalMinHeight().isPercentOrCalc() ||
            percentageLogicalHeightIsResolvable()));
 }
@@ skipping 61 matching lines @@
 
 DISABLE_CFI_PERF
 LayoutRect LayoutBox::visualOverflowRectForPropagation(
     const ComputedStyle& parentStyle) const {
   // If the writing modes of the child and parent match, then we don't have to
   // do anything fancy. Just return the result.
   LayoutRect rect = visualOverflowRect();
   if (parentStyle.getWritingMode() == style()->getWritingMode())
     return rect;
 
-  // We are putting ourselves into our parent's coordinate space.  If there is a flipped block mismatch
-  // in a particular axis, then we have to flip the rect along that axis.
+  // We are putting ourselves into our parent's coordinate space. If there is a
+  // flipped block mismatch in a particular axis, then we have to flip the rect
+  // along that axis.
   if (style()->getWritingMode() == RightToLeftWritingMode ||
       parentStyle.getWritingMode() == RightToLeftWritingMode)
     rect.setX(size().width() - rect.maxX());
 
   return rect;
 }
 
 DISABLE_CFI_PERF
 LayoutRect LayoutBox::logicalLayoutOverflowRectForPropagation(
     const ComputedStyle& parentStyle) const {
   LayoutRect rect = layoutOverflowRectForPropagation(parentStyle);
   if (!parentStyle.isHorizontalWritingMode())
     return rect.transposedRect();
   return rect;
 }
 
 DISABLE_CFI_PERF
 LayoutRect LayoutBox::layoutOverflowRectForPropagation(
     const ComputedStyle& parentStyle) const {
   // Only propagate interior layout overflow if we don't clip it.
   LayoutRect rect = borderBoxRect();
-  // We want to include the margin, but only when it adds height. Quirky margins don't contribute height
-  // nor do the margins of self-collapsing blocks.
+  // We want to include the margin, but only when it adds height. Quirky margins
+  // don't contribute height nor do the margins of self-collapsing blocks.
   if (!styleRef().hasMarginAfterQuirk() && !isSelfCollapsingBlock())
     rect.expand(isHorizontalWritingMode()
                     ? LayoutSize(LayoutUnit(), marginAfter())
                     : LayoutSize(marginAfter(), LayoutUnit()));
 
   if (!hasOverflowClip())
     rect.unite(layoutOverflowRect());
 
   bool hasTransform = hasLayer() && layer()->transform();
   if (isInFlowPositioned() || hasTransform) {
-    // If we are relatively positioned or if we have a transform, then we have to convert
-    // this rectangle into physical coordinates, apply relative positioning and transforms
-    // to it, and then convert it back.
+    // If we are relatively positioned or if we have a transform, then we have
+    // to convert this rectangle into physical coordinates, apply relative
+    // positioning and transforms to it, and then convert it back.
     flipForWritingMode(rect);
 
     if (hasTransform)
       rect = layer()->currentTransform().mapRect(rect);
 
     if (isInFlowPositioned())
       rect.move(offsetForInFlowPosition());
 
     // Now we need to flip back.
     flipForWritingMode(rect);
   }
 
   // If the writing modes of the child and parent match, then we don't have to
   // do anything fancy. Just return the result.
   if (parentStyle.getWritingMode() == style()->getWritingMode())
     return rect;
 
-  // We are putting ourselves into our parent's coordinate space.  If there is a flipped block mismatch
-  // in a particular axis, then we have to flip the rect along that axis.
+  // We are putting ourselves into our parent's coordinate space. If there is a
+  // flipped block mismatch in a particular axis, then we have to flip the rect
+  // along that axis.
   if (style()->getWritingMode() == RightToLeftWritingMode ||
       parentStyle.getWritingMode() == RightToLeftWritingMode)
     rect.setX(size().width() - rect.maxX());
 
   return rect;
 }
 
 DISABLE_CFI_PERF
 LayoutRect LayoutBox::noOverflowRect() const {
-  // Because of the special coordinate system used for overflow rectangles and many other
-  // rectangles (not quite logical, not quite physical), we need to flip the block progression
-  // coordinate in vertical-rl writing mode. In other words, the rectangle returned is physical,
-  // except for the block direction progression coordinate (x in vertical writing mode), which is
-  // always "logical top". Apart from the flipping, this method does the same thing as
+  // Because of the special coordinate system used for overflow rectangles and
+  // many other rectangles (not quite logical, not quite physical), we need to
+  // flip the block progression coordinate in vertical-rl writing mode. In other
+  // words, the rectangle returned is physical, except for the block direction
+  // progression coordinate (x in vertical writing mode), which is always
+  // "logical top". Apart from the flipping, this method does the same thing as
   // clientBoxRect().
 
   const int scrollBarWidth = verticalScrollbarWidth();
   const int scrollBarHeight = horizontalScrollbarHeight();
   LayoutUnit left(
       borderLeft() +
       (shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? scrollBarWidth : 0));
   LayoutUnit top(borderTop());
   LayoutUnit right(borderRight());
   LayoutUnit bottom(borderBottom());
   LayoutRect rect(left, top, size().width() - left - right,
                   size().height() - top - bottom);
   flipForWritingMode(rect);
-  // Subtract space occupied by scrollbars. Order is important here: first flip, then subtract
-  // scrollbars. This may seem backwards and weird, since one would think that a vertical
-  // scrollbar at the physical right in vertical-rl ought to be at the logical left (physical
-  // right), between the logical left (physical right) border and the logical left (physical
-  // right) padding. But this is how the rest of the code expects us to behave. This is highly
+  // Subtract space occupied by scrollbars. Order is important here: first flip,
+  // then subtract scrollbars. This may seem backwards and weird, since one
+  // would think that a vertical scrollbar at the physical right in vertical-rl
+  // ought to be at the logical left (physical right), between the logical left
+  // (physical right) border and the logical left (physical right) padding. But
+  // this is how the rest of the code expects us to behave. This is highly
   // related to https://bugs.webkit.org/show_bug.cgi?id=76129
-  // FIXME: when the above mentioned bug is fixed, it should hopefully be possible to call
-  // clientBoxRect() or paddingBoxRect() in this method, rather than fiddling with the edges on
-  // our own.
+  // FIXME: when the above mentioned bug is fixed, it should hopefully be
+  // possible to call clientBoxRect() or paddingBoxRect() in this method, rather
+  // than fiddling with the edges on our own.
   if (shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     rect.contract(0, scrollBarHeight);
   else
     rect.contract(scrollBarWidth, scrollBarHeight);
   return rect;
 }
 
 LayoutRect LayoutBox::visualOverflowRect() const {
   if (!m_overflow)
     return borderBoxRect();
@@ skipping 42 matching lines @@
 bool LayoutBox::hasRelativeLogicalHeight() const {
   return style()->logicalHeight().isPercentOrCalc() ||
          style()->logicalMinHeight().isPercentOrCalc() ||
          style()->logicalMaxHeight().isPercentOrCalc();
 }
 
 static void markBoxForRelayoutAfterSplit(LayoutBox* box) {
   // FIXME: The table code should handle that automatically. If not,
   // we should fix it and remove the table part checks.
   if (box->isTable()) {
-    // Because we may have added some sections with already computed column structures, we need to
-    // sync the table structure with them now. This avoids crashes when adding new cells to the table.
+    // Because we may have added some sections with already computed column
+    // structures, we need to sync the table structure with them now. This
+    // avoids crashes when adding new cells to the table.
     toLayoutTable(box)->forceSectionsRecalc();
   } else if (box->isTableSection()) {
     toLayoutTableSection(box)->setNeedsCellRecalc();
   }
 
   box->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReason::AnonymousBlockChange);
 }
 
 static void collapseLoneAnonymousBlockChild(LayoutBox* parent,
@@ skipping 13 matching lines @@
   while (beforeChild->parent() != this) {
     LayoutBox* boxToSplit = toLayoutBox(beforeChild->parent());
     if (boxToSplit->slowFirstChild() != beforeChild &&
         boxToSplit->isAnonymous()) {
       // We have to split the parent box into two boxes and move children
       // from |beforeChild| to end into the new post box.
       LayoutBox* postBox = boxToSplit->createAnonymousBoxWithSameTypeAs(this);
       postBox->setChildrenInline(boxToSplit->childrenInline());
       LayoutBox* parentBox = toLayoutBox(boxToSplit->parent());
       // We need to invalidate the |parentBox| before inserting the new node
-      // so that the table paint invalidation logic knows the structure is dirty.
+      // so that the table paint invalidation logic knows the structure is
+      // dirty.
       // See for example LayoutTableCell:localOverflowRectForPaintInvalidation.
       markBoxForRelayoutAfterSplit(parentBox);
       parentBox->virtualChildren()->insertChildNode(parentBox, postBox,
                                                     boxToSplit->nextSibling());
       boxToSplit->moveChildrenTo(postBox, beforeChild, 0, true);
 
       LayoutObject* child = postBox->slowFirstChild();
       ASSERT(child);
       if (child && !child->nextSibling())
         collapseLoneAnonymousBlockChild(postBox, child);
       child = boxToSplit->slowFirstChild();
       ASSERT(child);
       if (child && !child->nextSibling())
         collapseLoneAnonymousBlockChild(boxToSplit, child);
 
       markBoxForRelayoutAfterSplit(boxToSplit);
       markBoxForRelayoutAfterSplit(postBox);
       boxAtTopOfNewBranch = postBox;
 
       beforeChild = postBox;
     } else {
       beforeChild = boxToSplit;
     }
   }
 
-  // Splitting the box means the left side of the container chain will lose any percent height descendants
-  // below |boxAtTopOfNewBranch| on the right hand side.
+  // Splitting the box means the left side of the container chain will lose any
+  // percent height descendants below |boxAtTopOfNewBranch| on the right hand
+  // side.
   if (boxAtTopOfNewBranch) {
     boxAtTopOfNewBranch->clearPercentHeightDescendants();
     markBoxForRelayoutAfterSplit(this);
   }
 
   ASSERT(beforeChild->parent() == this);
   return beforeChild;
 }
 
 LayoutUnit LayoutBox::offsetFromLogicalTopOfFirstPage() const {
   LayoutState* layoutState = view()->layoutState();
   if (!layoutState || !layoutState->isPaginated())
     return LayoutUnit();
 
   if (layoutState->layoutObject() == this) {
     LayoutSize offsetDelta =
         layoutState->layoutOffset() - layoutState->pageOffset();
     return isHorizontalWritingMode() ? offsetDelta.height()
                                      : offsetDelta.width();
   }
 
-  // A LayoutBlock always establishes a layout state, and this method is only meant to be called
-  // on the object currently being laid out.
+  // A LayoutBlock always establishes a layout state, and this method is only
+  // meant to be called on the object currently being laid out.
   ASSERT(!isLayoutBlock());
 
-  // In case this box doesn't establish a layout state, try the containing block.
+  // In case this box doesn't establish a layout state, try the containing
+  // block.
   LayoutBlock* containerBlock = containingBlock();
   ASSERT(layoutState->layoutObject() == containerBlock);
   return containerBlock->offsetFromLogicalTopOfFirstPage() + logicalTop();
 }
 
 void LayoutBox::setPageLogicalOffset(LayoutUnit offset) {
   if (!m_rareData && !offset)
     return;
   ensureRareData().m_pageLogicalOffset = offset;
 }
@@ skipping 166 matching lines @@
     return;
   ensureRareData().m_percentHeightContainer = container;
 }
 
 void LayoutBox::removeFromPercentHeightContainer() {
   if (!percentHeightContainer())
     return;
 
   ASSERT(percentHeightContainer()->hasPercentHeightDescendant(this));
   percentHeightContainer()->removePercentHeightDescendant(this);
-  // The above call should call this object's setPercentHeightContainer(nullptr).
+  // The above call should call this object's
+  // setPercentHeightContainer(nullptr).
   ASSERT(!percentHeightContainer());
 }
 
 void LayoutBox::clearPercentHeightDescendants() {
   for (LayoutObject* curr = slowFirstChild(); curr;
        curr = curr->nextInPreOrder(this)) {
     if (curr->isBox())
       toLayoutBox(curr)->removeFromPercentHeightContainer();
   }
 }
@@ skipping 12 matching lines @@
     PageBoundaryRule pageBoundaryRule) const {
   LayoutView* layoutView = view();
   offset += offsetFromLogicalTopOfFirstPage();
 
   LayoutFlowThread* flowThread = flowThreadContainingBlock();
   if (!flowThread) {
     LayoutUnit pageLogicalHeight = layoutView->pageLogicalHeight();
     LayoutUnit remainingHeight =
         pageLogicalHeight - intMod(offset, pageLogicalHeight);
     if (pageBoundaryRule == AssociateWithFormerPage) {
-      // An offset exactly at a page boundary will act as being part of the former page in
-      // question (i.e. no remaining space), rather than being part of the latter (i.e. one
-      // whole page length of remaining space).
+      // An offset exactly at a page boundary will act as being part of the
+      // former page in question (i.e. no remaining space), rather than being
+      // part of the latter (i.e. one whole page length of remaining space).
       remainingHeight = intMod(remainingHeight, pageLogicalHeight);
     }
     return remainingHeight;
   }
 
   return flowThread->pageRemainingLogicalHeightForOffset(offset,
                                                          pageBoundaryRule);
 }
 
 LayoutUnit LayoutBox::calculatePaginationStrutToFitContent(
     LayoutUnit offset,
     LayoutUnit strutToNextPage,
     LayoutUnit contentLogicalHeight) const {
   ASSERT(strutToNextPage ==
          pageRemainingLogicalHeightForOffset(offset, AssociateWithLatterPage));
   LayoutUnit nextPageLogicalTop = offset + strutToNextPage;
   if (pageLogicalHeightForOffset(nextPageLogicalTop) >= contentLogicalHeight)
-    return strutToNextPage;  // Content fits just fine in the next page or column.
+    return strutToNextPage;  // Content fits just fine in the next page or
+                             // column.
 
-  // Moving to the top of the next page or column doesn't result in enough space for the content
-  // that we're trying to fit. If we're in a nested fragmentation context, we may find enough
-  // space if we move to a column further ahead, by effectively breaking to the next outer
-  // fragmentainer.
+  // Moving to the top of the next page or column doesn't result in enough space
+  // for the content that we're trying to fit. If we're in a nested
+  // fragmentation context, we may find enough space if we move to a column
+  // further ahead, by effectively breaking to the next outer fragmentainer.
   LayoutFlowThread* flowThread = flowThreadContainingBlock();
   if (!flowThread) {
-    // If there's no flow thread, we're not nested. All pages have the same height. Give up.
+    // If there's no flow thread, we're not nested. All pages have the same
+    // height. Give up.
     return strutToNextPage;
   }
-  // Start searching for a suitable offset at the top of the next page or column.
+  // Start searching for a suitable offset at the top of the next page or
+  // column.
   LayoutUnit flowThreadOffset =
       offsetFromLogicalTopOfFirstPage() + nextPageLogicalTop;
   return strutToNextPage +
          flowThread->nextLogicalTopForUnbreakableContent(flowThreadOffset,
                                                          contentLogicalHeight) -
          flowThreadOffset;
 }
 
 LayoutBox* LayoutBox::snapContainer() const {
   return m_rareData ? m_rareData->m_snapContainer : nullptr;
@@ skipping 39 matching lines @@
   LayoutRect rect = frameRect();
 
   LayoutBlock* block = containingBlock();
   if (block)
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink