Re-land Reformat comments in core/layout up until LayoutBox

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
+ *               All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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 59 matching lines @@
 // This map is populated during layout. It is kept across layouts to handle
 // that we skip unchanged sub-trees during layout, in such a way that we are
 // able to lay out deeply nested out-of-flow descendants if their containing
 // block got laid out. The map could be invalidated during style change but
 // keeping track of containing blocks at that time is complicated (we are in
 // the middle of recomputing the style so we can't rely on any of its
 // information), which is why it's easier to just update it for every layout.
 static TrackedDescendantsMap* gPositionedDescendantsMap = nullptr;
 static TrackedContainerMap* gPositionedContainerMap = nullptr;
 
-// This map keeps track of the descendants whose 'height' is percentage associated
-// with a containing block. Like |gPositionedDescendantsMap|, it is also recomputed
-// for every layout (see the comment above about why).
+// This map keeps track of the descendants whose 'height' is percentage
+// associated with a containing block. Like |gPositionedDescendantsMap|, it is
+// also recomputed for every layout (see the comment above about why).
 static TrackedDescendantsMap* gPercentHeightDescendantsMap = nullptr;
 
 LayoutBlock::LayoutBlock(ContainerNode* node)
     : LayoutBox(node),
       m_hasMarginBeforeQuirk(false),
       m_hasMarginAfterQuirk(false),
       m_beingDestroyed(false),
       m_hasMarkupTruncation(false),
       m_widthAvailableToChildrenChanged(false),
       m_heightAvailableToChildrenChanged(false),
@@ skipping 54 matching lines @@
         oldStyle->canContainAbsolutePositionObjects();
     bool newStyleContainsFixedPosition =
         newStyle.canContainFixedPositionObjects();
     bool newStyleContainsAbsolutePosition =
         newStyleContainsFixedPosition ||
         newStyle.canContainAbsolutePositionObjects();
 
     if ((oldStyleContainsFixedPosition && !newStyleContainsFixedPosition) ||
         (oldStyleContainsAbsolutePosition &&
          !newStyleContainsAbsolutePosition)) {
-      // Clear our positioned objects list. Our absolute and fixed positioned descendants will be
-      // inserted into our containing block's positioned objects list during layout.
+      // Clear our positioned objects list. Our absolute and fixed positioned
+      // descendants will be inserted into our containing block's positioned
+      // objects list during layout.
       removePositionedObjects(nullptr, NewContainingBlock);
     }
     if (!oldStyleContainsAbsolutePosition && newStyleContainsAbsolutePosition) {
-      // Remove our absolutely positioned descendants from their current containing block.
+      // Remove our absolutely positioned descendants from their current
+      // containing block.
       // They will be inserted into our positioned objects list during layout.
       if (LayoutBlock* cb = containingBlockForAbsolutePosition())
         cb->removePositionedObjects(this, NewContainingBlock);
     }
     if (!oldStyleContainsFixedPosition && newStyleContainsFixedPosition) {
-      // Remove our fixed positioned descendants from their current containing block.
+      // Remove our fixed positioned descendants from their current containing
+      // block.
       // They will be inserted into our positioned objects list during layout.
       if (LayoutBlock* cb = containerForFixedPosition())
         cb->removePositionedObjects(this, NewContainingBlock);
     }
   }
 
   LayoutBox::styleWillChange(diff, newStyle);
 }
 
 enum LogicalExtent { LogicalWidth, LogicalHeight };
