[css-flexbox] Wrap comments at 80 characters

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

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 102 matching lines @@
 
 LayoutFlexibleBox* LayoutFlexibleBox::createAnonymous(Document* document) {
   LayoutFlexibleBox* layoutObject = new LayoutFlexibleBox(nullptr);
   layoutObject->setDocumentForAnonymous(document);
   return layoutObject;
 }
 
 void LayoutFlexibleBox::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
-  // FIXME: We're ignoring flex-basis here and we shouldn't. We can't start honoring it though until
-  // the flex shorthand stops setting it to 0.
-  // See https://bugs.webkit.org/show_bug.cgi?id=116117 and http://crbug.com/240765.
+  // FIXME: We're ignoring flex-basis here and we shouldn't. We can't start
+  // honoring it though until the flex shorthand stops setting it to 0. See
+  // https://bugs.webkit.org/show_bug.cgi?id=116117 and
+  // https://crbug.com/240765.
   float previousMaxContentFlexFraction = -1;
   for (LayoutBox* child = firstChildBox(); child;
        child = child->nextSiblingBox()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
     LayoutUnit margin = marginIntrinsicLogicalWidthForChild(*child);
 
     LayoutUnit minPreferredLogicalWidth;
     LayoutUnit maxPreferredLogicalWidth;
     computeChildPreferredLogicalWidths(*child, minPreferredLogicalWidth,
                                        maxPreferredLogicalWidth);
     DCHECK_GE(minPreferredLogicalWidth, LayoutUnit());
     DCHECK_GE(maxPreferredLogicalWidth, LayoutUnit());
     minPreferredLogicalWidth += margin;
     maxPreferredLogicalWidth += margin;
     if (!isColumnFlow()) {
       maxLogicalWidth += maxPreferredLogicalWidth;
       if (isMultiline()) {
-        // For multiline, the min preferred width is if you put a break between each item.
+        // For multiline, the min preferred width is if you put a break between
+        // each item.
         minLogicalWidth = std::max(minLogicalWidth, minPreferredLogicalWidth);
       } else {
         minLogicalWidth += minPreferredLogicalWidth;
       }
     } else {
       minLogicalWidth = std::max(minPreferredLogicalWidth, minLogicalWidth);
       maxLogicalWidth = std::max(maxPreferredLogicalWidth, maxLogicalWidth);
     }
 
     previousMaxContentFlexFraction = countIntrinsicSizeForAlgorithmChange(
         maxPreferredLogicalWidth, child, previousMaxContentFlexFraction);
   }
 
   maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
 
-  // Due to negative margins, it is possible that we calculated a negative intrinsic width. Make sure that we
-  // never return a negative width.
+  // Due to negative margins, it is possible that we calculated a negative
+  // intrinsic width. Make sure that we never return a negative width.
   minLogicalWidth = std::max(LayoutUnit(), minLogicalWidth);
   maxLogicalWidth = std::max(LayoutUnit(), maxLogicalWidth);
 
   LayoutUnit scrollbarWidth(scrollbarLogicalWidth());
   maxLogicalWidth += scrollbarWidth;
   minLogicalWidth += scrollbarWidth;
 }
 
 float LayoutFlexibleBox::countIntrinsicSizeForAlgorithmChange(
     LayoutUnit maxPreferredLogicalWidth,
     LayoutBox* child,
     float previousMaxContentFlexFraction) const {
-  // Determine whether the new version of the intrinsic size algorithm of the flexbox
-  // spec would produce a different result than our above algorithm.
-  // The algorithm produces a different result iff the max-content flex fraction
-  // (as defined in the new algorithm) is not identical for each flex item.
+  // Determine whether the new version of the intrinsic size algorithm of the
+  // flexbox spec would produce a different result than our above algorithm.
+  // The algorithm produces a different result iff the max-content flex
+  // fraction (as defined in the new algorithm) is not identical for each flex
+  // item.
   if (isColumnFlow())
     return previousMaxContentFlexFraction;
   Length flexBasis = child->styleRef().flexBasis();
   float flexGrow = child->styleRef().flexGrow();
-  // A flex-basis of auto will lead to a max-content flex fraction of zero, so just like
-  // an inflexible item it would compute to a size of max-content, so we ignore it here.
+  // A flex-basis of auto will lead to a max-content flex fraction of zero, so
+  // just like an inflexible item it would compute to a size of max-content, so
+  // we ignore it here.
   if (flexBasis.isAuto() || flexGrow == 0)
     return previousMaxContentFlexFraction;
   flexGrow = std::max(1.0f, flexGrow);
   float maxContentFlexFraction = maxPreferredLogicalWidth.toFloat() / flexGrow;
   if (previousMaxContentFlexFraction != -1 &&
       maxContentFlexFraction != previousMaxContentFlexFraction)
     UseCounter::count(document(),
                       UseCounter::FlexboxIntrinsicSizeAlgorithmIsDifferent);
   return maxContentFlexFraction;
 }
@@ skipping 16 matching lines @@
                                         LinePositionMode mode) const {
   DCHECK_EQ(mode, PositionOnContainingLine);
   int baseline = firstLineBoxBaseline();
   if (baseline == -1)
     baseline = synthesizedBaselineFromContentBox(*this, direction);
 
   return beforeMarginInLineDirection(direction) + baseline;
 }
 
 static const StyleContentAlignmentData& contentAlignmentNormalBehavior() {
-  // The justify-content property applies along the main axis, but since flexing
-  // in the main axis is controlled by flex, stretch behaves as flex-start (ignoring
-  // the specified fallback alignment, if any).
+  // The justify-content property applies along the main axis, but since
+  // flexing in the main axis is controlled by flex, stretch behaves as
+  // flex-start (ignoring the specified fallback alignment, if any).
   // https://drafts.csswg.org/css-align/#distribution-flex
   static const StyleContentAlignmentData normalBehavior = {
       ContentPositionNormal, ContentDistributionStretch};
   return normalBehavior;
 }
 
 int LayoutFlexibleBox::firstLineBoxBaseline() const {
   if (isWritingModeRoot() || m_numberOfInFlowChildrenOnFirstLine <= 0)
     return -1;
   LayoutBox* baselineChild = nullptr;
@@ skipping 22 matching lines @@
     return (crossAxisExtentForChild(*baselineChild) +
             baselineChild->logicalTop())
         .toInt();
   if (isColumnFlow() && !hasOrthogonalFlow(*baselineChild))
     return (mainAxisExtentForChild(*baselineChild) +
             baselineChild->logicalTop())
         .toInt();
 
   int baseline = baselineChild->firstLineBoxBaseline();
   if (baseline == -1) {
-    // FIXME: We should pass |direction| into firstLineBoxBaseline and stop bailing out if we're a writing mode root.
-    // This would also fix some cases where the flexbox is orthogonal to its container.
+    // FIXME: We should pass |direction| into firstLineBoxBaseline and stop
+    // bailing out if we're a writing mode root. This would also fix some
+    // cases where the flexbox is orthogonal to its container.
     LineDirectionMode direction =
         isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
     return (synthesizedBaselineFromContentBox(*baselineChild, direction) +
             baselineChild->logicalTop())
         .toInt();
   }
 
   return (baseline + baselineChild->logicalTop()).toInt();
 }
 
