[css-flexbox] Wrap comments at 80 characters

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

 /*
  * This file is part of the layout object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003 Apple Computer, Inc.
  *
  * 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
@@ skipping 29 matching lines @@
 class FlexBoxIterator {
  public:
   FlexBoxIterator(LayoutDeprecatedFlexibleBox* parent)
       : m_box(parent), m_largestOrdinal(1) {
     if (m_box->style()->boxOrient() == HORIZONTAL &&
         !m_box->style()->isLeftToRightDirection())
       m_forward = m_box->style()->boxDirection() != BNORMAL;
     else
       m_forward = m_box->style()->boxDirection() == BNORMAL;
     if (!m_forward) {
-      // No choice, since we're going backwards, we have to find out the highest ordinal up front.
+      // No choice, since we're going backwards, we have to find out the highest
+      // ordinal up front.
       LayoutBox* child = m_box->firstChildBox();
       while (child) {
         if (child->style()->boxOrdinalGroup() > m_largestOrdinal)
           m_largestOrdinal = child->style()->boxOrdinalGroup();
         child = child->nextSiblingBox();
       }
     }
 
     reset();
   }
@@ skipping 13 matching lines @@
       if (!m_currentChild) {
         ++m_ordinalIteration;
 
         if (!m_ordinalIteration) {
           m_currentOrdinal = m_forward ? 1 : m_largestOrdinal;
         } else {
           if (static_cast<size_t>(m_ordinalIteration) >=
               m_ordinalValues.size() + 1)
             return nullptr;
 
-          // Only copy+sort the values once per layout even if the iterator is reset.
+          // Only copy+sort the values once per layout even if the iterator is
+          // reset.
           if (m_ordinalValues.size() != m_sortedOrdinalValues.size()) {
             copyToVector(m_ordinalValues, m_sortedOrdinalValues);
             std::sort(m_sortedOrdinalValues.begin(),
                       m_sortedOrdinalValues.end());
           }
           m_currentOrdinal =
               m_forward ? m_sortedOrdinalValues[m_ordinalIteration - 1]
                         : m_sortedOrdinalValues[m_sortedOrdinalValues.size() -
                                                 m_ordinalIteration];
         }
@@ skipping 23 matching lines @@
   LayoutDeprecatedFlexibleBox* m_box;
   LayoutBox* m_currentChild;
   bool m_forward;
   unsigned m_currentOrdinal;
   unsigned m_largestOrdinal;
   HashSet<unsigned> m_ordinalValues;
   Vector<unsigned> m_sortedOrdinalValues;
   int m_ordinalIteration;
 };
 
-// Helper methods for obtaining the last line, computing line counts and heights for line counts
+// Helper methods for obtaining the last line, computing line counts and heights
+// for line counts
 // (crawling into blocks).
 static bool shouldCheckLines(LayoutBlockFlow* blockFlow) {
   return !blockFlow->isFloatingOrOutOfFlowPositioned() &&
          blockFlow->style()->height().isAuto();
 }
 
 static int getHeightForLineCount(const LayoutBlockFlow* blockFlow,
                                  int lineCount,
                                  bool includeBottom,
                                  int& count) {
@@ skipping 272 matching lines @@
 // The first walk over our kids is to find out if we have any flexible children.
 static void gatherFlexChildrenInfo(FlexBoxIterator& iterator,
                                    bool relayoutChildren,
                                    unsigned& highestFlexGroup,
                                    unsigned& lowestFlexGroup,
                                    bool& haveFlex) {
   for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
     // Check to see if this child flexes.
     if (!childDoesNotAffectWidthOrFlexing(child) &&
         child->style()->boxFlex() > 0.0f) {
-      // We always have to lay out flexible objects again, since the flex distribution
+      // We always have to lay out flexible objects again, since the flex
+      // distribution
       // may have changed, and we need to reallocate space.
       child->clearOverrideSize();
       if (!relayoutChildren)
         child->setChildNeedsLayout(MarkOnlyThis);
       haveFlex = true;
       unsigned flexGroup = child->style()->boxFlexGroup();
       if (lowestFlexGroup == 0)
         lowestFlexGroup = flexGroup;
       if (flexGroup < lowestFlexGroup)
         lowestFlexGroup = flexGroup;
@@ skipping 33 matching lines @@
     // Our first pass is done without flexing.  We simply lay the children
     // out within the box.  We have to do a layout first in order to determine
     // our box's intrinsic height.
     LayoutUnit maxAscent;
     LayoutUnit maxDescent;
     for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
       if (child->isOutOfFlowPositioned())
         continue;
 
       SubtreeLayoutScope layoutScope(*child);
-      // TODO(jchaffraix): It seems incorrect to check isAtomicInlineLevel in this file.
+      // TODO(jchaffraix): It seems incorrect to check isAtomicInlineLevel in
+      // this file.
       // We probably want to check if the element is replaced.
       if (relayoutChildren || (child->isAtomicInlineLevel() &&
                                (child->style()->width().isPercentOrCalc() ||
                                 child->style()->height().isPercentOrCalc())))
         layoutScope.setChildNeedsLayout(child);
 
       // Compute the child's vertical margins.
       child->computeAndSetBlockDirectionMargins(this);
 
       if (!child->needsLayout())
@@ skipping 59 matching lines @@
 
       if (child->style()->visibility() == EVisibility::Collapse) {
         // visibility: collapsed children do not participate in our positioning.
         // But we need to lay them down.
         child->layoutIfNeeded();
         continue;
       }
 
       SubtreeLayoutScope layoutScope(*child);
 
-      // We need to see if this child's height will change, since we make block elements fill
-      // the height of a containing box by default. We cannot actually *set* the new height
-      // here, though. Need to do that from within layout, or we won't be able to detect the
-      // change and duly notify any positioned descendants that are affected by it.
+      // We need to see if this child's height will change, since we make block
+      // elements fill the height of a containing box by default. We cannot
+      // actually *set* the new height here, though. Need to do that from
+      // within layout, or we won't be able to detect the change and duly
+      // notify any positioned descendants that are affected by it.
       LayoutUnit oldChildHeight = child->logicalHeight();
       LogicalExtentComputedValues computedValues;
       child->computeLogicalHeight(child->logicalHeight(), child->logicalTop(),
                                   computedValues);
       LayoutUnit newChildHeight = computedValues.m_extent;
       if (oldChildHeight != newChildHeight)
         layoutScope.setChildNeedsLayout(child);
 
       if (!child->needsLayout())
         markChildForPaginationRelayoutIfNeeded(*child, layoutScope);
@@ skipping 32 matching lines @@
       xPos += child->size().width() + child->marginRight();
     }
 
     remainingSpace = size().width() - borderRight() - paddingRight() -
                      verticalScrollbarWidth() - xPos;
 
     m_stretchingChildren = false;
     if (flexingChildren) {
       haveFlex = false;  // We're done.
     } else if (haveFlex) {
-      // We have some flexible objects.  See if we need to grow/shrink them at all.
+      // We have some flexible objects.  See if we need to grow/shrink them at
+      // all.
       if (!remainingSpace)
         break;
 
-      // Allocate the remaining space among the flexible objects.  If we are trying to
-      // grow, then we go from the lowest flex group to the highest flex group.  For shrinking,
-      // we go from the highest flex group to the lowest group.
+      // Allocate the remaining space among the flexible objects.  If we are
+      // trying to grow, then we go from the lowest flex group to the highest
+      // flex group.  For shrinking, we go from the highest flex group to the
+      // lowest group.
       bool expanding = remainingSpace > 0;
       unsigned start = expanding ? lowestFlexGroup : highestFlexGroup;
       unsigned end = expanding ? highestFlexGroup : lowestFlexGroup;
       for (unsigned i = start; i <= end && remainingSpace; i++) {
-        // Always start off by assuming the group can get all the remaining space.
+        // Always start off by assuming the group can get all the remaining
+        // space.
         LayoutUnit groupRemainingSpace = remainingSpace;
         do {
-          // Flexing consists of multiple passes, since we have to change ratios every time an object hits its max/min-width
-          // For a given pass, we always start off by computing the totalFlex of all objects that can grow/shrink at all, and
-          // computing the allowed growth before an object hits its min/max width (and thus
-          // forces a totalFlex recomputation).
+          // Flexing consists of multiple passes, since we have to change
+          // ratios every time an object hits its max/min-width For a given
+          // pass, we always start off by computing the totalFlex of all
+          // objects that can grow/shrink at all, and computing the allowed
+          // growth before an object hits its min/max width (and thus forces a
+          // totalFlex recomputation).
           LayoutUnit groupRemainingSpaceAtBeginning = groupRemainingSpace;
           float totalFlex = 0.0f;
           for (LayoutBox* child = iterator.first(); child;
                child = iterator.next()) {
             if (allowedChildFlex(child, expanding, i))
               totalFlex += child->style()->boxFlex();
           }
           LayoutUnit spaceAvailableThisPass = groupRemainingSpace;
           for (LayoutBox* child = iterator.first(); child;
                child = iterator.next()) {
             LayoutUnit allowedFlex = allowedChildFlex(child, expanding, i);
             if (allowedFlex) {
               LayoutUnit projectedFlex =
                   (allowedFlex == LayoutUnit::max())
                       ? allowedFlex
                       : LayoutUnit(allowedFlex *
                                    (totalFlex / child->style()->boxFlex()));
               spaceAvailableThisPass =
                   expanding ? std::min(spaceAvailableThisPass, projectedFlex)
                             : std::max(spaceAvailableThisPass, projectedFlex);
             }
           }
 
           // The flex groups may not have any flexible objects this time around.
           if (!spaceAvailableThisPass || totalFlex == 0.0f) {
-            // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
+            // If we just couldn't grow/shrink any more, then it's time to
+            // transition to the next flex group.
             groupRemainingSpace = LayoutUnit();
             continue;
           }
 
           // Now distribute the space to objects.
           for (LayoutBox* child = iterator.first();
                child && spaceAvailableThisPass && totalFlex;
                child = iterator.next()) {
             if (child->style()->visibility() == EVisibility::Collapse)
               continue;
@@ skipping 10 matching lines @@
               }
 
               spaceAvailableThisPass -= spaceAdd;
               remainingSpace -= spaceAdd;
               groupRemainingSpace -= spaceAdd;
 
               totalFlex -= child->style()->boxFlex();
             }
           }
           if (groupRemainingSpace == groupRemainingSpaceAtBeginning) {
-            // This is not advancing, avoid getting stuck by distributing the remaining pixels.
+            // This is not advancing, avoid getting stuck by distributing the
+            // remaining pixels.
             LayoutUnit spaceAdd = LayoutUnit(groupRemainingSpace > 0 ? 1 : -1);
             for (LayoutBox* child = iterator.first();
                  child && groupRemainingSpace; child = iterator.next()) {
               if (allowedChildFlex(child, expanding, i)) {
                 child->setOverrideLogicalContentWidth(
                     contentWidthForChild(child) + spaceAdd);
                 flexingChildren = true;
                 relayoutChildren = true;
                 remainingSpace -= spaceAdd;
                 groupRemainingSpace -= spaceAdd;
@@ skipping 56 matching lines @@
       for (LayoutBox* child = iterator.first(); child;
            child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
           continue;
 
         placeChild(child, child->location() + LayoutSize(offset, LayoutUnit()));
       }
     }
   }
 
-  // So that the computeLogicalHeight in layoutBlock() knows to relayout positioned objects because of
-  // a height change, we revert our height back to the intrinsic height before returning.
+  // So that the computeLogicalHeight in layoutBlock() knows to relayout
+  // positioned objects because of a height change, we revert our height back
+  // to the intrinsic height before returning.
   if (heightSpecified)
     setHeight(oldHeight);
 }
 
 void LayoutDeprecatedFlexibleBox::layoutVerticalBox(bool relayoutChildren) {
   LayoutUnit yPos = borderTop() + paddingTop();
   LayoutUnit toAdd =
       borderBottom() + paddingBottom() + horizontalScrollbarHeight();
   bool heightSpecified = false;
   LayoutUnit oldHeight;
 
   LayoutUnit remainingSpace;
 
   FlexBoxIterator iterator(this);
   unsigned highestFlexGroup = 0;
   unsigned lowestFlexGroup = 0;
   bool haveFlex = false, flexingChildren = false;
   gatherFlexChildrenInfo(iterator, relayoutChildren, highestFlexGroup,
                          lowestFlexGroup, haveFlex);
 
-  // We confine the line clamp ugliness to vertical flexible boxes (thus keeping it out of
+  // We confine the line clamp ugliness to vertical flexible boxes (thus keeping
+  // it out of
   // mainstream block layout); this is not really part of the XUL box model.
   bool haveLineClamp = !style()->lineClamp().isNone();
   if (haveLineClamp)
     applyLineClamp(iterator, relayoutChildren);
 
   PaintLayerScrollableArea::DelayScrollPositionClampScope delayClampScope;
 
   // We do 2 passes.  The first pass is simply to lay everyone out at
   // their preferred widths.  The second pass handles flexing the children.
   // Our first pass is done without flexing.  We simply lay the children
@@ skipping 78 matching lines @@
 
     if (!iterator.first() && hasLineIfEmpty())
       setHeight(size().height() + lineHeight(true,
                                              style()->isHorizontalWritingMode()
                                                  ? HorizontalLine
                                                  : VerticalLine,
                                              PositionOfInteriorLineBoxes));
 
     setHeight(size().height() + toAdd);
 
-    // Negative margins can cause our height to shrink below our minimal height (border/padding).
-    // If this happens, ensure that the computed height is increased to the minimal height.
+    // Negative margins can cause our height to shrink below our minimal height
+    // (border/padding).  If this happens, ensure that the computed height is
+    // increased to the minimal height.
     if (size().height() < minHeight)
       setHeight(minHeight);
 
-    // Now we have to calc our height, so we know how much space we have remaining.
+    // Now we have to calc our height, so we know how much space we have
+    // remaining.
     oldHeight = size().height();
     updateLogicalHeight();
     if (oldHeight != size().height())
       heightSpecified = true;
 
     remainingSpace = size().height() - borderBottom() - paddingBottom() -
                      horizontalScrollbarHeight() - yPos;
 
     if (flexingChildren) {
       haveFlex = false;  // We're done.
     } else if (haveFlex) {
-      // We have some flexible objects.  See if we need to grow/shrink them at all.
+      // We have some flexible objects.  See if we need to grow/shrink them at
+      // all.
       if (!remainingSpace)
         break;
 
-      // Allocate the remaining space among the flexible objects.  If we are trying to
-      // grow, then we go from the lowest flex group to the highest flex group.  For shrinking,
-      // we go from the highest flex group to the lowest group.
+      // Allocate the remaining space among the flexible objects.  If we are
+      // trying to grow, then we go from the lowest flex group to the highest
+      // flex group.  For shrinking, we go from the highest flex group to the
+      // lowest group.
       bool expanding = remainingSpace > 0;
       unsigned start = expanding ? lowestFlexGroup : highestFlexGroup;
       unsigned end = expanding ? highestFlexGroup : lowestFlexGroup;
       for (unsigned i = start; i <= end && remainingSpace; i++) {
-        // Always start off by assuming the group can get all the remaining space.
+        // Always start off by assuming the group can get all the remaining
+        // space.
         LayoutUnit groupRemainingSpace = remainingSpace;
         do {
-          // Flexing consists of multiple passes, since we have to change ratios every time an object hits its max/min-width
-          // For a given pass, we always start off by computing the totalFlex of all objects that can grow/shrink at all, and
-          // computing the allowed growth before an object hits its min/max width (and thus
-          // forces a totalFlex recomputation).
+          // Flexing consists of multiple passes, since we have to change
+          // ratios every time an object hits its max/min-width For a given
+          // pass, we always start off by computing the totalFlex of all
+          // objects that can grow/shrink at all, and computing the allowed
+          // growth before an object hits its min/max width (and thus forces a
+          // totalFlex recomputation).
           LayoutUnit groupRemainingSpaceAtBeginning = groupRemainingSpace;
           float totalFlex = 0.0f;
           for (LayoutBox* child = iterator.first(); child;
                child = iterator.next()) {
             if (allowedChildFlex(child, expanding, i))
               totalFlex += child->style()->boxFlex();
           }
           LayoutUnit spaceAvailableThisPass = groupRemainingSpace;
           for (LayoutBox* child = iterator.first(); child;
                child = iterator.next()) {
             LayoutUnit allowedFlex = allowedChildFlex(child, expanding, i);
             if (allowedFlex) {
               LayoutUnit projectedFlex =
                   (allowedFlex == LayoutUnit::max())
                       ? allowedFlex
                       : static_cast<LayoutUnit>(
                             allowedFlex *
                             (totalFlex / child->style()->boxFlex()));
               spaceAvailableThisPass =
                   expanding ? std::min(spaceAvailableThisPass, projectedFlex)
                             : std::max(spaceAvailableThisPass, projectedFlex);
             }
           }
 
           // The flex groups may not have any flexible objects this time around.
           if (!spaceAvailableThisPass || totalFlex == 0.0f) {
-            // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
+            // If we just couldn't grow/shrink any more, then it's time to
+            // transition to the next flex group.
             groupRemainingSpace = LayoutUnit();
             continue;
           }
 
           // Now distribute the space to objects.
           for (LayoutBox* child = iterator.first();
                child && spaceAvailableThisPass && totalFlex;
                child = iterator.next()) {
             if (allowedChildFlex(child, expanding, i)) {
               LayoutUnit spaceAdd = static_cast<LayoutUnit>(
                   spaceAvailableThisPass *
                   (child->style()->boxFlex() / totalFlex));
               if (spaceAdd) {
                 child->setOverrideLogicalContentHeight(
                     contentHeightForChild(child) + spaceAdd);
                 flexingChildren = true;
                 relayoutChildren = true;
               }
 
               spaceAvailableThisPass -= spaceAdd;
               remainingSpace -= spaceAdd;
               groupRemainingSpace -= spaceAdd;
 
               totalFlex -= child->style()->boxFlex();
             }
           }
           if (groupRemainingSpace == groupRemainingSpaceAtBeginning) {
-            // This is not advancing, avoid getting stuck by distributing the remaining pixels.
+            // This is not advancing, avoid getting stuck by distributing the
+            // remaining pixels.
             LayoutUnit spaceAdd = LayoutUnit(groupRemainingSpace > 0 ? 1 : -1);
             for (LayoutBox* child = iterator.first();
                  child && groupRemainingSpace; child = iterator.next()) {
               if (allowedChildFlex(child, expanding, i)) {
                 child->setOverrideLogicalContentHeight(
                     contentHeightForChild(child) + spaceAdd);
                 flexingChildren = true;
                 relayoutChildren = true;
                 remainingSpace -= spaceAdd;
                 groupRemainingSpace -= spaceAdd;
@@ skipping 52 matching lines @@
         offset += remainingSpace;
       for (LayoutBox* child = iterator.first(); child;
            child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
           continue;
         placeChild(child, child->location() + LayoutSize(LayoutUnit(), offset));
       }
     }
   }
 
-  // So that the computeLogicalHeight in layoutBlock() knows to relayout positioned objects because of
-  // a height change, we revert our height back to the intrinsic height before returning.
+  // So that the computeLogicalHeight in layoutBlock() knows to relayout
+  // positioned objects because of a height change, we revert our height back
+  // to the intrinsic height before returning.
   if (heightSpecified)
     setHeight(oldHeight);
 }
 
 void LayoutDeprecatedFlexibleBox::applyLineClamp(FlexBoxIterator& iterator,
                                                  bool relayoutChildren) {
   UseCounter::count(document(), UseCounter::LineClamp);
 
   int maxLineCount = 0;
   for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
@@ skipping 12 matching lines @@
         toLayoutBlockFlow(child)->markPositionedObjectsForLayout();
         clearTruncation(toLayoutBlockFlow(child));
       }
     }
     child->layoutIfNeeded();
     if (child->style()->height().isAuto() && child->isLayoutBlockFlow())
       maxLineCount =
           std::max(maxLineCount, lineCount(toLayoutBlockFlow(child)));
   }
 
-  // Get the number of lines and then alter all block flow children with auto height to use the
+  // Get the number of lines and then alter all block flow children with auto
+  // height to use the
   // specified height. We always try to leave room for at least one line.
   LineClampValue lineClamp = style()->lineClamp();
   int numVisibleLines =
       lineClamp.isPercentage()
           ? std::max(1, (maxLineCount + 1) * lineClamp.value() / 100)
           : lineClamp.value();
   if (numVisibleLines >= maxLineCount)
     return;
 
   for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
@@ skipping 34 matching lines @@
                         (&horizontalEllipsisCharacter, 1));
     const Font& font = style(numVisibleLines == 1)->font();
     float totalWidth =
         font.width(constructTextRun(font, &horizontalEllipsisCharacter, 1,
                                     styleRef(), style()->direction()));
 
     // See if this width can be accommodated on the last visible line
     LineLayoutBlockFlow destBlock = lastVisibleLine->block();
     LineLayoutBlockFlow srcBlock = lastLine->block();
 
-    // FIXME: Directions of src/destBlock could be different from our direction and from one another.
+    // FIXME: Directions of src/destBlock could be different from our direction
+    // and from one another.
     if (!srcBlock.style()->isLeftToRightDirection())
       continue;
 
     bool leftToRight = destBlock.style()->isLeftToRightDirection();
     if (!leftToRight)
       continue;
 
     LayoutUnit blockRightEdge = destBlock.logicalRightOffsetForLine(
         lastVisibleLine->y(), DoNotIndentText);
     if (!lastVisibleLine->lineCanAccommodateEllipsis(
             leftToRight, blockRightEdge.toInt(),
             (lastVisibleLine->x() + lastVisibleLine->logicalWidth()).toInt(),
             totalWidth))
       continue;
 
     // Let the truncation code kick in.
-    // FIXME: the text alignment should be recomputed after the width changes due to truncation.
+    // FIXME: the text alignment should be recomputed after the width changes
+    // due to truncation.
     LayoutUnit blockLeftEdge = destBlock.logicalLeftOffsetForLine(
         lastVisibleLine->y(), DoNotIndentText);
     lastVisibleLine->placeEllipsis(ellipsisStr, leftToRight, blockLeftEdge,
                                    blockRightEdge, LayoutUnit(totalWidth));
     destBlock.setHasMarkupTruncation(true);
   }
 }
 
 void LayoutDeprecatedFlexibleBox::clearLineClamp() {
   FlexBoxIterator iterator(this);
@@ skipping 11 matching lines @@
       if (child->isLayoutBlockFlow()) {
         toLayoutBlockFlow(child)->markPositionedObjectsForLayout();
         clearTruncation(toLayoutBlockFlow(child));
       }
     }
   }
 }
 
 void LayoutDeprecatedFlexibleBox::placeChild(LayoutBox* child,
                                              const LayoutPoint& location) {
-  // FIXME Investigate if this can be removed based on other flags. crbug.com/370010
+  // FIXME Investigate if this can be removed based on other flags.
+  // crbug.com/370010
   child->setMayNeedPaintInvalidation();
 
   // Place the child.
   child->setLocation(location);
 }
 
 LayoutUnit LayoutDeprecatedFlexibleBox::allowedChildFlex(LayoutBox* child,
                                                          bool expanding,
                                                          unsigned group) {
   if (childDoesNotAffectWidthOrFlexing(child) ||
@@ skipping 38 matching lines @@
   if (minHeight.isFixed() || minHeight.isAuto()) {
     LayoutUnit minHeight(child->style()->minHeight().value());
     LayoutUnit height = contentHeightForChild(child);
     LayoutUnit allowedShrinkage = (minHeight - height).clampPositiveToZero();
     return allowedShrinkage;
   }
   return LayoutUnit();
 }
 
 }  // namespace blink