@@ skipping 16 matching lines @@
 
 void LayoutBlock::styleDidChange(StyleDifference diff,
                                  const ComputedStyle* oldStyle) {
   LayoutBox::styleDidChange(diff, oldStyle);
 
   const ComputedStyle& newStyle = styleRef();
 
   if (oldStyle && parent()) {
     if (oldStyle->position() != newStyle.position() &&
         newStyle.position() != StaticPosition) {
-      // In LayoutObject::styleWillChange() we already removed ourself from our old containing
-      // block's positioned descendant list, and we will be inserted to the new containing
-      // block's list during layout. However the positioned descendant layout logic assumes
-      // layout objects to obey parent-child order in the list. Remove our descendants here
-      // so they will be re-inserted after us.
+      // In LayoutObject::styleWillChange() we already removed ourself from our
+      // old containing block's positioned descendant list, and we will be
+      // inserted to the new containing block's list during layout. However the
+      // positioned descendant layout logic assumes layout objects to obey
+      // parent-child order in the list. Remove our descendants here so they
+      // will be re-inserted after us.
       if (LayoutBlock* cb = containingBlock()) {
         cb->removePositionedObjects(this, NewContainingBlock);
         if (isOutOfFlowPositioned()) {
-          // Insert this object into containing block's positioned descendants list
-          // in case the parent won't layout. This is needed especially there are
-          // descendants scheduled for overflow recalc.
+          // Insert this object into containing block's positioned descendants
+          // list in case the parent won't layout. This is needed especially
+          // there are descendants scheduled for overflow recalc.
           cb->insertPositionedObject(this);
         }
       }
     }
   }
 
   if (TextAutosizer* textAutosizer = document().textAutosizer())
     textAutosizer->record(this);
 
   propagateStyleToAnonymousChildren();
 
-  // It's possible for our border/padding to change, but for the overall logical width or height of the block to
-  // end up being the same. We keep track of this change so in layoutBlock, we can know to set relayoutChildren=true.
+  // It's possible for our border/padding to change, but for the overall logical
+  // width or height of the block to end up being the same. We keep track of
+  // this change so in layoutBlock, we can know to set relayoutChildren=true.
   m_widthAvailableToChildrenChanged |=
       oldStyle && diff.needsFullLayout() && needsLayout() &&
       borderOrPaddingLogicalDimensionChanged(*oldStyle, newStyle, LogicalWidth);
   m_heightAvailableToChildrenChanged |= oldStyle && diff.needsFullLayout() &&
                                         needsLayout() &&
                                         borderOrPaddingLogicalDimensionChanged(
                                             *oldStyle, newStyle, LogicalHeight);
 }
 
 void LayoutBlock::updateFromStyle() {
@@ skipping 15 matching lines @@
 }
 
 void LayoutBlock::addChildBeforeDescendant(LayoutObject* newChild,
                                            LayoutObject* beforeDescendant) {
   ASSERT(beforeDescendant->parent() != this);
   LayoutObject* beforeDescendantContainer = beforeDescendant->parent();
   while (beforeDescendantContainer->parent() != this)
     beforeDescendantContainer = beforeDescendantContainer->parent();
   ASSERT(beforeDescendantContainer);
 
-  // We really can't go on if what we have found isn't anonymous. We're not supposed to use some
-  // random non-anonymous object and put the child there. That's a recipe for security issues.
+  // We really can't go on if what we have found isn't anonymous. We're not
+  // supposed to use some random non-anonymous object and put the child there.
+  // That's a recipe for security issues.
   RELEASE_ASSERT(beforeDescendantContainer->isAnonymous());
 
-  // If the requested insertion point is not one of our children, then this is because
-  // there is an anonymous container within this object that contains the beforeDescendant.
+  // If the requested insertion point is not one of our children, then this is
+  // because there is an anonymous container within this object that contains
+  // the beforeDescendant.
   if (beforeDescendantContainer->isAnonymousBlock()
-      // Full screen layoutObjects and full screen placeholders act as anonymous blocks, not tables:
+      // Full screen layoutObjects and full screen placeholders act as anonymous
+      // blocks, not tables:
       || beforeDescendantContainer->isLayoutFullScreen() ||
       beforeDescendantContainer->isLayoutFullScreenPlaceholder()) {
     // Insert the child into the anonymous block box instead of here.
     if (newChild->isInline() || newChild->isFloatingOrOutOfFlowPositioned() ||
         beforeDescendant->parent()->slowFirstChild() != beforeDescendant)
       beforeDescendant->parent()->addChild(newChild, beforeDescendant);
     else
       addChild(newChild, beforeDescendant->parent());
     return;
   }
@@ skipping 16 matching lines @@
 
   addChild(newChild, beforeChild);
 }
 
 void LayoutBlock::addChild(LayoutObject* newChild, LayoutObject* beforeChild) {
   if (beforeChild && beforeChild->parent() != this) {
     addChildBeforeDescendant(newChild, beforeChild);
     return;
   }
 
-  // Only LayoutBlockFlow should have inline children, and then we shouldn't be here.
+  // Only LayoutBlockFlow should have inline children, and then we shouldn't be
+  // here.
   ASSERT(!childrenInline());
 
   if (newChild->isInline() || newChild->isFloatingOrOutOfFlowPositioned()) {
-    // If we're inserting an inline child but all of our children are blocks, then we have to make sure
-    // it is put into an anomyous block box. We try to use an existing anonymous box if possible, otherwise
-    // a new one is created and inserted into our list of children in the appropriate position.
+    // If we're inserting an inline child but all of our children are blocks,
+    // then we have to make sure it is put into an anomyous block box. We try to
+    // use an existing anonymous box if possible, otherwise a new one is created
+    // and inserted into our list of children in the appropriate position.
     LayoutObject* afterChild =
         beforeChild ? beforeChild->previousSibling() : lastChild();
 
     if (afterChild && afterChild->isAnonymousBlock()) {
       afterChild->addChild(newChild);
       return;
     }
 
     if (newChild->isInline()) {
       // No suitable existing anonymous box - create a new one.
@@ skipping 11 matching lines @@
   ASSERT(child->isAnonymousBlock());
   ASSERT(!child->childrenInline());
   ASSERT(child->parent() == this);
 
   if (child->continuation())
     return;
 
   if (isFieldset())
     return;
 
-  // Promote all the leftover anonymous block's children (to become children of this block
-  // instead). We still want to keep the leftover block in the tree for a moment, for notification
-  // purposes done further below (flow threads and grids).
+  // Promote all the leftover anonymous block's children (to become children of
+  // this block instead). We still want to keep the leftover block in the tree
+  // for a moment, for notification purposes done further below (flow threads
+  // and grids).
   child->moveAllChildrenTo(this, child->nextSibling());
 
-  // Remove all the information in the flow thread associated with the leftover anonymous block.
+  // Remove all the information in the flow thread associated with the leftover
+  // anonymous block.
   child->removeFromLayoutFlowThread();
 
-  // LayoutGrid keeps track of its children, we must notify it about changes in the tree.
+  // LayoutGrid keeps track of its children, we must notify it about changes in
+  // the tree.
   if (child->parent()->isLayoutGrid())
     toLayoutGrid(child->parent())->dirtyGrid();
 
-  // Now remove the leftover anonymous block from the tree, and destroy it. We'll rip it out
-  // manually from the tree before destroying it, because we don't want to trigger any tree
-  // adjustments with regards to anonymous blocks (or any other kind of undesired chain-reaction).
+  // Now remove the leftover anonymous block from the tree, and destroy it.
+  // We'll rip it out manually from the tree before destroying it, because we
+  // don't want to trigger any tree adjustments with regards to anonymous blocks
+  // (or any other kind of undesired chain-reaction).
   children()->removeChildNode(this, child, false);
   child->destroy();
 }
 
 void LayoutBlock::updateAfterLayout() {
   invalidateStickyConstraints();
 
-  // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
-  // we overflow or not.
+  // Update our scroll information if we're overflow:auto/scroll/hidden now that
+  // we know if we overflow or not.
   if (hasOverflowClip())
     layer()->getScrollableArea()->updateAfterLayout();
 }
 
 void LayoutBlock::layout() {
   DCHECK(!getScrollableArea() || getScrollableArea()->scrollAnchor());
 
   LayoutAnalyzer::Scope analyzer(*this);
 
   bool needsScrollAnchoring =
       hasOverflowClip() && getScrollableArea()->shouldPerformScrollAnchoring();
   if (needsScrollAnchoring)
     getScrollableArea()->scrollAnchor()->save();
 
-  // Table cells call layoutBlock directly, so don't add any logic here.  Put code into
-  // layoutBlock().
+  // Table cells call layoutBlock directly, so don't add any logic here.  Put
+  // code into layoutBlock().
   layoutBlock(false);
 
-  // It's safe to check for control clip here, since controls can never be table cells.
-  // If we have a lightweight clip, there can never be any overflow from children.
+  // It's safe to check for control clip here, since controls can never be table
+  // cells. If we have a lightweight clip, there can never be any overflow from
+  // children.
   if (hasControlClip() && m_overflow)
     clearLayoutOverflow();
 
   invalidateBackgroundObscurationStatus();
 
-  // If clamping is delayed, we will restore in PaintLayerScrollableArea::clampScrollPositionsAfterLayout.
-  // Restoring during the intermediate layout may clamp the scroller to the wrong bounds.
+  // If clamping is delayed, we will restore in
+  // PaintLayerScrollableArea::clampScrollPositionsAfterLayout.
+  // Restoring during the intermediate layout may clamp the scroller to the
+  // wrong bounds.
   bool clampingDelayed = PaintLayerScrollableArea::
       DelayScrollPositionClampScope::clampingIsDelayed();
   if (needsScrollAnchoring && !clampingDelayed)
     getScrollableArea()->scrollAnchor()->restore();
 
   m_heightAvailableToChildrenChanged = false;
 }
 
 bool LayoutBlock::widthAvailableToChildrenHasChanged() {
-  // TODO(robhogan): Does m_widthAvailableToChildrenChanged always get reset when it needs to?
+  // TODO(robhogan): Does m_widthAvailableToChildrenChanged always get reset
+  // when it needs to?
   bool widthAvailableToChildrenHasChanged = m_widthAvailableToChildrenChanged;
   m_widthAvailableToChildrenChanged = false;
 
-  // If we use border-box sizing, have percentage padding, and our parent has changed width then the width available to our children has changed even
+  // If we use border-box sizing, have percentage padding, and our parent has
+  // changed width then the width available to our children has changed even
   // though our own width has remained the same.
   widthAvailableToChildrenHasChanged |=
       style()->boxSizing() == BoxSizingBorderBox &&
       needsPreferredWidthsRecalculation() &&
       view()->layoutState()->containingBlockLogicalWidthChanged();
 
   return widthAvailableToChildrenHasChanged;
 }
 
 DISABLE_CFI_PERF
@@ skipping 19 matching lines @@
 void LayoutBlock::computeOverflow(LayoutUnit oldClientAfterEdge, bool) {
   m_overflow.reset();
 
   // Add overflow from children.
   addOverflowFromChildren();
 
   // Add in the overflow from positioned objects.
   addOverflowFromPositionedObjects();
 
   if (hasOverflowClip()) {
-    // When we have overflow clip, propagate the original spillout since it will include collapsed bottom margins
-    // and bottom padding.  Set the axis we don't care about to be 1, since we want this overflow to always
-    // be considered reachable.
+    // When we have overflow clip, propagate the original spillout since it will
+    // include collapsed bottom margins and bottom padding. Set the axis we
+    // don't care about to be 1, since we want this overflow to always be
+    // considered reachable.
     LayoutRect clientRect(noOverflowRect());
     LayoutRect rectToApply;
     if (isHorizontalWritingMode())
       rectToApply = LayoutRect(
           clientRect.x(), clientRect.y(), LayoutUnit(1),
           (oldClientAfterEdge - clientRect.y()).clampNegativeToZero());
     else
       rectToApply = LayoutRect(
           clientRect.x(), clientRect.y(),
           (oldClientAfterEdge - clientRect.x()).clampNegativeToZero(),
           LayoutUnit(1));
     addLayoutOverflow(rectToApply);
     if (hasOverflowModel())
       m_overflow->setLayoutClientAfterEdge(oldClientAfterEdge);
   }
 
   addVisualEffectOverflow();
   addVisualOverflowFromTheme();
 
-  // An enclosing composited layer will need to update its bounds if we now overflow it.
+  // An enclosing composited layer will need to update its bounds if we now
+  // overflow it.
   PaintLayer* layer = enclosingLayer();
   if (!needsLayout() && layer->hasCompositedLayerMapping() &&
       !layer->visualRect().contains(visualOverflowRect()))
     layer->setNeedsCompositingInputsUpdate();
 }
 
 void LayoutBlock::addOverflowFromBlockChildren() {
   for (LayoutBox* child = firstChildBox(); child;
        child = child->nextSiblingBox()) {
     if (!child->isFloatingOrOutOfFlowPositioned() && !child->isColumnSpanAll())
       addOverflowFromChild(child);
   }
 }
 
 void LayoutBlock::addOverflowFromPositionedObjects() {
   TrackedLayoutBoxListHashSet* positionedDescendants = positionedObjects();
   if (!positionedDescendants)
     return;
 
   for (auto* positionedObject : *positionedDescendants) {
-    // Fixed positioned elements don't contribute to layout overflow, since they don't scroll with the content.
+    // Fixed positioned elements don't contribute to layout overflow, since they
+    // don't scroll with the content.
     if (positionedObject->style()->position() != FixedPosition)
       addOverflowFromChild(positionedObject,
                            toLayoutSize(positionedObject->location()));
   }
 }
 
 void LayoutBlock::addVisualOverflowFromTheme() {
   if (!style()->hasAppearance())
     return;
 
@@ skipping 17 matching lines @@
     LayoutBox& child) {
   if (parent->style()->boxSizing() != BoxSizingBorderBox)
     return false;
   return parent->style()->isHorizontalWritingMode() &&
          !child.style()->isHorizontalWritingMode();
 }
 
 void LayoutBlock::updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren,
                                                         LayoutBox& child) {
   if (child.isOutOfFlowPositioned()) {
-    // It's rather useless to mark out-of-flow children at this point. We may not be their
-    // containing block (and if we are, it's just pure luck), so this would be the wrong place
-    // for it. Furthermore, it would cause trouble for out-of-flow descendants of column
-    // spanners, if the containing block is outside the spanner but inside the multicol container.
+    // It's rather useless to mark out-of-flow children at this point. We may
+    // not be their containing block (and if we are, it's just pure luck), so
+    // this would be the wrong place for it. Furthermore, it would cause trouble
+    // for out-of-flow descendants of column spanners, if the containing block
+    // is outside the spanner but inside the multicol container.
     return;
   }
-  // FIXME: Technically percentage height objects only need a relayout if their percentage isn't going to be turned into
-  // an auto value. Add a method to determine this, so that we can avoid the relayout.
+  // FIXME: Technically percentage height objects only need a relayout if their
+  // percentage isn't going to be turned into an auto value. Add a method to
+  // determine this, so that we can avoid the relayout.
   bool hasRelativeLogicalHeight =
       child.hasRelativeLogicalHeight() ||
       (child.isAnonymous() && this->hasRelativeLogicalHeight()) ||
       child.stretchesToViewport();
   if (relayoutChildren || (hasRelativeLogicalHeight && !isLayoutView()) ||
       (m_heightAvailableToChildrenChanged &&
        changeInAvailableLogicalHeightAffectsChild(this, child))) {
     child.setChildNeedsLayout(MarkOnlyThis);
 
-    // If the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
+    // If the child has percentage padding or an embedded content box, we also
+    // need to invalidate the childs pref widths.
     if (child.needsPreferredWidthsRecalculation())
       child.setPreferredLogicalWidthsDirty(MarkOnlyThis);
   }
 }
 
 void LayoutBlock::simplifiedNormalFlowLayout() {
   if (childrenInline()) {
     ASSERT_WITH_SECURITY_IMPLICATION(isLayoutBlockFlow());
     LayoutBlockFlow* blockFlow = toLayoutBlockFlow(this);
     blockFlow->simplifiedNormalFlowInlineLayout();
@@ skipping 27 matching lines @@
         !tryLayoutDoingPositionedMovementOnly())
       return false;
 
     if (LayoutFlowThread* flowThread = flowThreadContainingBlock()) {
       if (!flowThread->canSkipLayout(*this))
         return false;
     }
 
     TextAutosizer::LayoutScope textAutosizerLayoutScope(this);
 
-    // Lay out positioned descendants or objects that just need to recompute overflow.
+    // Lay out positioned descendants or objects that just need to recompute
+    // overflow.
     if (needsSimplifiedNormalFlowLayout())
       simplifiedNormalFlowLayout();
 
     // Lay out our positioned objects if our positioned child bit is set.
-    // Also, if an absolute position element inside a relative positioned container moves, and the absolute element has a fixed position
-    // child, neither the fixed element nor its container learn of the movement since posChildNeedsLayout() is only marked as far as the
-    // relative positioned container. So if we can have fixed pos objects in our positioned objects list check if any of them
-    // are statically positioned and thus need to move with their absolute ancestors.
+    // Also, if an absolute position element inside a relative positioned
+    // container moves, and the absolute element has a fixed position child
+    // neither the fixed element nor its container learn of the movement since
+    // posChildNeedsLayout() is only marked as far as the relative positioned
+    // container. So if we can have fixed pos objects in our positioned objects
+    // list check if any of them are statically positioned and thus need to move
+    // with their absolute ancestors.
     bool canContainFixedPosObjects = canContainFixedPositionObjects();
     if (posChildNeedsLayout() || needsPositionedMovementLayout() ||
         canContainFixedPosObjects)
       layoutPositionedObjects(
           false, needsPositionedMovementLayout()
                      ? ForcedLayoutAfterContainingBlockMoved
                      : (!posChildNeedsLayout() && canContainFixedPosObjects
                             ? LayoutOnlyFixedPositionedObjects
                             : DefaultLayout));
 
     // Recompute our overflow information.
-    // FIXME: We could do better here by computing a temporary overflow object from layoutPositionedObjects and only
-    // updating our overflow if we either used to have overflow or if the new temporary object has overflow.
-    // For now just always recompute overflow. This is no worse performance-wise than the old code that called rightmostPosition and
-    // lowestPosition on every relayout so it's not a regression.
-    // computeOverflow expects the bottom edge before we clamp our height. Since this information isn't available during
-    // simplifiedLayout, we cache the value in m_overflow.
+    // FIXME: We could do better here by computing a temporary overflow object
+    // from layoutPositionedObjects and only updating our overflow if we either
+    // used to have overflow or if the new temporary object has overflow.
+    // For now just always recompute overflow. This is no worse performance-wise
+    // than the old code that called rightmostPosition and lowestPosition on
+    // every relayout so it's not a regression. computeOverflow expects the
+    // bottom edge before we clamp our height. Since this information isn't
+    // available during simplifiedLayout, we cache the value in m_overflow.
     LayoutUnit oldClientAfterEdge = hasOverflowModel()
                                         ? m_overflow->layoutClientAfterEdge()
                                         : clientLogicalBottom();
     computeOverflow(oldClientAfterEdge, true);
   }
 
   updateLayerTransformAfterLayout();
 
   updateAfterLayout();
 
@@ skipping 48 matching lines @@
   Length marginRight = child.style()->marginEndUsing(style());
   LayoutUnit margin;
   if (marginLeft.isFixed())
     margin += marginLeft.value();
   if (marginRight.isFixed())
     margin += marginRight.value();
   return margin;
 }
 
 static bool needsLayoutDueToStaticPosition(LayoutBox* child) {
-  // When a non-positioned block element moves, it may have positioned children that are
-  // implicitly positioned relative to the non-positioned block.
+  // When a non-positioned block element moves, it may have positioned children
+  // that are implicitly positioned relative to the non-positioned block.
   const ComputedStyle* style = child->style();
   bool isHorizontal = style->isHorizontalWritingMode();
   if (style->hasStaticBlockPosition(isHorizontal)) {
     LayoutBox::LogicalExtentComputedValues computedValues;
     LayoutUnit currentLogicalTop = child->logicalTop();
     LayoutUnit currentLogicalHeight = child->logicalHeight();
     child->computeLogicalHeight(currentLogicalHeight, currentLogicalTop,
                                 computedValues);
     if (computedValues.m_position != currentLogicalTop ||
         computedValues.m_extent != currentLogicalHeight)
@@ skipping 16 matching lines @@
   TrackedLayoutBoxListHashSet* positionedDescendants = positionedObjects();
   if (!positionedDescendants)
     return;
 
   bool isPaginated = view()->layoutState()->isPaginated();
 
   for (auto* positionedObject : *positionedDescendants) {
     positionedObject->setMayNeedPaintInvalidation();
 
     SubtreeLayoutScope layoutScope(*positionedObject);
-    // A fixed position element with an absolute positioned ancestor has no way of knowing if the latter has changed position. So
-    // if this is a fixed position element, mark it for layout if it has an abspos ancestor and needs to move with that ancestor, i.e.
-    // it has static position.
+    // A fixed position element with an absolute positioned ancestor has no way
+    // of knowing if the latter has changed position. So if this is a fixed
+    // position element, mark it for layout if it has an abspos ancestor and
+    // needs to move with that ancestor, i.e. it has static position.
     markFixedPositionObjectForLayoutIfNeeded(positionedObject, layoutScope);
     if (info == LayoutOnlyFixedPositionedObjects) {
       positionedObject->layoutIfNeeded();
       continue;
     }
 
     if (!positionedObject->normalChildNeedsLayout() &&
         (relayoutChildren || m_heightAvailableToChildrenChanged ||
          needsLayoutDueToStaticPosition(positionedObject)))
       layoutScope.setChildNeedsLayout(positionedObject);
 
-    // If relayoutChildren is set and the child has percentage padding or an embedded content box, we also need to invalidate the childs pref widths.
+    // If relayoutChildren is set and the child has percentage padding or an
+    // embedded content box, we also need to invalidate the childs pref widths.
     if (relayoutChildren &&
         positionedObject->needsPreferredWidthsRecalculation())
       positionedObject->setPreferredLogicalWidthsDirty(MarkOnlyThis);
 
     LayoutUnit logicalTopEstimate;
     bool needsBlockDirectionLocationSetBeforeLayout =
         isPaginated &&
         positionedObject->getPaginationBreakability() != ForbidBreaks;
     if (needsBlockDirectionLocationSetBeforeLayout) {
-      // Out-of-flow objects are normally positioned after layout (while in-flow objects are
-      // positioned before layout). If the child object is paginated in the same context as
-      // we are, estimate its logical top now. We need to know this up-front, to correctly
-      // evaluate if we need to mark for relayout, and, if our estimate is correct, we'll
-      // even be able to insert correct pagination struts on the first attempt.
+      // Out-of-flow objects are normally positioned after layout (while in-flow
+      // objects are positioned before layout). If the child object is paginated
+      // in the same context as we are, estimate its logical top now. We need to
+      // know this up-front, to correctly evaluate if we need to mark for
+      // relayout, and, if our estimate is correct, we'll even be able to insert
+      // correct pagination struts on the first attempt.
       LogicalExtentComputedValues computedValues;
       positionedObject->computeLogicalHeight(positionedObject->logicalHeight(),
                                              positionedObject->logicalTop(),
                                              computedValues);
       logicalTopEstimate = computedValues.m_position;
       positionedObject->setLogicalTop(logicalTopEstimate);
     }
 
     if (!positionedObject->needsLayout())
       markChildForPaginationRelayoutIfNeeded(*positionedObject, layoutScope);
 
-    // FIXME: We should be able to do a r->setNeedsPositionedMovementLayout() here instead of a full layout. Need
-    // to investigate why it does not trigger the correct invalidations in that case. crbug.com/350756
+    // FIXME: We should be able to do a r->setNeedsPositionedMovementLayout()
+    // here instead of a full layout. Need to investigate why it does not
+    // trigger the correct invalidations in that case. crbug.com/350756
     if (info == ForcedLayoutAfterContainingBlockMoved)
       positionedObject->setNeedsLayout(LayoutInvalidationReason::AncestorMoved,
                                        MarkOnlyThis);
 
     positionedObject->layoutIfNeeded();
 
     LayoutObject* parent = positionedObject->parent();
     bool layoutChanged = false;
     if (parent->isFlexibleBox() &&
         toLayoutFlexibleBox(parent)->setStaticPositionForPositionedLayout(
             *positionedObject)) {
-      // The static position of an abspos child of a flexbox depends on its size (for example,
-      // they can be centered). So we may have to reposition the item after layout.
-      // TODO(cbiesinger): We could probably avoid a layout here and just reposition?
+      // The static position of an abspos child of a flexbox depends on its size
+      // (for example, they can be centered). So we may have to reposition the
+      // item after layout.
+      // TODO(cbiesinger): We could probably avoid a layout here and just
+      // reposition?
       positionedObject->forceChildLayout();
       layoutChanged = true;
     }
 
     // Lay out again if our estimate was wrong.
     if (!layoutChanged && needsBlockDirectionLocationSetBeforeLayout &&
         logicalTopEstimate != logicalTopForChild(*positionedObject))
       positionedObject->forceChildLayout();
   }
 }
@@ skipping 19 matching lines @@
 void LayoutBlock::paintObject(const PaintInfo& paintInfo,
                               const LayoutPoint& paintOffset) const {
   BlockPainter(*this).paintObject(paintInfo, paintOffset);
 }
 
 bool LayoutBlock::isSelectionRoot() const {
   if (isPseudoElement())
     return false;
   ASSERT(node() || isAnonymous());
 
-  // FIXME: Eventually tables should have to learn how to fill gaps between cells, at least in simple non-spanning cases.
+  // FIXME: Eventually tables should have to learn how to fill gaps between
+  // cells, at least in simple non-spanning cases.
   if (isTable())
     return false;
 
   if (isBody() || isDocumentElement() || hasOverflowClip() || isPositioned() ||
       isFloating() || isTableCell() || isInlineBlockOrInlineTable() ||
       hasTransformRelatedProperty() || hasReflection() || hasMask() ||
       isWritingModeRoot() || isLayoutFlowThread() ||
       isFlexItemIncludingDeprecated())
     return true;
 
@@ skipping 151 matching lines @@
     return;
 
   Vector<LayoutBox*, 16> deadObjects;
   for (auto* positionedObject : *positionedDescendants) {
     if (!o || (positionedObject->isDescendantOf(o) && o != positionedObject)) {
       if (containingBlockState == NewContainingBlock) {
         positionedObject->setChildNeedsLayout(MarkOnlyThis);
         if (positionedObject->needsPreferredWidthsRecalculation())
           positionedObject->setPreferredLogicalWidthsDirty(MarkOnlyThis);
 
-        // The positioned object changing containing block may change paint invalidation container.
-        // Invalidate it (including non-compositing descendants) on its original paint invalidation container.
+        // The positioned object changing containing block may change paint
+        // invalidation container.
+        // Invalidate it (including non-compositing descendants) on its original
+        // paint invalidation container.
         if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-          // This valid because we need to invalidate based on the current status.
+          // This valid because we need to invalidate based on the current
+          // status.
           DisableCompositingQueryAsserts compositingDisabler;
           if (!positionedObject->isPaintInvalidationContainer())
             ObjectPaintInvalidator(*positionedObject)
                 .invalidatePaintIncludingNonCompositingDescendants();
         }
       }
 
-      // It is parent blocks job to add positioned child to positioned objects list of its containing block
+      // It is parent blocks job to add positioned child to positioned objects
+      // list of its containing block
       // Parent layout needs to be invalidated to ensure this happens.
       LayoutObject* p = positionedObject->parent();
       while (p && !p->isLayoutBlock())
         p = p->parent();
       if (p)
         p->setChildNeedsLayout();
 
       deadObjects.append(positionedObject);
     }
   }
@@ skipping 166 matching lines @@
 // FIXME: This function should go on LayoutObject.
 // Then all cases in which positionForPoint recurs could call this instead to
 // prevent crossing editable boundaries. This would require many tests.
 PositionWithAffinity LayoutBlock::positionForPointRespectingEditingBoundaries(
     LineLayoutBox child,
     const LayoutPoint& pointInParentCoordinates) {
   LayoutPoint childLocation = child.location();
   if (child.isInFlowPositioned())
     childLocation += child.offsetForInFlowPosition();
 
-  // FIXME: This is wrong if the child's writing-mode is different from the parent's.
+  // FIXME: This is wrong if the child's writing-mode is different from the
+  // parent's.
   LayoutPoint pointInChildCoordinates(
       toLayoutPoint(pointInParentCoordinates - childLocation));
 
   // If this is an anonymous layoutObject, we just recur normally
   Node* childNode = child.nonPseudoNode();
   if (!childNode)
     return child.positionForPoint(pointInChildCoordinates);
 
-  // Otherwise, first make sure that the editability of the parent and child agree.
-  // If they don't agree, then we return a visible position just before or after the child
+  // Otherwise, first make sure that the editability of the parent and child
+  // agree. If they don't agree, then we return a visible position just before
+  // or after the child
   LayoutObject* ancestor = this;
   while (ancestor && !ancestor->nonPseudoNode())
     ancestor = ancestor->parent();
 
-  // If we can't find an ancestor to check editability on, or editability is unchanged, we recur like normal
+  // If we can't find an ancestor to check editability on, or editability is
+  // unchanged, we recur like normal
   if (isEditingBoundary(ancestor, child))
     return child.positionForPoint(pointInChildCoordinates);
 
-  // Otherwise return before or after the child, depending on if the click was to the logical left or logical right of the child
+  // Otherwise return before or after the child, depending on if the click was
+  // to the logical left or logical right of the child
   LayoutUnit childMiddle = logicalWidthForChildSize(child.size()) / 2;
   LayoutUnit logicalLeft = isHorizontalWritingMode()
                                ? pointInChildCoordinates.x()
                                : pointInChildCoordinates.y();
   if (logicalLeft < childMiddle)
     return ancestor->createPositionWithAffinity(childNode->nodeIndex());
   return ancestor->createPositionWithAffinity(childNode->nodeIndex() + 1,
                                               TextAffinity::Upstream);
 }
 
 PositionWithAffinity LayoutBlock::positionForPointIfOutsideAtomicInlineLevel(
     const LayoutPoint& point) {
   ASSERT(isAtomicInlineLevel());
-  // FIXME: This seems wrong when the object's writing-mode doesn't match the line's writing-mode.
+  // FIXME: This seems wrong when the object's writing-mode doesn't match the
+  // line's writing-mode.
   LayoutUnit pointLogicalLeft =
       isHorizontalWritingMode() ? point.x() : point.y();
   LayoutUnit pointLogicalTop =
       isHorizontalWritingMode() ? point.y() : point.x();
 
   if (pointLogicalLeft < 0)
     return createPositionWithAffinity(caretMinOffset());
   if (pointLogicalLeft >= logicalWidth())
     return createPositionWithAffinity(caretMaxOffset());
   if (pointLogicalTop < 0)
@@ skipping 39 matching lines @@
          pointInLogicalContents.y() == logicalTopForChild(*lastCandidateBox)))
       return positionForPointRespectingEditingBoundaries(
           LineLayoutBox(lastCandidateBox), pointInContents);
 
     for (LayoutBox* childBox = firstChildBox(); childBox;
          childBox = childBox->nextSiblingBox()) {
       if (!isChildHitTestCandidate(childBox))
         continue;
       LayoutUnit childLogicalBottom =
           logicalTopForChild(*childBox) + logicalHeightForChild(*childBox);
-      // We hit child if our click is above the bottom of its padding box (like IE6/7 and FF3).
+      // We hit child if our click is above the bottom of its padding box (like
+      // IE6/7 and FF3).
       if (pointInLogicalContents.y() < childLogicalBottom ||
           (blocksAreFlipped &&
            pointInLogicalContents.y() == childLogicalBottom)) {
         return positionForPointRespectingEditingBoundaries(
             LineLayoutBox(childBox), pointInContents);
       }
     }
   }
 