@@ skipping 62 matching lines @@
     return flexDirection ==
            (style()->isLeftToRightDirection() ? FlowRowReverse : FlowRow);
   return flexDirection == FlowColumnReverse;
 }
 
 void LayoutFlexibleBox::removeChild(LayoutObject* child) {
   LayoutBlock::removeChild(child);
   m_intrinsicSizeAlongMainAxis.remove(child);
 }
 
-// TODO (lajava): Is this function still needed ? Every time the flex container's align-items value changes we
-// propagate the diff to its children (see ComputedStyle::stylePropagationDiff).
+// TODO (lajava): Is this function still needed ? Every time the flex
+// container's align-items value changes we propagate the diff to its children
+// (see ComputedStyle::stylePropagationDiff).
 void LayoutFlexibleBox::styleDidChange(StyleDifference diff,
                                        const ComputedStyle* oldStyle) {
   LayoutBlock::styleDidChange(diff, oldStyle);
 
   if (oldStyle && oldStyle->alignItemsPosition() == ItemPositionStretch &&
       diff.needsFullLayout()) {
-    // Flex items that were previously stretching need to be relayed out so we can compute new available cross axis space.
-    // This is only necessary for stretching since other alignment values don't change the size of the box.
+    // Flex items that were previously stretching need to be relayed out so we
+    // can compute new available cross axis space. This is only necessary for
+    // stretching since other alignment values don't change the size of the
+    // box.
     for (LayoutBox* child = firstChildBox(); child;
          child = child->nextSiblingBox()) {
       ItemPosition previousAlignment =
           child->styleRef()
               .resolvedAlignSelf(selfAlignmentNormalBehavior(), oldStyle)
               .position();
       if (previousAlignment == ItemPositionStretch &&
           previousAlignment !=
               child->styleRef()
                   .resolvedAlignSelf(selfAlignmentNormalBehavior(), style())
@@ skipping 34 matching lines @@
       prepareOrderIteratorAndMargins();
       layoutFlexItems(true, layoutScope);
       PaintLayerScrollableArea::PreventRelayoutScope::resetRelayoutNeeded();
     }
 
     if (logicalHeight() != previousHeight)
       relayoutChildren = true;
 
     layoutPositionedObjects(relayoutChildren || isDocumentElement());
 
-    // FIXME: css3/flexbox/repaint-rtl-column.html seems to issue paint invalidations for more overflow than it needs to.
+    // FIXME: css3/flexbox/repaint-rtl-column.html seems to issue paint
+    // invalidations for more overflow than it needs to.
     computeOverflow(clientLogicalBottomAfterRepositioning());
   }
 
   updateLayerTransformAfterLayout();
 
-  // 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.
   updateAfterLayout();
 
   clearNeedsLayout();
 
-  // We have to reset this, because changes to our ancestors' style
-  // can affect this value.
+  // We have to reset this, because changes to our ancestors' style can affect
+  // this value.
   m_hasDefiniteHeight = SizeDefiniteness::Unknown;
 }
 
 void LayoutFlexibleBox::paintChildren(const PaintInfo& paintInfo,
                                       const LayoutPoint& paintOffset) const {
   BlockPainter::paintChildrenOfFlexibleBox(*this, paintInfo, paintOffset);
 }
 
 void LayoutFlexibleBox::repositionLogicalHeightDependentFlexItems(
     Vector<LineContext>& lineContexts,
     LayoutObject* childToExclude) {
   LayoutUnit crossAxisStartEdge =
       lineContexts.isEmpty() ? LayoutUnit() : lineContexts[0].crossAxisOffset;
   alignFlexLines(lineContexts);
 
   alignChildren(lineContexts, childToExclude);
 
   if (style()->flexWrap() == FlexWrapReverse)
     flipForWrapReverse(lineContexts, crossAxisStartEdge);
 
-  // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
+  // direction:rtl + flex-direction:column means the cross-axis direction is
+  // flipped.
   flipForRightToLeftColumn();
 }
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::clientLogicalBottomAfterRepositioning() {
   LayoutUnit maxChildLogicalBottom;
   for (LayoutBox* child = firstChildBox(); child;
        child = child->nextSiblingBox()) {
     if (child->isOutOfFlowPositioned())
       continue;
@@ skipping 68 matching lines @@
         child, childIntrinsicContentLogicalHeight);
   }
   return child.logicalHeight();
 }
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::childIntrinsicLogicalWidth(
     const LayoutBox& child) const {
   // This should only be called if the logical width is the cross size
   DCHECK(hasOrthogonalFlow(child));
-  // If our height is auto, make sure that our returned height is unaffected by earlier layouts by
-  // returning the max preferred logical width
+  // If our height is auto, make sure that our returned height is unaffected by
+  // earlier layouts by returning the max preferred logical width
   if (!crossAxisLengthIsDefinite(child, child.styleRef().logicalWidth()))
     return child.maxPreferredLogicalWidth();
 
   return child.logicalWidth();
 }
 
 LayoutUnit LayoutFlexibleBox::crossAxisIntrinsicExtentForChild(
     const LayoutBox& child) const {
   return hasOrthogonalFlow(child) ? childIntrinsicLogicalWidth(child)
                                   : childIntrinsicLogicalHeight(child);
@@ skipping 38 matching lines @@
                     computedValues.m_extent - borderPaddingAndScrollbar);
   }
   return contentLogicalWidth();
 }
 
 LayoutUnit LayoutFlexibleBox::computeMainAxisExtentForChild(
     const LayoutBox& child,
     SizeType sizeType,
     const Length& size) {
   // If we have a horizontal flow, that means the main size is the width.
-  // That's the logical width for horizontal writing modes, and the logical height in vertical writing modes.
-  // For a vertical flow, main size is the height, so it's the inverse.
-  // So we need the logical width if we have a horizontal flow and horizontal writing mode, or vertical flow and vertical writing mode.
-  // Otherwise we need the logical height.
+  // That's the logical width for horizontal writing modes, and the logical
+  // height in vertical writing modes. For a vertical flow, main size is the
+  // height, so it's the inverse. So we need the logical width if we have a
+  // horizontal flow and horizontal writing mode, or vertical flow and vertical
+  // writing mode. Otherwise we need the logical height.
   if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode()) {
-    // We don't have to check for "auto" here - computeContentLogicalHeight will just return -1 for that case anyway.
-    // It's safe to access scrollbarLogicalHeight here because computeNextFlexLine will have already
-    // forced layout on the child.
-    // We previously layed out the child if necessary (see computeNextFlexLine and the call to childHasIntrinsicMainAxisSize)
-    // so we can be sure that the two height calls here will return up-to-date data.
+    // We don't have to check for "auto" here - computeContentLogicalHeight
+    // will just return -1 for that case anyway. It's safe to access
+    // scrollbarLogicalHeight here because computeNextFlexLine will have
+    // already forced layout on the child. We previously layed out the child
+    // if necessary (see computeNextFlexLine and the call to
+    // childHasIntrinsicMainAxisSize) so we can be sure that the two height
+    // calls here will return up-to-date data.
     return child.computeContentLogicalHeight(
                sizeType, size, child.intrinsicContentLogicalHeight()) +
            child.scrollbarLogicalHeight();
   }
-  // computeLogicalWidth always re-computes the intrinsic widths. However, when our logical width is auto,
-  // we can just use our cached value. So let's do that here. (Compare code in LayoutBlock::computePreferredLogicalWidths)
+  // computeLogicalWidth always re-computes the intrinsic widths. However, when
+  // our logical width is auto, we can just use our cached value. So let's do
+  // that here. (Compare code in LayoutBlock::computePreferredLogicalWidths)
   LayoutUnit borderAndPadding = child.borderAndPaddingLogicalWidth();
   if (child.styleRef().logicalWidth().isAuto() && !hasAspectRatio(child)) {
     if (size.type() == MinContent)
       return child.minPreferredLogicalWidth() - borderAndPadding;
     if (size.type() == MaxContent)
       return child.maxPreferredLogicalWidth() - borderAndPadding;
   }
   return child.computeLogicalWidthUsing(sizeType, size, contentLogicalWidth(),
                                         this) -
          borderAndPadding;
@@ skipping 246 matching lines @@
     if (hasOrthogonalFlow(child) ||
         m_hasDefiniteHeight == SizeDefiniteness::Definite)
       return true;
     if (m_hasDefiniteHeight == SizeDefiniteness::Indefinite)
       return false;
     bool definite = child.computePercentageLogicalHeight(length) != -1;
     m_hasDefiniteHeight =
         definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite;
     return definite;
   }
-  // TODO(cbiesinger): Eventually we should support other types of sizes here. Requires updating
-  // computeMainSizeFromAspectRatioUsing.
+  // TODO(cbiesinger): Eventually we should support other types of sizes here.
+  // Requires updating computeMainSizeFromAspectRatioUsing.
   return length.isFixed();
 }
 
 bool LayoutFlexibleBox::childFlexBaseSizeRequiresLayout(
     const LayoutBox& child) const {
   return (!mainAxisLengthIsDefinite(child, flexBasisForChild(child)) &&
           (hasOrthogonalFlow(child) ||
            (crossAxisOverflowForChild(child) == OverflowAuto &&
             !PaintLayerScrollableArea::FreezeScrollbarsScope::
                 scrollbarsAreFrozen())));
 }
 
 void LayoutFlexibleBox::cacheChildMainSize(const LayoutBox& child) {
   DCHECK(!child.needsLayout());
   LayoutUnit mainSize;
   if (hasOrthogonalFlow(child)) {
     mainSize = child.logicalHeight();
   } else {
-    // The max preferred logical width includes the intrinsic scrollbar logical width, which is only set for
-    // overflow: scroll. To handle overflow: auto, we have to take scrollbarLogicalWidth() into account, and then
-    // subtract the intrinsic width again so as to not double-count overflow: scroll scrollbars.
+    // The max preferred logical width includes the intrinsic scrollbar logical
+    // width, which is only set for overflow: scroll. To handle overflow: auto,
+    // we have to take scrollbarLogicalWidth() into account, and then subtract
+    // the intrinsic width again so as to not double-count overflow: scroll
+    // scrollbars.
     mainSize = child.maxPreferredLogicalWidth() +
                child.scrollbarLogicalWidth() - child.scrollbarLogicalWidth();
   }
   m_intrinsicSizeAlongMainAxis.set(&child, mainSize);
   m_relaidOutChildren.add(&child);
 }
 
 void LayoutFlexibleBox::clearCachedMainSizeForChild(const LayoutBox& child) {
   m_intrinsicSizeAlongMainAxis.remove(&child);
 }