-  // We only get here if there are no hit test candidate children below the click.
+  // We only get here if there are no hit test candidate children below the
+  // click.
   return LayoutBox::positionForPoint(point);
 }
 
 void LayoutBlock::offsetForContents(LayoutPoint& offset) const {
   offset = flipForWritingMode(offset);
 
   if (hasOverflowClip())
     offset += LayoutSize(scrolledContentOffset());
 
   offset = flipForWritingMode(offset);
 }
 
 int LayoutBlock::columnGap() const {
-  if (style()->hasNormalColumnGap())
-    return style()
-        ->getFontDescription()
-        .computedPixelSize();  // "1em" is recommended as the normal gap setting. Matches <p> margins.
+  if (style()->hasNormalColumnGap()) {
+    // "1em" is recommended as the normal gap setting. Matches <p> margins.
+    return style()->getFontDescription().computedPixelSize();
+  }
   return static_cast<int>(style()->columnGap());
 }
 
 void LayoutBlock::scrollbarsChanged(bool horizontalScrollbarChanged,
                                     bool verticalScrollbarChanged) {
   m_widthAvailableToChildrenChanged |= verticalScrollbarChanged;
   m_heightAvailableToChildrenChanged |= horizontalScrollbarChanged;
 }
 
 void LayoutBlock::computeIntrinsicLogicalWidths(
@@ skipping 30 matching lines @@
   minLogicalWidth += scrollbarWidth;
 }
 
 DISABLE_CFI_PERF
 void LayoutBlock::computePreferredLogicalWidths() {
   ASSERT(preferredLogicalWidthsDirty());
 
   m_minPreferredLogicalWidth = LayoutUnit();
   m_maxPreferredLogicalWidth = LayoutUnit();
 
-  // FIXME: The isFixed() calls here should probably be checking for isSpecified since you
-  // should be able to use percentage, calc or viewport relative values for width.
+  // FIXME: The isFixed() calls here should probably be checking for isSpecified
+  // since you should be able to use percentage, calc or viewport relative
+  // values for width.
   const ComputedStyle& styleToUse = styleRef();
   if (!isTableCell() && styleToUse.logicalWidth().isFixed() &&
       styleToUse.logicalWidth().value() >= 0 &&
       !(isDeprecatedFlexItem() && !styleToUse.logicalWidth().intValue()))
     m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth =
         adjustContentBoxLogicalWidthForBoxSizing(
             LayoutUnit(styleToUse.logicalWidth().value()));
   else
     computeIntrinsicLogicalWidths(m_minPreferredLogicalWidth,
                                   m_maxPreferredLogicalWidth);
@@ skipping 14 matching lines @@
     m_maxPreferredLogicalWidth =
         std::min(m_maxPreferredLogicalWidth,
                  adjustContentBoxLogicalWidthForBoxSizing(
                      LayoutUnit(styleToUse.logicalMaxWidth().value())));
     m_minPreferredLogicalWidth =
         std::min(m_minPreferredLogicalWidth,
                  adjustContentBoxLogicalWidthForBoxSizing(
                      LayoutUnit(styleToUse.logicalMaxWidth().value())));
   }
 