@@ skipping 23 matching lines @@
 
     updateBlockChildDirtyBitsBeforeLayout(childLayoutType == ForceLayout,
                                           child);
     if (child.needsLayout() || childLayoutType == ForceLayout ||
         !m_intrinsicSizeAlongMainAxis.contains(&child)) {
       child.forceChildLayout();
       cacheChildMainSize(child);
     }
     mainAxisExtent = m_intrinsicSizeAlongMainAxis.get(&child);
   } else {
-    // We don't need to add scrollbarLogicalWidth here. For overflow: scroll, the preferred width
-    // already includes the scrollbar size (via scrollbarLogicalWidth()). For overflow: auto,
-    // childFlexBaseSizeRequiresLayout returns true and we handle that via the other branch
-    // of this if.
+    // We don't need to add scrollbarLogicalWidth here. For overflow: scroll,
+    // the preferred width already includes the scrollbar size (via
+    // scrollbarLogicalWidth()). For overflow: auto,
+    // childFlexBaseSizeRequiresLayout returns true and we handle that via the
+    // other branch of this if.
     mainAxisExtent = child.maxPreferredLogicalWidth();
   }
   DCHECK_GE(mainAxisExtent - mainAxisBorderAndPadding, LayoutUnit())
       << mainAxisExtent << " - " << mainAxisBorderAndPadding;
   return mainAxisExtent - mainAxisBorderAndPadding;
 }
 
 void LayoutFlexibleBox::layoutFlexItems(bool relayoutChildren,
                                         SubtreeLayoutScope& layoutScope) {
   Vector<LineContext> lineContexts;
   OrderedFlexItemList orderedChildren;
   LayoutUnit sumFlexBaseSize;
   double totalFlexGrow;
   double totalFlexShrink;
   double totalWeightedFlexShrink;
   LayoutUnit sumHypotheticalMainSize;
 
   PaintLayerScrollableArea::PreventRelayoutScope preventRelayoutScope(
       layoutScope);
 
-  // Fieldsets need to find their legend and position it inside the border of the object.
-  // The legend then gets skipped during normal layout.
-  // It doesn't get included in the normal layout process but is instead skipped.
+  // Fieldsets need to find their legend and position it inside the border of
+  // the object. The legend then gets skipped during normal layout. It
+  // doesn't get included in the normal layout process but is instead skipped.
   LayoutObject* childToExclude =
       layoutSpecialExcludedChild(relayoutChildren, layoutScope);
 
   m_orderIterator.first();
   LayoutUnit crossAxisOffset =
       flowAwareBorderBefore() + flowAwarePaddingBefore();
   while (computeNextFlexLine(orderedChildren, sumFlexBaseSize, totalFlexGrow,
                              totalFlexShrink, totalWeightedFlexShrink,
                              sumHypotheticalMainSize, relayoutChildren,
                              childToExclude)) {
     LayoutUnit containerMainInnerSize =
         mainAxisContentExtent(sumHypotheticalMainSize);
     // availableFreeSpace is the initial amount of free space in this flexbox.
-    // remainingFreeSpace starts out at the same value but as we place and lay out
-    // flex items we subtract from it. Note that both values can be negative.
+    // remainingFreeSpace starts out at the same value but as we place and lay
+    // out flex items we subtract from it. Note that both values can be
+    // negative.
     LayoutUnit remainingFreeSpace = containerMainInnerSize - sumFlexBaseSize;
     FlexSign flexSign = (sumHypotheticalMainSize < containerMainInnerSize)
                             ? PositiveFlexibility
                             : NegativeFlexibility;
     freezeInflexibleItems(flexSign, orderedChildren, remainingFreeSpace,
                           totalFlexGrow, totalFlexShrink,
                           totalWeightedFlexShrink);
-    // The initial free space gets calculated after freezing inflexible items. https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths step 3
+    // The initial free space gets calculated after freezing inflexible items.
+    // https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths step 3
     const LayoutUnit initialFreeSpace = remainingFreeSpace;
     while (!resolveFlexibleLengths(flexSign, orderedChildren, initialFreeSpace,
                                    remainingFreeSpace, totalFlexGrow,
                                    totalFlexShrink, totalWeightedFlexShrink)) {
       DCHECK_GE(totalFlexGrow, 0);
       DCHECK_GE(totalWeightedFlexShrink, 0);
     }
 
-    // Recalculate the remaining free space. The adjustment for flex factors between 0..1 means we can't just
-    // use remainingFreeSpace here.
+    // Recalculate the remaining free space. The adjustment for flex factors
+    // between 0..1 means we can't just use remainingFreeSpace here.
     remainingFreeSpace = containerMainInnerSize;
     for (size_t i = 0; i < orderedChildren.size(); ++i) {
       FlexItem& flexItem = orderedChildren[i];
       LayoutBox* child = orderedChildren[i].box;
       if (child->isOutOfFlowPositioned())
         continue;
       remainingFreeSpace -= orderedChildren[i].flexedContentSize +
                             flexItem.mainAxisBorderAndPadding +
                             flexItem.mainAxisMargin;
     }
@@ skipping 108 matching lines @@
       child.setMarginTop(availableAlignmentSpace / 2);
       child.setMarginBottom(availableAlignmentSpace / 2);
     } else {
       child.setMarginLeft(availableAlignmentSpace / 2);
       child.setMarginRight(availableAlignmentSpace / 2);
     }
     return true;
   }
   bool shouldAdjustTopOrLeft = true;
   if (isColumnFlow() && !child.style()->isLeftToRightDirection()) {
-    // For column flows, only make this adjustment if topOrLeft corresponds to the "before" margin,
-    // so that flipForRightToLeftColumn will do the right thing.
+    // For column flows, only make this adjustment if topOrLeft corresponds to
+    // the "before" margin, so that flipForRightToLeftColumn will do the right
+    // thing.
     shouldAdjustTopOrLeft = false;
   }
   if (!isColumnFlow() && child.style()->isFlippedBlocksWritingMode()) {
-    // If we are a flipped writing mode, we need to adjust the opposite side. This is only needed
-    // for row flows because this only affects the block-direction axis.
+    // If we are a flipped writing mode, we need to adjust the opposite side.
+    // This is only needed for row flows because this only affects the
+    // block-direction axis.
     shouldAdjustTopOrLeft = false;
   }
 
   if (topOrLeft.isAuto()) {
     if (shouldAdjustTopOrLeft)
       adjustAlignmentForChild(child, availableAlignmentSpace);
 
     if (isHorizontal)
       child.setMarginTop(availableAlignmentSpace);
     else
@@ skipping 15 matching lines @@
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::marginBoxAscentForChild(const LayoutBox& child) {
   LayoutUnit ascent(child.firstLineBoxBaseline());
   if (ascent == -1)
     ascent = crossAxisExtentForChild(child);
   return ascent + flowAwareMarginBeforeForChild(child);
 }
 
 LayoutUnit LayoutFlexibleBox::computeChildMarginValue(Length margin) {
-  // When resolving the margins, we use the content size for resolving percent and calc (for percents in calc expressions) margins.
-  // Fortunately, percent margins are always computed with respect to the block's width, even for margin-top and margin-bottom.
+  // When resolving the margins, we use the content size for resolving percent
+  // and calc (for percents in calc expressions) margins. Fortunately, percent
+  // margins are always computed with respect to the block's width, even for
+  // margin-top and margin-bottom.
   LayoutUnit availableSize = contentLogicalWidth();
   return minimumValueForLength(margin, availableSize);
 }
 
 void LayoutFlexibleBox::prepareOrderIteratorAndMargins() {
   OrderIteratorPopulator populator(m_orderIterator);
 
   for (LayoutBox* child = firstChildBox(); child;
        child = child->nextSiblingBox()) {
     populator.collectChild(child);
 
     if (child->isOutOfFlowPositioned())
       continue;
 
     // Before running the flex algorithm, 'auto' has a margin of 0.
-    // Also, if we're not auto sizing, we don't do a layout that computes the start/end margins.
+    // Also, if we're not auto sizing, we don't do a layout that computes the
+    // start/end margins.
     if (isHorizontalFlow()) {
       child->setMarginLeft(
           computeChildMarginValue(child->style()->marginLeft()));
       child->setMarginRight(
           computeChildMarginValue(child->style()->marginRight()));
     } else {
       child->setMarginTop(computeChildMarginValue(child->style()->marginTop()));
       child->setMarginBottom(
           computeChildMarginValue(child->style()->marginBottom()));
     }
@@ skipping 12 matching lines @@
     DCHECK_GE(maxExtent, LayoutUnit(-1));
     if (maxExtent != -1 && childSize > maxExtent)
       childSize = maxExtent;
   }
 
   Length min = isHorizontalFlow() ? child.style()->minWidth()
                                   : child.style()->minHeight();
   LayoutUnit minExtent;
   if (min.isSpecifiedOrIntrinsic()) {
     minExtent = computeMainAxisExtentForChild(child, MinSize, min);
-    // computeMainAxisExtentForChild can return -1 when the child has a percentage
-    // min size, but we have an indefinite size in that axis.
+    // computeMainAxisExtentForChild can return -1 when the child has a
+    // percentage min size, but we have an indefinite size in that axis.
     minExtent = std::max(LayoutUnit(), minExtent);
   } else if (min.isAuto() && !child.styleRef().containsSize() &&
              mainAxisOverflowForChild(child) == OverflowVisible &&
              !(isColumnFlow() && child.isFlexibleBox())) {
-    // TODO(cbiesinger): For now, we do not handle min-height: auto for nested column flexboxes. We need
-    // to implement https://drafts.csswg.org/css-flexbox/#intrinsic-sizes before that produces
-    // reasonable results. Tracking bug: https://crbug.com/581553
+    // TODO(cbiesinger): For now, we do not handle min-height: auto for nested
+    // column flexboxes. We need to implement
+    // https://drafts.csswg.org/css-flexbox/#intrinsic-sizes before that
+    // produces reasonable results. Tracking bug: https://crbug.com/581553
     // css-flexbox section 4.5
     LayoutUnit contentSize =
         computeMainAxisExtentForChild(child, MinSize, Length(MinContent));
     DCHECK_GE(contentSize, LayoutUnit());
     if (hasAspectRatio(child) && child.intrinsicSize().height() > 0)
       contentSize =
           adjustChildSizeForAspectRatioCrossAxisMinAndMax(child, contentSize);
     if (maxExtent != -1 && contentSize > maxExtent)
       contentSize = maxExtent;
 
@@ skipping 28 matching lines @@
     const LayoutBox& child) {
   if (alignmentForChild(child) != ItemPositionStretch)
     return LayoutUnit(-1);
 
   // Here we implement https://drafts.csswg.org/css-flexbox/#algo-stretch
   if (hasOrthogonalFlow(child) && child.hasOverrideLogicalContentWidth())
     return child.overrideLogicalContentWidth();
   if (!hasOrthogonalFlow(child) && child.hasOverrideLogicalContentHeight())
     return child.overrideLogicalContentHeight();
 
-  // We don't currently implement the optimization from https://drafts.csswg.org/css-flexbox/#definite-sizes
-  // case 1. While that could speed up a specialized case, it requires determining if we have a definite
-  // size, which itself is not cheap. We can consider implementing it at a later time.
-  // (The correctness is ensured by redoing layout in applyStretchAlignmentToChild)
+  // We don't currently implement the optimization from
+  // https://drafts.csswg.org/css-flexbox/#definite-sizes case 1. While that
+  // could speed up a specialized case, it requires determining if we have a
+  // definite size, which itself is not cheap. We can consider implementing it
+  // at a later time. (The correctness is ensured by redoing layout in
+  // applyStretchAlignmentToChild)
   return LayoutUnit(-1);
 }
 
 LayoutUnit LayoutFlexibleBox::mainSizeForPercentageResolution(
     const LayoutBox& child) {
   // This function implements section 9.8. Definite and Indefinite Sizes, case
   // 2) of the flexbox spec.
   // We need to check for the flexbox to have a definite main size, and for the
   // flex item to have a definite flex basis.
   const Length& flexBasis = flexBasisForChild(child);
   if (!mainAxisLengthIsDefinite(child, flexBasis))
     return LayoutUnit(-1);
   if (!flexBasis.isPercentOrCalc()) {
-    // If flex basis had a percentage, our size is guaranteed to be definite or the flex item's
-    // size could not be definite.
-    // Otherwise, we make up a percentage to check whether we have a definite size.
+    // If flex basis had a percentage, our size is guaranteed to be definite or
+    // the flex item's size could not be definite. Otherwise, we make up a
+    // percentage to check whether we have a definite size.
     if (!mainAxisLengthIsDefinite(child, Length(0, Percent)))
       return LayoutUnit(-1);
   }
 
   if (hasOrthogonalFlow(child))
     return child.hasOverrideLogicalContentHeight()
                ? child.overrideLogicalContentHeight()
                : LayoutUnit(-1);
   return child.hasOverrideLogicalContentWidth()
              ? child.overrideLogicalContentWidth()
@@ skipping 62 matching lines @@
   if (!m_orderIterator.currentChild())
     return false;
 
   LayoutUnit lineBreakLength = mainAxisContentExtent(LayoutUnit::max());
 
   bool lineHasInFlowItem = false;
 
   for (LayoutBox* child = m_orderIterator.currentChild(); child;
        child = m_orderIterator.next()) {
     if (childToExclude == child)
-      continue;  // Skip this child, since it will be positioned by the specialized subclass (fieldsets runs).
+      continue;  // Skip this child, since it will be positioned by the
+                 // specialized subclass (fieldsets runs).
 
     if (child->isOutOfFlowPositioned()) {
       orderedChildren.append(FlexItem(child));
       continue;
     }
 
     ChildLayoutType layoutType =
         relayoutChildren ? ForceLayout : LayoutIfNeeded;
 
-    // If this condition is true, then computeMainAxisExtentForChild will call child.intrinsicContentLogicalHeight()
-    // and child.scrollbarLogicalHeight(), so if the child has intrinsic min/max/preferred size,
-    // run layout on it now to make sure its logical height and scroll bars are up to date.
+    // If this condition is true, then computeMainAxisExtentForChild will call
+    // child.intrinsicContentLogicalHeight() and
+    // child.scrollbarLogicalHeight(), so if the child has intrinsic
+    // min/max/preferred size, run layout on it now to make sure its logical
+    // height and scroll bars are up to date.
     if (childHasIntrinsicMainAxisSize(*child) && child->needsLayout()) {
       child->clearOverrideSize();
       child->forceChildLayout();
       cacheChildMainSize(*child);
       layoutType = LayoutIfNeeded;
     }
 
     FlexItem flexItem = constructFlexItem(*child, layoutType);
     if (isMultiline() &&
         sumHypotheticalMainSize + flexItem.hypotheticalMainAxisMarginBoxSize() >
@@ skipping 19 matching lines @@
                                          double& totalWeightedFlexShrink) {
   for (size_t i = 0; i < violations.size(); ++i) {
     DCHECK(!violations[i]->frozen) << i;
     LayoutBox* child = violations[i]->box;
     LayoutUnit childSize = violations[i]->flexedContentSize;
     availableFreeSpace -= childSize - violations[i]->flexBaseContentSize;
     totalFlexGrow -= child->style()->flexGrow();
     totalFlexShrink -= child->style()->flexShrink();
     totalWeightedFlexShrink -=
         child->style()->flexShrink() * violations[i]->flexBaseContentSize;
-    // totalWeightedFlexShrink can be negative when we exceed the precision of a double when we initially
-    // calcuate totalWeightedFlexShrink. We then subtract each child's weighted flex shrink with full precision,
-    // now leading to a negative result. See css3/flexbox/large-flex-shrink-assert.html
+    // totalWeightedFlexShrink can be negative when we exceed the precision of
+    // a double when we initially calcuate totalWeightedFlexShrink. We then
+    // subtract each child's weighted flex shrink with full precision, now
+    // leading to a negative result. See
+    // css3/flexbox/large-flex-shrink-assert.html
     totalWeightedFlexShrink = std::max(totalWeightedFlexShrink, 0.0);
     violations[i]->frozen = true;
   }
 }
 
 void LayoutFlexibleBox::freezeInflexibleItems(FlexSign flexSign,
                                               OrderedFlexItemList& children,
                                               LayoutUnit& remainingFreeSpace,
                                               double& totalFlexGrow,
                                               double& totalFlexShrink,
                                               double& totalWeightedFlexShrink) {
   // Per https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths step 2,
-  // we freeze all items with a flex factor of 0 as well as this with a min/max size violation.
+  // we freeze all items with a flex factor of 0 as well as those with a min/max
+  // size violation.
   Vector<FlexItem*> newInflexibleItems;
   for (size_t i = 0; i < children.size(); ++i) {
     FlexItem& flexItem = children[i];
     LayoutBox* child = flexItem.box;
     if (child->isOutOfFlowPositioned())
       continue;
     DCHECK(!flexItem.frozen) << i;
     float flexFactor = (flexSign == PositiveFlexibility)
                            ? child->style()->flexGrow()
                            : child->style()->flexShrink();
@@ skipping 116 matching lines @@
                                   ItemPosition position,
                                   LayoutUnit ascent,
                                   LayoutUnit maxAscent,
                                   bool isWrapReverse) {
   switch (position) {
     case ItemPositionAuto:
     case ItemPositionNormal:
       NOTREACHED();
       break;
     case ItemPositionStretch:
-      // Actual stretching must be handled by the caller.
-      // Since wrap-reverse flips cross start and cross end, stretch children should be aligned with the cross end.
-      // This matters because applyStretchAlignment doesn't always stretch or stretch fully (explicit cross size given,
-      // or stretching constrained by max-height/max-width).
-      // For flex-start and flex-end this is handled by alignmentForChild().
+      // Actual stretching must be handled by the caller. Since wrap-reverse
+      // flips cross start and cross end, stretch children should be aligned
+      // with the cross end. This matters because applyStretchAlignment
+      // doesn't always stretch or stretch fully (explicit cross size given, or
+      // stretching constrained by max-height/max-width). For flex-start and
+      // flex-end this is handled by alignmentForChild().
       if (isWrapReverse)
         return availableFreeSpace;
       break;
     case ItemPositionFlexStart:
       break;
     case ItemPositionFlexEnd:
       return availableFreeSpace;
     case ItemPositionCenter:
       return availableFreeSpace / 2;
     case ItemPositionBaseline:
-      // FIXME: If we get here in columns, we want the use the descent, except we currently can't get the ascent/descent of orthogonal children.
+      // FIXME: If we get here in columns, we want the use the descent, except
+      // we currently can't get the ascent/descent of orthogonal children.
       // https://bugs.webkit.org/show_bug.cgi?id=98076
       return maxAscent - ascent;
     case ItemPositionLastBaseline:
     case ItemPositionSelfStart:
     case ItemPositionSelfEnd:
     case ItemPositionStart:
     case ItemPositionEnd:
     case ItemPositionLeft:
     case ItemPositionRight:
       // FIXME: Implement these (https://crbug.com/507690). The extended grammar
@@ skipping 147 matching lines @@
       if (child.style()->marginLeft().isAuto())
         child.setMarginLeft(LayoutUnit());
       if (child.style()->marginRight().isAuto())
         child.setMarginRight(LayoutUnit());
     }
   }
 }
 
 bool LayoutFlexibleBox::needToStretchChildLogicalHeight(
     const LayoutBox& child) const {
-  // This function is a little bit magical. It relies on the fact that blocks intrinsically
-  // "stretch" themselves in their inline axis, i.e. a <div> has an implicit width: 100%.
-  // So the child will automatically stretch if our cross axis is the child's inline axis. That's the case if:
+  // This function is a little bit magical. It relies on the fact that blocks
+  // intrinsically "stretch" themselves in their inline axis, i.e. a <div> has
+  // an implicit width: 100%. So the child will automatically stretch if our
+  // cross axis is the child's inline axis. That's the case if:
   // - We are horizontal and the child is in vertical writing mode
   // - We are vertical and the child is in horizontal writing mode
   // Otherwise, we need to stretch if the cross axis size is auto.
   if (alignmentForChild(child) != ItemPositionStretch)
     return false;
 
   if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode())
     return false;
 
   return child.styleRef().logicalHeight().isAuto();
@@ skipping 76 matching lines @@
     child->setMayNeedPaintInvalidation();
 
     setOverrideMainAxisContentSizeForChild(*child, flexItem.flexedContentSize);
     // The flexed content size and the override size include the scrollbar
     // width, so we need to compare to the size including the scrollbar.
     // TODO(cbiesinger): Should it include the scrollbar?
     if (flexItem.flexedContentSize !=
         mainAxisContentExtentForChildIncludingScrollbar(*child)) {
       child->setChildNeedsLayout(MarkOnlyThis);
     } else {
-      // To avoid double applying margin changes in updateAutoMarginsInCrossAxis, we reset the margins here.
+      // To avoid double applying margin changes in
+      // updateAutoMarginsInCrossAxis, we reset the margins here.
       resetAutoMarginsAndLogicalTopInCrossAxis(*child);
     }
-    // We may have already forced relayout for orthogonal flowing children in computeInnerFlexBaseSizeForChild.
+    // We may have already forced relayout for orthogonal flowing children in
+    // computeInnerFlexBaseSizeForChild.
     bool forceChildRelayout =
         relayoutChildren && !m_relaidOutChildren.contains(child);
     if (child->isLayoutBlock() &&
         toLayoutBlock(*child).hasPercentHeightDescendants()) {
-      // Have to force another relayout even though the child is sized correctly, because
-      // its descendants are not sized correctly yet. Our previous layout of the child was
-      // done without an override height set. So, redo it here.
+      // Have to force another relayout even though the child is sized
+      // correctly, because its descendants are not sized correctly yet. Our
+      // previous layout of the child was done without an override height set.
+      // So, redo it here.
       forceChildRelayout = true;
     }
     updateBlockChildDirtyBitsBeforeLayout(forceChildRelayout, *child);
     if (!child->needsLayout())
       markChildForPaginationRelayoutIfNeeded(*child, layoutScope);
     if (child->needsLayout())
       m_relaidOutChildren.add(child);
     child->layoutIfNeeded();
 
     updateAutoMarginsInMainAxis(*child, autoMarginOffset);
@@ skipping 20 matching lines @@
       setLogicalHeight(std::max(
           logicalHeight(),
           crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() +
               childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
     maxChildCrossAxisExtent =
         std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
 
     mainAxisOffset += flowAwareMarginStartForChild(*child);
 
     LayoutUnit childMainExtent = mainAxisExtentForChild(*child);
-    // In an RTL column situation, this will apply the margin-right/margin-end on the left.
-    // This will be fixed later in flipForRightToLeftColumn.
+    // In an RTL column situation, this will apply the margin-right/margin-end
+    // on the left. This will be fixed later in flipForRightToLeftColumn.
     LayoutPoint childLocation(
         shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent
                            : mainAxisOffset,
         crossAxisOffset + flowAwareMarginBeforeForChild(*child));
     setFlowAwareLocationForChild(*child, childLocation);
     mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(*child);
 
     ++seenInFlowPositionedChildren;
     if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
       mainAxisOffset += justifyContentSpaceBetweenChildren(
           availableFreeSpace, distribution, numberOfChildrenForJustifyContent);
   }
 
   if (isColumnFlow())
     setLogicalHeight(std::max(
         logicalHeight(), mainAxisOffset + flowAwareBorderEnd() +
                              flowAwarePaddingEnd() + scrollbarLogicalHeight()));
 
   if (style()->flexDirection() == FlowColumnReverse) {
-    // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
-    // on the height of the flexbox, which we only know after we've positioned all the flex items.
+    // We have to do an extra pass for column-reverse to reposition the flex
+    // items since the start depends on the height of the flexbox, which we
+    // only know after we've positioned all the flex items.
     updateLogicalHeight();
     layoutColumnReverse(children, crossAxisOffset, availableFreeSpace);
   }
 
   if (m_numberOfInFlowChildrenOnFirstLine == -1)
     m_numberOfInFlowChildrenOnFirstLine = seenInFlowPositionedChildren;
   lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent,
                                   children.size(), maxAscent));
   crossAxisOffset += maxChildCrossAxisExtent;
 }
 
 void LayoutFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children,
                                             LayoutUnit crossAxisOffset,
                                             LayoutUnit availableFreeSpace) {
   ContentPosition position = styleRef().resolvedJustifyContentPosition(
       contentAlignmentNormalBehavior());
   ContentDistributionType distribution =
       styleRef().resolvedJustifyContentDistribution(
           contentAlignmentNormalBehavior());
 
-  // This is similar to the logic in layoutAndPlaceChildren, except we place the children
-  // starting from the end of the flexbox. We also don't need to layout anything since we're
-  // just moving the children to a new position.
+  // This is similar to the logic in layoutAndPlaceChildren, except we place
+  // the children starting from the end of the flexbox. We also don't need to
+  // layout anything since we're just moving the children to a new position.
   size_t numberOfChildrenForJustifyContent =
       numberOfInFlowPositionedChildren(children);
   LayoutUnit mainAxisOffset =
       logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
   mainAxisOffset -=
       initialJustifyContentOffset(availableFreeSpace, position, distribution,
                                   numberOfChildrenForJustifyContent);
   mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth()
                                        : horizontalScrollbarHeight();
 
@@ skipping 55 matching lines @@
   return LayoutUnit();
 }
 
 void LayoutFlexibleBox::alignFlexLines(Vector<LineContext>& lineContexts) {
   ContentPosition position =
       styleRef().resolvedAlignContentPosition(contentAlignmentNormalBehavior());
   ContentDistributionType distribution =
       styleRef().resolvedAlignContentDistribution(
           contentAlignmentNormalBehavior());
 
-  // If we have a single line flexbox or a multiline line flexbox with only one flex line,
-  // the line height is all the available space.
-  // For flex-direction: row, this means we need to use the height, so we do this after calling updateLogicalHeight.
+  // If we have a single line flexbox or a multiline line flexbox with only one
+  // flex line, the line height is all the available space. For
+  // flex-direction: row, this means we need to use the height, so we do this
+  // after calling updateLogicalHeight.
   if (lineContexts.size() == 1) {
     lineContexts[0].crossAxisExtent = crossAxisContentExtent();
     return;
   }
 
   if (position == ContentPositionFlexStart)
     return;
 
   LayoutUnit availableCrossAxisSpace = crossAxisContentExtent();
   for (size_t i = 0; i < lineContexts.size(); ++i)
@@ skipping 24 matching lines @@
                                                 LayoutUnit delta) {
   if (child.isOutOfFlowPositioned())
     return;
 
   setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) +
                                           LayoutSize(LayoutUnit(), delta));
 }
 
 void LayoutFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts,
                                       LayoutObject* childToExclude) {
-  // Keep track of the space between the baseline edge and the after edge of the box for each line.
+  // Keep track of the space between the baseline edge and the after edge of
+  // the box for each line.
   Vector<LayoutUnit> minMarginAfterBaselines;
 
   LayoutBox* child = m_orderIterator.first();
   for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
     LayoutUnit minMarginAfterBaseline = LayoutUnit::max();
     LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
     LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
 
     for (size_t childNumber = 0;
          childNumber < lineContexts[lineNumber].numberOfChildren;
@@ skipping 27 matching lines @@
             minMarginAfterBaseline,
             availableAlignmentSpaceForChild(lineCrossAxisExtent, *child) -
                 offset);
     }
     minMarginAfterBaselines.append(minMarginAfterBaseline);
   }
 
   if (style()->flexWrap() != FlexWrapReverse)
     return;
 
-  // wrap-reverse flips the cross axis start and end. For baseline alignment, this means we
-  // need to align the after edge of baseline elements with the after edge of the flex line.
+  // wrap-reverse flips the cross axis start and end. For baseline alignment,
+  // this means we need to align the after edge of baseline elements with the
+  // after edge of the flex line.
   child = m_orderIterator.first();
   for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
     LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
     for (size_t childNumber = 0;
          childNumber < lineContexts[lineNumber].numberOfChildren;
          ++childNumber, child = m_orderIterator.next()) {
       DCHECK(child);
       if (alignmentForChild(*child) == ItemPositionBaseline &&
           !hasAutoMarginsInCrossAxis(*child) && minMarginAfterBaseline)
         adjustAlignmentForChild(*child, minMarginAfterBaseline);
     }
   }
 }
 
 void LayoutFlexibleBox::applyStretchAlignmentToChild(
     LayoutBox& child,
     LayoutUnit lineCrossAxisExtent) {
   if (!hasOrthogonalFlow(child) && child.style()->logicalHeight().isAuto()) {
     LayoutUnit heightBeforeStretching = childIntrinsicLogicalHeight(child);
     LayoutUnit stretchedLogicalHeight =
         std::max(child.borderAndPaddingLogicalHeight(),
                  heightBeforeStretching +
                      availableAlignmentSpaceForChildBeforeStretching(
                          lineCrossAxisExtent, child));
     DCHECK(!child.needsLayout());
     LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(
         stretchedLogicalHeight,
         heightBeforeStretching - child.borderAndPaddingLogicalHeight());
 
-    // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
+    // FIXME: Can avoid laying out here in some cases. See
+    // https://webkit.org/b/87905.
     bool childNeedsRelayout = desiredLogicalHeight != child.logicalHeight();
     if (child.isLayoutBlock() &&
         toLayoutBlock(child).hasPercentHeightDescendants() &&
         m_relaidOutChildren.contains(&child)) {
-      // Have to force another relayout even though the child is sized correctly, because
-      // its descendants are not sized correctly yet. Our previous layout of the child was
-      // done without an override height set. So, redo it here.
+      // Have to force another relayout even though the child is sized
+      // correctly, because its descendants are not sized correctly yet. Our
+      // previous layout of the child was done without an override height set.
+      // So, redo it here.
       childNeedsRelayout = true;
     }
     if (childNeedsRelayout || !child.hasOverrideLogicalContentHeight())
       child.setOverrideLogicalContentHeight(
           desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
     if (childNeedsRelayout) {
       child.setLogicalHeight(LayoutUnit());
-      // We cache the child's intrinsic content logical height to avoid it being reset to the stretched height.
-      // FIXME: This is fragile. LayoutBoxes should be smart enough to determine their intrinsic content logical
-      // height correctly even when there's an overrideHeight.
+      // We cache the child's intrinsic content logical height to avoid it being
+      // reset to the stretched height.
+      // FIXME: This is fragile. LayoutBoxes should be smart enough to
+      // determine their intrinsic content logical height correctly even when
+      // there's an overrideHeight.
       LayoutUnit childIntrinsicContentLogicalHeight =
           child.intrinsicContentLogicalHeight();
       child.forceChildLayout();
       child.setIntrinsicContentLogicalHeight(
           childIntrinsicContentLogicalHeight);
     }
   } else if (hasOrthogonalFlow(child) &&
              child.style()->logicalWidth().isAuto()) {
     LayoutUnit childWidth =
         (lineCrossAxisExtent - crossAxisMarginExtentForChild(child))
@@ skipping 42 matching lines @@
       LayoutUnit originalOffset =
           lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
       LayoutUnit newOffset =
           contentExtent - originalOffset - lineCrossAxisExtent;
       adjustAlignmentForChild(*child, newOffset - originalOffset);
     }
   }
 }
 
 }  // namespace blink