-  // Table layout uses integers, ceil the preferred widths to ensure that they can contain the contents.
+  // Table layout uses integers, ceil the preferred widths to ensure that they
+  // can contain the contents.
   if (isTableCell()) {
     m_minPreferredLogicalWidth = LayoutUnit(m_minPreferredLogicalWidth.ceil());
     m_maxPreferredLogicalWidth = LayoutUnit(m_maxPreferredLogicalWidth.ceil());
   }
 
   LayoutUnit borderAndPadding = borderAndPaddingLogicalWidth();
   m_minPreferredLogicalWidth += borderAndPadding;
   m_maxPreferredLogicalWidth += borderAndPadding;
 
   clearPreferredLogicalWidthsDirty();
 }
 
 void LayoutBlock::computeBlockPreferredLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
   const ComputedStyle& styleToUse = styleRef();
   bool nowrap = styleToUse.whiteSpace() == NOWRAP;
 
   LayoutObject* child = firstChild();
   LayoutBlock* containingBlock = this->containingBlock();
   LayoutUnit floatLeftWidth, floatRightWidth;
   while (child) {
-    // Positioned children don't affect the min/max width. Spanners only affect the min/max
-    // width of the multicol container, not the flow thread.
+    // Positioned children don't affect the min/max width. Spanners only affect
+    // the min/max width of the multicol container, not the flow thread.
     if (child->isOutOfFlowPositioned() || child->isColumnSpanAll()) {
       child = child->nextSibling();
       continue;
     }
 
     RefPtr<ComputedStyle> childStyle = child->mutableStyle();
     if (child->isFloating() ||
         (child->isBox() && toLayoutBox(child)->avoidsFloats())) {
       LayoutUnit floatTotalWidth = floatLeftWidth + floatRightWidth;
       if (childStyle->clear() & ClearLeft) {
         maxLogicalWidth = std::max(floatTotalWidth, maxLogicalWidth);
         floatLeftWidth = LayoutUnit();
       }
       if (childStyle->clear() & ClearRight) {
         maxLogicalWidth = std::max(floatTotalWidth, maxLogicalWidth);
         floatRightWidth = LayoutUnit();
       }
     }
 
-    // A margin basically has three types: fixed, percentage, and auto (variable).
+    // A margin basically has three types: fixed, percentage, and auto
+    // (variable).
     // Auto and percentage margins simply become 0 when computing min/max width.
     // Fixed margins can be added in as is.
     Length startMarginLength = childStyle->marginStartUsing(&styleToUse);
     Length endMarginLength = childStyle->marginEndUsing(&styleToUse);
     LayoutUnit margin;
     LayoutUnit marginStart;
     LayoutUnit marginEnd;
     if (startMarginLength.isFixed())
       marginStart += startMarginLength.value();
     if (endMarginLength.isFixed())
       marginEnd += endMarginLength.value();
     margin = marginStart + marginEnd;
 
     LayoutUnit childMinPreferredLogicalWidth, childMaxPreferredLogicalWidth;
     computeChildPreferredLogicalWidths(*child, childMinPreferredLogicalWidth,
                                        childMaxPreferredLogicalWidth);
 
     LayoutUnit w = childMinPreferredLogicalWidth + margin;
     minLogicalWidth = std::max(w, minLogicalWidth);
 
     // IE ignores tables for calculation of nowrap. Makes some sense.
     if (nowrap && !child->isTable())
       maxLogicalWidth = std::max(w, maxLogicalWidth);
 
     w = childMaxPreferredLogicalWidth + margin;
 
     if (!child->isFloating()) {
       if (child->isBox() && toLayoutBox(child)->avoidsFloats()) {
-        // Determine a left and right max value based off whether or not the floats can fit in the
-        // margins of the object.  For negative margins, we will attempt to overlap the float if the negative margin
-        // is smaller than the float width.
+        // Determine a left and right max value based off whether or not the
+        // floats can fit in the margins of the object. For negative margins, we
+        // will attempt to overlap the float if the negative margin is smaller
+        // than the float width.
         bool ltr = containingBlock
                        ? containingBlock->style()->isLeftToRightDirection()
                        : styleToUse.isLeftToRightDirection();
         LayoutUnit marginLogicalLeft = ltr ? marginStart : marginEnd;
         LayoutUnit marginLogicalRight = ltr ? marginEnd : marginStart;
         LayoutUnit maxLeft = marginLogicalLeft > 0
                                  ? std::max(floatLeftWidth, marginLogicalLeft)
                                  : floatLeftWidth + marginLogicalLeft;
         LayoutUnit maxRight =
             marginLogicalRight > 0
@@ skipping 27 matching lines @@
   maxLogicalWidth = std::max(floatLeftWidth + floatRightWidth, maxLogicalWidth);
 }
 
 DISABLE_CFI_PERF
 void LayoutBlock::computeChildPreferredLogicalWidths(
     LayoutObject& child,
     LayoutUnit& minPreferredLogicalWidth,
     LayoutUnit& maxPreferredLogicalWidth) const {
   if (child.isBox() &&
       child.isHorizontalWritingMode() != isHorizontalWritingMode()) {
-    // If the child is an orthogonal flow, child's height determines the width, but the height is not available until layout.
+    // If the child is an orthogonal flow, child's height determines the width,
+    // but the height is not available until layout.
     // http://dev.w3.org/csswg/css-writing-modes-3/#orthogonal-shrink-to-fit
     if (!child.needsLayout()) {
       minPreferredLogicalWidth = maxPreferredLogicalWidth =
           toLayoutBox(child).logicalHeight();
       return;
     }
     minPreferredLogicalWidth = maxPreferredLogicalWidth =
         toLayoutBox(child).computeLogicalHeightWithoutLayout();
     return;
   }
   minPreferredLogicalWidth = child.minPreferredLogicalWidth();
   maxPreferredLogicalWidth = child.maxPreferredLogicalWidth();
 
-  // For non-replaced blocks if the inline size is min|max-content or a definite size the min|max-content contribution
-  // is that size plus border, padding and margin https://drafts.csswg.org/css-sizing/#block-intrinsic
+  // For non-replaced blocks if the inline size is min|max-content or a definite
+  // size the min|max-content contribution is that size plus border, padding and
+  // margin https://drafts.csswg.org/css-sizing/#block-intrinsic
   if (child.isLayoutBlock()) {
     const Length& computedInlineSize = child.styleRef().logicalWidth();
     if (computedInlineSize.isMaxContent())
       minPreferredLogicalWidth = maxPreferredLogicalWidth;
     else if (computedInlineSize.isMinContent())
       maxPreferredLogicalWidth = minPreferredLogicalWidth;
   }
 }
 
 bool LayoutBlock::hasLineIfEmpty() const {
@@ skipping 32 matching lines @@
 
 int LayoutBlock::baselinePosition(FontBaseline baselineType,
                                   bool firstLine,
                                   LineDirectionMode direction,
                                   LinePositionMode linePositionMode) const {
   // Inline blocks are replaced elements. Otherwise, just pass off to
   // the base class.  If we're being queried as though we're the root line
   // box, then the fact that we're an inline-block is irrelevant, and we behave
   // just like a block.
   if (isInline() && linePositionMode == PositionOnContainingLine) {
-    // For "leaf" theme objects, let the theme decide what the baseline position is.
-    // FIXME: Might be better to have a custom CSS property instead, so that if the theme
-    // is turned off, checkboxes/radios will still have decent baselines.
+    // For "leaf" theme objects, let the theme decide what the baseline position
+    // is.
+    // FIXME: Might be better to have a custom CSS property instead, so that if
+    //        the theme is turned off, checkboxes/radios will still have decent
+    //        baselines.
     // FIXME: Need to patch form controls to deal with vertical lines.
     if (style()->hasAppearance() &&
         !LayoutTheme::theme().isControlContainer(style()->appearance()))
       return LayoutTheme::theme().baselinePosition(this);
 
     int baselinePos = (isWritingModeRoot() && !isRubyRun())
                           ? -1
                           : inlineBlockBaseline(direction);
 
     if (isDeprecatedFlexibleBox()) {
@@ skipping 11 matching lines @@
       if (baselinePos > bottomOfContent)
         baselinePos = -1;
     }
     if (baselinePos != -1)
       return beforeMarginInLineDirection(direction) + baselinePos;
 
     return LayoutBox::baselinePosition(baselineType, firstLine, direction,
                                        linePositionMode);
   }
 
-  // If we're not replaced, we'll only get called with PositionOfInteriorLineBoxes.
+  // If we're not replaced, we'll only get called with
+  // PositionOfInteriorLineBoxes.
   // Note that inline-block counts as replaced here.
   ASSERT(linePositionMode == PositionOfInteriorLineBoxes);
 
   const FontMetrics& fontMetrics = style(firstLine)->getFontMetrics();
   return (fontMetrics.ascent(baselineType) +
           (lineHeight(firstLine, direction, linePositionMode) -
            fontMetrics.height()) /
               2)
       .toInt();
 }
 
 LayoutUnit LayoutBlock::minLineHeightForReplacedObject(
     bool isFirstLine,
     LayoutUnit replacedHeight) const {
   if (!document().inNoQuirksMode() && replacedHeight)
     return replacedHeight;
 
   return std::max<LayoutUnit>(
       replacedHeight,
       lineHeight(isFirstLine,
                  isHorizontalWritingMode() ? HorizontalLine : VerticalLine,
                  PositionOfInteriorLineBoxes));
 }
 
-// TODO(mstensho): Figure out if all of this baseline code is needed here, or if it should be moved
-// down to LayoutBlockFlow. LayoutDeprecatedFlexibleBox and LayoutGrid lack baseline calculation
-// overrides, so the code is here just for them. Just walking the block children in logical order
-// seems rather wrong for those two layout modes, though.
+// TODO(mstensho): Figure out if all of this baseline code is needed here, or if
+// it should be moved down to LayoutBlockFlow. LayoutDeprecatedFlexibleBox and
+// LayoutGrid lack baseline calculation overrides, so the code is here just for
+// them. Just walking the block children in logical order seems rather wrong for
+// those two layout modes, though.
 
 int LayoutBlock::firstLineBoxBaseline() const {
   ASSERT(!childrenInline());
   if (isWritingModeRoot() && !isRubyRun())
     return -1;
 
   for (LayoutBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
     if (!curr->isFloatingOrOutOfFlowPositioned()) {
       int result = curr->firstLineBoxBaseline();
       if (result != -1)
         return (curr->logicalTop() + result)
             .toInt();  // Translate to our coordinate space.
     }
   }
   return -1;
 }
 
 int LayoutBlock::inlineBlockBaseline(LineDirectionMode lineDirection) const {
   ASSERT(!childrenInline());
   if ((!style()->isOverflowVisible() &&
        !shouldIgnoreOverflowPropertyForInlineBlockBaseline()) ||
       style()->containsSize()) {
-    // We are not calling LayoutBox::baselinePosition here because the caller should add the margin-top/margin-right, not us.
+    // We are not calling LayoutBox::baselinePosition here because the caller
+    // should add the margin-top/margin-right, not us.
     return (lineDirection == HorizontalLine ? size().height() + marginBottom()
                                             : size().width() + marginLeft())
         .toInt();
   }
 
   if (isWritingModeRoot() && !isRubyRun())
     return -1;
 
   bool haveNormalFlowChild = false;
   for (LayoutBox* curr = lastChildBox(); curr;
@@ skipping 144 matching lines @@
 
 void LayoutBlock::paginatedContentWasLaidOut(
     LayoutUnit logicalBottomOffsetAfterPagination) {
   if (LayoutFlowThread* flowThread = flowThreadContainingBlock())
     flowThread->contentWasLaidOut(offsetFromLogicalTopOfFirstPage() +
                                   logicalBottomOffsetAfterPagination);
 }
 
 LayoutUnit LayoutBlock::collapsedMarginBeforeForChild(
     const LayoutBox& child) const {
-  // If the child has the same directionality as we do, then we can just return its
-  // collapsed margin.
+  // If the child has the same directionality as we do, then we can just return
+  // its collapsed margin.
   if (!child.isWritingModeRoot())
     return child.collapsedMarginBefore();
 
-  // The child has a different directionality.  If the child is parallel, then it's just
-  // flipped relative to us.  We can use the collapsed margin for the opposite edge.
+  // The child has a different directionality.  If the child is parallel, then
+  // it's just flipped relative to us.  We can use the collapsed margin for the
+  // opposite edge.
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return child.collapsedMarginAfter();
 
-  // The child is perpendicular to us, which means its margins don't collapse but are on the
-  // "logical left/right" sides of the child box.  We can just return the raw margin in this case.
+  // The child is perpendicular to us, which means its margins don't collapse
+  // but are on the "logical left/right" sides of the child box. We can just
+  // return the raw margin in this case.
   return marginBeforeForChild(child);
 }
 
 LayoutUnit LayoutBlock::collapsedMarginAfterForChild(
     const LayoutBox& child) const {
-  // If the child has the same directionality as we do, then we can just return its
-  // collapsed margin.
+  // If the child has the same directionality as we do, then we can just return
+  // its collapsed margin.
   if (!child.isWritingModeRoot())
     return child.collapsedMarginAfter();
 
-  // The child has a different directionality.  If the child is parallel, then it's just
-  // flipped relative to us.  We can use the collapsed margin for the opposite edge.
+  // The child has a different directionality.  If the child is parallel, then
+  // it's just flipped relative to us.  We can use the collapsed margin for the
+  // opposite edge.
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return child.collapsedMarginBefore();
 
-  // The child is perpendicular to us, which means its margins don't collapse but are on the
-  // "logical left/right" side of the child box.  We can just return the raw margin in this case.
+  // The child is perpendicular to us, which means its margins don't collapse
+  // but are on the "logical left/right" side of the child box. We can just
+  // return the raw margin in this case.
   return marginAfterForChild(child);
 }
 
 bool LayoutBlock::hasMarginBeforeQuirk(const LayoutBox* child) const {
-  // If the child has the same directionality as we do, then we can just return its
-  // margin quirk.
+  // If the child has the same directionality as we do, then we can just return
+  // its margin quirk.
   if (!child->isWritingModeRoot())
     return child->isLayoutBlock() ? toLayoutBlock(child)->hasMarginBeforeQuirk()
                                   : child->style()->hasMarginBeforeQuirk();
 
-  // The child has a different directionality. If the child is parallel, then it's just
-  // flipped relative to us. We can use the opposite edge.
+  // The child has a different directionality. If the child is parallel, then
+  // it's just flipped relative to us. We can use the opposite edge.
   if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
     return child->isLayoutBlock() ? toLayoutBlock(child)->hasMarginAfterQuirk()
                                   : child->style()->hasMarginAfterQuirk();
 
-  // The child is perpendicular to us and box sides are never quirky in html.css, and we don't really care about
-  // whether or not authors specified quirky ems, since they're an implementation detail.
+  // The child is perpendicular to us and box sides are never quirky in
+  // html.css, and we don't really care about whether or not authors specified
+  // quirky ems, since they're an implementation detail.
   return false;
 }
 
 bool LayoutBlock::hasMarginAfterQuirk(const LayoutBox* child) const {
-  // If the child has the same directionality as we do, then we can just return its
-  // margin quirk.
+  // If the child has the same directionality as we do, then we can just return
+  // its margin quirk.
   if (!child->isWritingModeRoot())
     return child->isLayoutBlock() ? toLayoutBlock(child)->hasMarginAfterQuirk()
                                   : child->style()->hasMarginAfterQuirk();
 
-  // The child has a different directionality. If the child is parallel, then it's just
-  // flipped relative to us. We can use the opposite edge.
+  // The child has a different directionality. If the child is parallel, then
+  // it's just flipped relative to us. We can use the opposite edge.
   if (child->isHorizontalWritingMode() == isHorizontalWritingMode())
     return child->isLayoutBlock() ? toLayoutBlock(child)->hasMarginBeforeQuirk()
                                   : child->style()->hasMarginBeforeQuirk();
 
-  // The child is perpendicular to us and box sides are never quirky in html.css, and we don't really care about
-  // whether or not authors specified quirky ems, since they're an implementation detail.
+  // The child is perpendicular to us and box sides are never quirky in
+  // html.css, and we don't really care about whether or not authors specified
+  // quirky ems, since they're an implementation detail.
   return false;
 }
 
 const char* LayoutBlock::name() const {
   ASSERT_NOT_REACHED();
   return "LayoutBlock";
 }
 
 LayoutBlock* LayoutBlock::createAnonymousWithParentAndDisplay(
     const LayoutObject* parent,
     EDisplay display) {
-  // FIXME: Do we need to convert all our inline displays to block-type in the anonymous logic ?
+  // FIXME: Do we need to convert all our inline displays to block-type in the
+  // anonymous logic ?
   EDisplay newDisplay;
   LayoutBlock* newBox = nullptr;
   if (display == EDisplay::Flex || display == EDisplay::InlineFlex) {
     newBox = LayoutFlexibleBox::createAnonymous(&parent->document());
     newDisplay = EDisplay::Flex;
   } else if (display == EDisplay::Grid || display == EDisplay::InlineGrid) {
     newBox = LayoutGrid::createAnonymous(&parent->document());
     newDisplay = EDisplay::Grid;
   } else {
     newBox = LayoutBlockFlow::createAnonymous(&parent->document());
@@ skipping 79 matching lines @@
                                       ? m_overflow->layoutClientAfterEdge()
                                       : clientLogicalBottom();
   computeOverflow(oldClientAfterEdge, true);
 
   if (hasOverflowClip())
     layer()->getScrollableArea()->updateAfterOverflowRecalc();
 
   return !hasOverflowClip();
 }
 
-// Called when a positioned object moves but doesn't necessarily change size.  A simplified layout is attempted
-// that just updates the object's position. If the size does change, the object remains dirty.
+// Called when a positioned object moves but doesn't necessarily change size.
+// A simplified layout is attempted that just updates the object's position.
+// If the size does change, the object remains dirty.
 bool LayoutBlock::tryLayoutDoingPositionedMovementOnly() {
   LayoutUnit oldWidth = logicalWidth();
   LogicalExtentComputedValues computedValues;
   logicalExtentAfterUpdatingLogicalWidth(logicalTop(), computedValues);
-  // If we shrink to fit our width may have changed, so we still need full layout.
+  // If we shrink to fit our width may have changed, so we still need full
+  // layout.
   if (oldWidth != computedValues.m_extent)
     return false;
   setLogicalWidth(computedValues.m_extent);
   setLogicalLeft(computedValues.m_position);
   setMarginStart(computedValues.m_margins.m_start);
   setMarginEnd(computedValues.m_margins.m_end);
 
   LayoutUnit oldHeight = logicalHeight();
   LayoutUnit oldIntrinsicContentLogicalHeight = intrinsicContentLogicalHeight();
 
@@ skipping 30 matching lines @@
       ASSERT(!currBox->needsLayout());
     }
   }
 }
 
 #endif
 
 LayoutUnit LayoutBlock::availableLogicalHeightForPercentageComputation() const {
   LayoutUnit availableHeight(-1);
 
-  // For anonymous blocks that are skipped during percentage height calculation, we consider them to have an indefinite height.
+  // For anonymous blocks that are skipped during percentage height calculation,
+  // we consider them to have an indefinite height.
   if (skipContainingBlockForPercentHeightCalculation(this))
     return availableHeight;
 
   const ComputedStyle& style = styleRef();
 
-  // A positioned element that specified both top/bottom or that specifies height should be treated as though it has a height
-  // explicitly specified that can be used for any percentage computations.
+  // A positioned element that specified both top/bottom or that specifies
+  // height should be treated as though it has a height explicitly specified
+  // that can be used for any percentage computations.
   bool isOutOfFlowPositionedWithSpecifiedHeight =
       isOutOfFlowPositioned() &&
       (!style.logicalHeight().isAuto() ||
        (!style.logicalTop().isAuto() && !style.logicalBottom().isAuto()));
 
   LayoutUnit stretchedFlexHeight(-1);
   if (isFlexItem())
     stretchedFlexHeight =
         toLayoutFlexibleBox(parent())
             ->childLogicalHeightForPercentageResolution(*this);
@@ skipping 38 matching lines @@
   }
 
   return availableHeight;
 }
 
 bool LayoutBlock::hasDefiniteLogicalHeight() const {
   return availableLogicalHeightForPercentageComputation() != LayoutUnit(-1);
 }
 
 }  // namespace blink