Reformat comments in core/layout up until LayoutTableRow

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

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc.
+ *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * 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 63 matching lines @@
   // In the collapsed border model, there is no cell spacing.
   m_hSpacing = collapseBorders() ? 0 : style()->horizontalBorderSpacing();
   m_vSpacing = collapseBorders() ? 0 : style()->verticalBorderSpacing();
   m_effectiveColumnPositions[0] = m_hSpacing;
 
   if (!m_tableLayout || style()->isFixedTableLayout() != oldFixedTableLayout) {
     if (m_tableLayout)
       m_tableLayout->willChangeTableLayout();
 
     // According to the CSS2 spec, you only use fixed table layout if an
-    // explicit width is specified on the table.  Auto width implies auto table layout.
+    // explicit width is specified on the table. Auto width implies auto table
+    // layout.
     if (style()->isFixedTableLayout())
       m_tableLayout = wrapUnique(new TableLayoutAlgorithmFixed(this));
     else
       m_tableLayout = wrapUnique(new TableLayoutAlgorithmAuto(this));
   }
 
   // If border was changed, invalidate collapsed borders cache.
   if (!needsLayout() && oldStyle && oldStyle->border() != style()->border())
     invalidateCollapsedBorders();
   if (LayoutTableBoxComponent::doCellsHaveDirtyWidth(*this, *this, diff,
@@ skipping 169 matching lines @@
   LayoutUnit containerWidthInInlineDirection =
       hasPerpendicularContainingBlock
           ? perpendicularContainingBlockLogicalHeight()
           : availableLogicalWidth;
 
   Length styleLogicalWidth = style()->logicalWidth();
   if (!isLogicalWidthAuto()) {
     setLogicalWidth(convertStyleLogicalWidthToComputedWidth(
         styleLogicalWidth, containerWidthInInlineDirection));
   } else {
-    // Subtract out any fixed margins from our available width for auto width tables.
+    // Subtract out any fixed margins from our available width for auto width
+    // tables.
     LayoutUnit marginStart =
         minimumValueForLength(style()->marginStart(), availableLogicalWidth);
     LayoutUnit marginEnd =
         minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
     LayoutUnit marginTotal = marginStart + marginEnd;
 
     // Subtract out our margins to get the available content width.
     LayoutUnit availableContentLogicalWidth =
         (containerWidthInInlineDirection - marginTotal).clampNegativeToZero();
     if (shrinkToAvoidFloats() && cb->isLayoutBlockFlow() &&
         toLayoutBlockFlow(cb)->containsFloats() &&
         !hasPerpendicularContainingBlock)
       availableContentLogicalWidth = shrinkLogicalWidthToAvoidFloats(
           marginStart, marginEnd, toLayoutBlockFlow(cb));
 
     // Ensure we aren't bigger than our available width.
     LayoutUnit maxWidth = maxPreferredLogicalWidth();
-    // scaledWidthFromPercentColumns depends on m_layoutStruct in TableLayoutAlgorithmAuto, which
-    // maxPreferredLogicalWidth fills in. So scaledWidthFromPercentColumns has to be called after
+    // scaledWidthFromPercentColumns depends on m_layoutStruct in
+    // TableLayoutAlgorithmAuto, which maxPreferredLogicalWidth fills in. So
+    // scaledWidthFromPercentColumns has to be called after
     // maxPreferredLogicalWidth.
     LayoutUnit scaledWidth = m_tableLayout->scaledWidthFromPercentColumns() +
                              bordersPaddingAndSpacingInRowDirection();
     maxWidth = std::max(scaledWidth, maxWidth);
     setLogicalWidth(
         LayoutUnit(std::min(availableContentLogicalWidth, maxWidth).floor()));
   }
 
   // Ensure we aren't bigger than our max-width style.
   Length styleMaxLogicalWidth = style()->logicalMaxWidth();
   if ((styleMaxLogicalWidth.isSpecified() &&
        !styleMaxLogicalWidth.isNegative()) ||
       styleMaxLogicalWidth.isIntrinsic()) {
     LayoutUnit computedMaxLogicalWidth =
         convertStyleLogicalWidthToComputedWidth(styleMaxLogicalWidth,
                                                 availableLogicalWidth);
     setLogicalWidth(
         LayoutUnit(std::min(logicalWidth(), computedMaxLogicalWidth).floor()));
   }
 
-  // Ensure we aren't smaller than our min preferred width. This MUST be done after 'max-width' as
-  // we ignore it if it means we wouldn't accommodate our content.
+  // Ensure we aren't smaller than our min preferred width. This MUST be done
+  // after 'max-width' as we ignore it if it means we wouldn't accommodate our
+  // content.
   setLogicalWidth(
       LayoutUnit(std::max(logicalWidth(), minPreferredLogicalWidth()).floor()));
 
   // Ensure we aren't smaller than our min-width style.
   Length styleMinLogicalWidth = style()->logicalMinWidth();
   if ((styleMinLogicalWidth.isSpecified() &&
        !styleMinLogicalWidth.isNegative()) ||
       styleMinLogicalWidth.isIntrinsic()) {
     LayoutUnit computedMinLogicalWidth =
         convertStyleLogicalWidthToComputedWidth(styleMinLogicalWidth,
                                                 availableLogicalWidth);
     setLogicalWidth(
         LayoutUnit(std::max(logicalWidth(), computedMinLogicalWidth).floor()));
   }
 
   // Finally, with our true width determined, compute our margins for real.
   ComputedMarginValues marginValues;
   computeMarginsForDirection(InlineDirection, cb, availableLogicalWidth,
                              logicalWidth(), marginValues.m_start,
                              marginValues.m_end, style()->marginStart(),
                              style()->marginEnd());
   setMarginStart(marginValues.m_start);
   setMarginEnd(marginValues.m_end);
 
-  // We should NEVER shrink the table below the min-content logical width, or else the table can't accommodate
-  // its own content which doesn't match CSS nor what authors expect.
-  // FIXME: When we convert to sub-pixel layout for tables we can remove the int conversion
-  // https://code.google.com/p/chromium/issues/detail?id=241198
+  // We should NEVER shrink the table below the min-content logical width, or
+  // else the table can't accommodate its own content which doesn't match CSS
+  // nor what authors expect.
+  // FIXME: When we convert to sub-pixel layout for tables we can remove the int
+  // conversion. http://crbug.com/241198
   ASSERT(logicalWidth().floor() >= minPreferredLogicalWidth().floor());
 }
 
-// This method takes a ComputedStyle's logical width, min-width, or max-width length and computes its actual value.
+// This method takes a ComputedStyle's logical width, min-width, or max-width
+// length and computes its actual value.
 LayoutUnit LayoutTable::convertStyleLogicalWidthToComputedWidth(
     const Length& styleLogicalWidth,
     LayoutUnit availableWidth) {
   if (styleLogicalWidth.isIntrinsic())
     return computeIntrinsicLogicalWidthUsing(
         styleLogicalWidth, availableWidth,
         bordersPaddingAndSpacingInRowDirection());
 
-  // HTML tables' width styles already include borders and paddings, but CSS tables' width styles do not.
+  // HTML tables' width styles already include borders and paddings, but CSS
+  // tables' width styles do not.
   LayoutUnit borders;
   bool isCSSTable = !isHTMLTableElement(node());
   if (isCSSTable && styleLogicalWidth.isSpecified() &&
       styleLogicalWidth.isPositive() &&
       style()->boxSizing() == BoxSizingContentBox)
     borders =
         borderStart() + borderEnd() +
         (collapseBorders() ? LayoutUnit() : paddingStart() + paddingEnd());
 
   return minimumValueForLength(styleLogicalWidth, availableWidth) + borders;
 }
 
 LayoutUnit LayoutTable::convertStyleLogicalHeightToComputedHeight(
     const Length& styleLogicalHeight) {
   LayoutUnit borderAndPaddingBefore =
       borderBefore() + (collapseBorders() ? LayoutUnit() : paddingBefore());
   LayoutUnit borderAndPaddingAfter =
       borderAfter() + (collapseBorders() ? LayoutUnit() : paddingAfter());
   LayoutUnit borderAndPadding = borderAndPaddingBefore + borderAndPaddingAfter;
   LayoutUnit computedLogicalHeight;
   if (styleLogicalHeight.isFixed()) {
-    // HTML tables size as though CSS height includes border/padding, CSS tables do not.
+    // HTML tables size as though CSS height includes border/padding, CSS tables
+    // do not.
     LayoutUnit borders = LayoutUnit();
-    // FIXME: We cannot apply box-sizing: content-box on <table> which other browsers allow.
+    // FIXME: We cannot apply box-sizing: content-box on <table> which other
+    // browsers allow.
     if (isHTMLTableElement(node()) ||
         style()->boxSizing() == BoxSizingBorderBox) {
       borders = borderAndPadding;
     }
     computedLogicalHeight = LayoutUnit(styleLogicalHeight.value() - borders);
   } else if (styleLogicalHeight.isPercentOrCalc()) {
     computedLogicalHeight = computePercentageLogicalHeight(styleLogicalHeight);
   } else if (styleLogicalHeight.isIntrinsic()) {
     computedLogicalHeight = computeIntrinsicLogicalContentHeightUsing(
         styleLogicalHeight, logicalHeight() - borderAndPadding,
         borderAndPadding);
   } else {
     ASSERT_NOT_REACHED();
   }
   return computedLogicalHeight.clampNegativeToZero();
 }
 
 void LayoutTable::layoutCaption(LayoutTableCaption& caption) {
   if (caption.needsLayout()) {
-    // The margins may not be available but ensure the caption is at least located beneath any previous sibling caption
-    // so that it does not mistakenly think any floats in the previous caption intrude into it.
+    // The margins may not be available but ensure the caption is at least
+    // located beneath any previous sibling caption so that it does not
+    // mistakenly think any floats in the previous caption intrude into it.
     caption.setLogicalLocation(
         LayoutPoint(caption.marginStart(),
                     collapsedMarginBeforeForChild(caption) + logicalHeight()));
     // If LayoutTableCaption ever gets a layout() function, use it here.
     caption.layoutIfNeeded();
   }
-  // Apply the margins to the location now that they are definitely available from layout
+  // Apply the margins to the location now that they are definitely available
+  // from layout
   LayoutUnit captionLogicalTop =
       collapsedMarginBeforeForChild(caption) + logicalHeight();
   caption.setLogicalLocation(
       LayoutPoint(caption.marginStart(), captionLogicalTop));
 
   if (!selfNeedsLayout())
     caption.setMayNeedPaintInvalidation();
 
   setLogicalHeight(logicalHeight() + caption.logicalHeight() +
                    collapsedMarginBeforeForChild(caption) +
                    collapsedMarginAfterForChild(caption));
 }
 
 void LayoutTable::distributeExtraLogicalHeight(int extraLogicalHeight) {
   if (extraLogicalHeight <= 0)
     return;
 
-  // FIXME: Distribute the extra logical height between all table sections instead of giving it all to the first one.
+  // FIXME: Distribute the extra logical height between all table sections
+  // instead of giving it all to the first one.
   if (LayoutTableSection* section = firstBody())
     extraLogicalHeight -=
         section->distributeExtraLogicalHeightToRows(extraLogicalHeight);
 
-  // FIXME: We really would like to enable this ASSERT to ensure that all the extra space has been distributed.
-  // However our current distribution algorithm does not round properly and thus we can have some remaining height.
+  // FIXME: We really would like to enable this ASSERT to ensure that all the
+  // extra space has been distributed.
+  // However our current distribution algorithm does not round properly and thus
+  // we can have some remaining height.
   // ASSERT(!topSection() || !extraLogicalHeight);
 }
 
 void LayoutTable::simplifiedNormalFlowLayout() {
-  // FIXME: We should walk through the items in the tree in tree order to do the layout here
-  // instead of walking through individual parts of the tree. crbug.com/442737
+  // FIXME: We should walk through the items in the tree in tree order to do the
+  // layout here instead of walking through individual parts of the tree.
+  // crbug.com/442737
   for (auto& caption : m_captions)
     caption->layoutIfNeeded();
 
   for (LayoutTableSection* section = topSection(); section;
        section = sectionBelow(section)) {
     section->layoutIfNeeded();
     section->layoutRows();
     section->computeOverflowFromCells();
     section->updateLayerTransformAfterLayout();
     section->addVisualEffectOverflow();
   }
 }
 
 bool LayoutTable::recalcChildOverflowAfterStyleChange() {
   ASSERT(childNeedsOverflowRecalcAfterStyleChange());
   clearChildNeedsOverflowRecalcAfterStyleChange();
 
-  // If the table sections we keep pointers to have gone away then the table will be rebuilt and
-  // overflow will get recalculated anyway so return early.
+  // If the table sections we keep pointers to have gone away then the table
+  // will be rebuilt and overflow will get recalculated anyway so return early.
   if (needsSectionRecalc())
     return false;
 
   bool childrenOverflowChanged = false;
   for (LayoutTableSection* section = topSection(); section;
        section = sectionBelow(section)) {
     if (!section->childNeedsOverflowRecalcAfterStyleChange())
       continue;
     childrenOverflowChanged = section->recalcChildOverflowAfterStyleChange() ||
                               childrenOverflowChanged;
   }
   return recalcPositionedDescendantsOverflowAfterStyleChange() ||
          childrenOverflowChanged;
 }
 
 void LayoutTable::layout() {
   ASSERT(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
 
   if (simplifiedLayout())
     return;
 
-  // Note: LayoutTable is handled differently than other LayoutBlocks and the LayoutScope
+  // Note: LayoutTable is handled differently than other LayoutBlocks and the
+  // LayoutScope
   //       must be created before the table begins laying out.
   TextAutosizer::LayoutScope textAutosizerLayoutScope(this);
 
   recalcSectionsIfNeeded();
-  // FIXME: We should do this recalc lazily in borderStart/borderEnd so that we don't have to make sure
-  // to call this before we call borderStart/borderEnd to avoid getting a stale value.
+  // FIXME: We should do this recalc lazily in borderStart/borderEnd so that we
+  // don't have to make sure to call this before we call borderStart/borderEnd
+  // to avoid getting a stale value.
   recalcBordersInRowDirection();
 
   SubtreeLayoutScope layouter(*this);
 
-  // If any table section moved vertically, we will just issue paint invalidations for everything from that
-  // section down (it is quite unlikely that any of the following sections
-  // did not shift).
+  // If any table section moved vertically, we will just issue paint
+  // invalidations for everything from that section down (it is quite unlikely
+  // that any of the following sections did not shift).
   bool sectionMoved = false;
   {
     LayoutState state(*this, locationOffset());
     LayoutUnit oldLogicalWidth = logicalWidth();
     LayoutUnit oldLogicalHeight = logicalHeight();
 
     setLogicalHeight(LayoutUnit());
     updateLogicalWidth();
 
     if (logicalWidth() != oldLogicalWidth) {
@@ skipping 27 matching lines @@
           layouter.setChildNeedsLayout(section);
         section->layoutIfNeeded();
         totalSectionLogicalHeight += section->calcRowLogicalHeight();
         if (collapsing)
           section->recalcOuterBorder();
         ASSERT(!section->needsLayout());
       } else if (child->isLayoutTableCol()) {
         child->layoutIfNeeded();
         ASSERT(!child->needsLayout());
       } else {
-        // FIXME: We should never have other type of children (they should be wrapped in an
-        // anonymous table section) but our code is too crazy and this can happen in practice.
-        // Until this is fixed, let's make sure we don't leave non laid out children in the tree.
+        // FIXME: We should never have other type of children (they should be
+        // wrapped in an anonymous table section) but our code is too crazy and
+        // this can happen in practice. Until this is fixed, let's make sure we
+        // don't leave non laid out children in the tree.
         child->layoutIfNeeded();
       }
     }
 
     // FIXME: Collapse caption margin.
     if (!m_captions.isEmpty()) {
       for (unsigned i = 0; i < m_captions.size(); i++) {
         if (m_captions[i]->style()->captionSide() == ECaptionSide::Bottom)
           continue;
         layoutCaption(*m_captions[i]);
@@ skipping 41 matching lines @@
 
     bool isPaginated = view()->layoutState()->isPaginated();
     LayoutTableSection* topSection = this->topSection();
     LayoutUnit logicalOffset =
         topSection ? topSection->logicalTop() : LayoutUnit();
     for (LayoutTableSection* section = topSection; section;
          section = sectionBelow(section)) {
       section->setLogicalTop(logicalOffset);
       section->layoutRows();
       logicalOffset += section->logicalHeight();
-      // If the section is a repeating header group that allows at least one row of content then store the
-      // offset for other sections to offset their rows against.
+      // If the section is a repeating header group that allows at least one row
+      // of content then store the offset for other sections to offset their
+      // rows against.
       if (isPaginated && m_head && m_head == section &&
           section->logicalHeight() <
               section->pageLogicalHeightForOffset(logicalOffset) &&
           section->getPaginationBreakability() != LayoutBox::AllowAnyBreaks) {
         LayoutUnit offsetForTableHeaders = state.heightOffsetForTableHeaders();
-        // Don't include any strut in the header group - we only want the height from its content.
+        // Don't include any strut in the header group - we only want the height
+        // from its content.
         offsetForTableHeaders += section->logicalHeight();
         if (LayoutTableRow* row = section->firstRow())
           offsetForTableHeaders -= row->paginationStrut();
         state.setHeightOffsetForTableHeaders(offsetForTableHeaders);
       }
     }
 
     if (!topSection && computedLogicalHeight > totalSectionLogicalHeight &&
         !document().inQuirksMode()) {
-      // Completely empty tables (with no sections or anything) should at least honor specified height
-      // in strict mode.
+      // Completely empty tables (with no sections or anything) should at least
+      // honor specified height in strict mode.
       setLogicalHeight(logicalHeight() + computedLogicalHeight);
     }
 
     LayoutUnit sectionLogicalLeft = LayoutUnit(
         style()->isLeftToRightDirection() ? borderStart() : borderEnd());
     if (!collapsing)
       sectionLogicalLeft +=
           style()->isLeftToRightDirection() ? paddingStart() : paddingEnd();
 
     // position the table sections
     LayoutTableSection* section = topSection;
     while (section) {
       if (!sectionMoved && section->logicalTop() != logicalHeight())
         sectionMoved = true;
       section->setLogicalLocation(
           LayoutPoint(sectionLogicalLeft, logicalHeight()));
 
-      // As we may skip invalidation on the table, we need to ensure that sections are invalidated when they moved.
+      // As we may skip invalidation on the table, we need to ensure that
+      // sections are invalidated when they moved.
       if (sectionMoved && !section->selfNeedsLayout())
         section->setMayNeedPaintInvalidation();
 
       setLogicalHeight(logicalHeight() + section->logicalHeight());
 
       section->updateLayerTransformAfterLayout();
       section->addVisualEffectOverflow();
 
       section = sectionBelow(section);
     }
@@ skipping 37 matching lines @@
 void LayoutTable::invalidateCollapsedBorders() {
   m_collapsedBorders.clear();
   if (!collapseBorders())
     return;
 
   m_collapsedBordersValid = false;
   setMayNeedPaintInvalidation();
 }
 
 // Collect all the unique border values that we want to paint in a sorted list.
-// During the collection, each cell saves its recalculated borders into the cache
-// of its containing section, and invalidates itself if any border changes.
-// This method doesn't affect layout.
+// During the collection, each cell saves its recalculated borders into the
+// cache of its containing section, and invalidates itself if any border
+// changes. This method doesn't affect layout.
 void LayoutTable::recalcCollapsedBordersIfNeeded() {
   if (m_collapsedBordersValid || !collapseBorders())
     return;
   m_collapsedBordersValid = true;
   m_collapsedBorders.clear();
   for (LayoutObject* section = firstChild(); section;
        section = section->nextSibling()) {
     if (!section->isTableSection())
       continue;
     for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row;
          row = row->nextRow()) {
       for (LayoutTableCell* cell = row->firstCell(); cell;
            cell = cell->nextCell()) {
         ASSERT(cell->table() == this);
         cell->collectBorderValues(m_collapsedBorders);
       }
     }
   }
   LayoutTableCell::sortBorderValues(m_collapsedBorders);
 }
 
 void LayoutTable::addOverflowFromChildren() {
   // Add overflow from borders.
-  // Technically it's odd that we are incorporating the borders into layout overflow, which is only supposed to be about overflow from our
-  // descendant objects, but since tables don't support overflow:auto, this works out fine.
+  // Technically it's odd that we are incorporating the borders into layout
+  // overflow, which is only supposed to be about overflow from our
+  // descendant objects, but since tables don't support overflow:auto, this
+  // works out fine.
   if (collapseBorders()) {
     int rightBorderOverflow =
         (size().width() + outerBorderRight() - borderRight()).toInt();
     int leftBorderOverflow = borderLeft() - outerBorderLeft();
     int bottomBorderOverflow =
         (size().height() + outerBorderBottom() - borderBottom()).toInt();
     int topBorderOverflow = borderTop() - outerBorderTop();
     IntRect borderOverflowRect(leftBorderOverflow, topBorderOverflow,
                                rightBorderOverflow - leftBorderOverflow,
                                bottomBorderOverflow - topBorderOverflow);
@@ skipping 57 matching lines @@
 }
 
 void LayoutTable::paintMask(const PaintInfo& paintInfo,
                             const LayoutPoint& paintOffset) const {
   TablePainter(*this).paintMask(paintInfo, paintOffset);
 }
 
 void LayoutTable::computeIntrinsicLogicalWidths(LayoutUnit& minWidth,
                                                 LayoutUnit& maxWidth) const {
   recalcSectionsIfNeeded();
-  // FIXME: Do the recalc in borderStart/borderEnd and make those const_cast this call.
-  // Then m_borderStart/m_borderEnd will be transparent a cache and it removes the possibility
-  // of reading out stale values.
+  // FIXME: Do the recalc in borderStart/borderEnd and make those const_cast
+  // this call.
+  // Then m_borderStart/m_borderEnd will be transparent a cache and it removes
+  // the possibility of reading out stale values.
   const_cast<LayoutTable*>(this)->recalcBordersInRowDirection();
-  // FIXME: Restructure the table layout code so that we can make this method const.
+  // FIXME: Restructure the table layout code so that we can make this method
+  // const.
   const_cast<LayoutTable*>(this)->m_tableLayout->computeIntrinsicLogicalWidths(
       minWidth, maxWidth);
 
-  // FIXME: We should include captions widths here like we do in computePreferredLogicalWidths.
+  // FIXME: We should include captions widths here like we do in
+  // computePreferredLogicalWidths.
 }
 
 void LayoutTable::computePreferredLogicalWidths() {
   ASSERT(preferredLogicalWidthsDirty());
 
   computeIntrinsicLogicalWidths(m_minPreferredLogicalWidth,
                                 m_maxPreferredLogicalWidth);
 
   int bordersPaddingAndSpacing =
       bordersPaddingAndSpacingInRowDirection().toInt();
   m_minPreferredLogicalWidth += bordersPaddingAndSpacing;
   m_maxPreferredLogicalWidth += bordersPaddingAndSpacing;
 
   m_tableLayout->applyPreferredLogicalWidthQuirks(m_minPreferredLogicalWidth,
                                                   m_maxPreferredLogicalWidth);
 
   for (unsigned i = 0; i < m_captions.size(); i++)
     m_minPreferredLogicalWidth = std::max(
         m_minPreferredLogicalWidth, m_captions[i]->minPreferredLogicalWidth());
 
   const ComputedStyle& styleToUse = styleRef();
-  // FIXME: This should probably be checking for isSpecified since you should be able to use percentage or calc values for min-width.
+  // FIXME: This should probably be checking for isSpecified since you should be
+  // able to use percentage or calc values for min-width.
   if (styleToUse.logicalMinWidth().isFixed() &&
       styleToUse.logicalMinWidth().value() > 0) {
     m_maxPreferredLogicalWidth = std::max(
         m_maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(
                                         styleToUse.logicalMinWidth().value()));
     m_minPreferredLogicalWidth = std::max(
         m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(
                                         styleToUse.logicalMinWidth().value()));
   }
 
-  // FIXME: This should probably be checking for isSpecified since you should be able to use percentage or calc values for maxWidth.
+  // FIXME: This should probably be checking for isSpecified since you should be
+  // able to use percentage or calc values for maxWidth.
   if (styleToUse.logicalMaxWidth().isFixed()) {
-    // We don't constrain m_minPreferredLogicalWidth as the table should be at least the size of its min-content, regardless of 'max-width'.
+    // We don't constrain m_minPreferredLogicalWidth as the table should be at
+    // least the size of its min-content, regardless of 'max-width'.
     m_maxPreferredLogicalWidth = std::min(
         m_maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(
                                         styleToUse.logicalMaxWidth().value()));
     m_maxPreferredLogicalWidth =
         std::max(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
   }
 
-  // FIXME: We should be adding borderAndPaddingLogicalWidth here, but m_tableLayout->computePreferredLogicalWidths already does,
-  // so a bunch of tests break doing this naively.
+  // FIXME: We should be adding borderAndPaddingLogicalWidth here, but
+  // m_tableLayout->computePreferredLogicalWidths already does, so a bunch of
+  // tests break doing this naively.
   clearPreferredLogicalWidthsDirty();
 }
 
 LayoutTableSection* LayoutTable::topNonEmptySection() const {
   LayoutTableSection* section = topSection();
   if (section && !section->numRows())
     section = sectionBelow(section, SkipEmptySections);
   return section;
 }
 
 void LayoutTable::splitEffectiveColumn(unsigned index, unsigned firstSpan) {
   // We split the column at |index|, taking |firstSpan| cells from the span.
   ASSERT(m_effectiveColumns[index].span > firstSpan);
   m_effectiveColumns.insert(index, firstSpan);
   m_effectiveColumns[index + 1].span -= firstSpan;
 
-  // Propagate the change in our columns representation to the sections that don't need
-  // cell recalc. If they do, they will be synced up directly with m_columns later.
+  // Propagate the change in our columns representation to the sections that
+  // don't need cell recalc. If they do, they will be synced up directly with
+  // m_columns later.
   for (LayoutObject* child = firstChild(); child;
        child = child->nextSibling()) {
     if (!child->isTableSection())
       continue;
 
     LayoutTableSection* section = toLayoutTableSection(child);
     if (section->needsCellRecalc())
       continue;
 
     section->splitEffectiveColumn(index, firstSpan);
   }
 
   m_effectiveColumnPositions.grow(numEffectiveColumns() + 1);
 }
 
 void LayoutTable::appendEffectiveColumn(unsigned span) {
   unsigned newColumnIndex = m_effectiveColumns.size();
   m_effectiveColumns.append(span);
 
-  // Unless the table has cell(s) with colspan that exceed the number of columns afforded
-  // by the other rows in the table we can use the fast path when mapping columns to effective columns.
+  // Unless the table has cell(s) with colspan that exceed the number of columns
+  // afforded by the other rows in the table we can use the fast path when
+  // mapping columns to effective columns.
   if (span == 1 && m_noCellColspanAtLeast + 1 == numEffectiveColumns()) {
     m_noCellColspanAtLeast++;
   }
 
-  // Propagate the change in our columns representation to the sections that don't need
-  // cell recalc. If they do, they will be synced up directly with m_columns later.
+  // Propagate the change in our columns representation to the sections that
+  // don't need cell recalc. If they do, they will be synced up directly with
+  // m_columns later.
   for (LayoutObject* child = firstChild(); child;
        child = child->nextSibling()) {
     if (!child->isTableSection())
       continue;
 
     LayoutTableSection* section = toLayoutTableSection(child);
     if (section->needsCellRecalc())
       continue;
 
     section->appendEffectiveColumn(newColumnIndex);
@@ skipping 110 matching lines @@
           if (!m_firstBody)
             m_firstBody = section;
           section->recalcCellsIfNeeded();
         }
         break;
       default:
         break;
     }
   }
 
-  // repair column count (addChild can grow it too much, because it always adds elements to the last row of a section)
+  // repair column count (addChild can grow it too much, because it always adds
+  // elements to the last row of a section)
   unsigned maxCols = 0;
   for (LayoutObject* child = firstChild(); child;
        child = child->nextSibling()) {
     if (child->isTableSection()) {
       LayoutTableSection* section = toLayoutTableSection(child);
       unsigned sectionCols = section->numEffectiveColumns();
       if (sectionCols > maxCols)
         maxCols = sectionCols;
     }
   }
 
   m_effectiveColumns.resize(maxCols);
   m_effectiveColumnPositions.resize(maxCols + 1);
 
   ASSERT(selfNeedsLayout());
 
   m_needsSectionRecalc = false;
 }
 
 int LayoutTable::calcBorderStart() const {
   if (!collapseBorders())
     return LayoutBlock::borderStart();
 
-  // Determined by the first cell of the first row. See the CSS 2.1 spec, section 17.6.2.
+  // Determined by the first cell of the first row. See the CSS 2.1 spec,
+  // section 17.6.2.
   if (!numEffectiveColumns())
     return 0;
 
   int borderWidth = 0;
 
   const BorderValue& tableStartBorder = style()->borderStart();
   if (tableStartBorder.style() == BorderStyleHidden)
     return 0;
   if (tableStartBorder.style() > BorderStyleHidden)
     borderWidth = tableStartBorder.width();
 
-  // TODO(dgrogan): This logic doesn't properly account for the first column in the first column-group case.
+  // TODO(dgrogan): This logic doesn't properly account for the first column in
+  // the first column-group case.
   if (LayoutTableCol* column =
           colElementAtAbsoluteColumn(0).innermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& columnAdjoiningBorder = column->style()->borderStart();
     if (columnAdjoiningBorder.style() == BorderStyleHidden)
       return 0;
     if (columnAdjoiningBorder.style() > BorderStyleHidden)
       borderWidth = std::max(borderWidth, columnAdjoiningBorder.width());
   }
 
@@ skipping 26 matching lines @@
         borderWidth = std::max(borderWidth, firstRowAdjoiningBorder.width());
     }
   }
   return (borderWidth + (style()->isLeftToRightDirection() ? 0 : 1)) / 2;
 }
 
 int LayoutTable::calcBorderEnd() const {
   if (!collapseBorders())
     return LayoutBlock::borderEnd();
 
-  // Determined by the last cell of the first row. See the CSS 2.1 spec, section 17.6.2.
+  // Determined by the last cell of the first row. See the CSS 2.1 spec, section
+  // 17.6.2.
   if (!numEffectiveColumns())
     return 0;
 
   int borderWidth = 0;
 
   const BorderValue& tableEndBorder = style()->borderEnd();
   if (tableEndBorder.style() == BorderStyleHidden)
     return 0;
   if (tableEndBorder.style() > BorderStyleHidden)
     borderWidth = tableEndBorder.width();
 
   unsigned endColumn = numEffectiveColumns() - 1;
 
-  // TODO(dgrogan): This logic doesn't properly account for the last column in the last column-group case.
+  // TODO(dgrogan): This logic doesn't properly account for the last column in
+  // the last column-group case.
   if (LayoutTableCol* column =
           colElementAtAbsoluteColumn(endColumn).innermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& columnAdjoiningBorder = column->style()->borderEnd();
     if (columnAdjoiningBorder.style() == BorderStyleHidden)
       return 0;
     if (columnAdjoiningBorder.style() > BorderStyleHidden)
       borderWidth = std::max(borderWidth, columnAdjoiningBorder.width());
   }
 
@@ skipping 23 matching lines @@
       if (endCellAdjoiningBorder.style() > BorderStyleHidden)
         borderWidth = std::max(borderWidth, endCellAdjoiningBorder.width());
       if (firstRowAdjoiningBorder.style() > BorderStyleHidden)
         borderWidth = std::max(borderWidth, firstRowAdjoiningBorder.width());
     }
   }
   return (borderWidth + (style()->isLeftToRightDirection() ? 1 : 0)) / 2;
 }
 
 void LayoutTable::recalcBordersInRowDirection() {
-  // FIXME: We need to compute the collapsed before / after borders in the same fashion.
+  // FIXME: We need to compute the collapsed before / after borders in the same
+  // fashion.
   m_borderStart = calcBorderStart();
   m_borderEnd = calcBorderEnd();
 }
 
 int LayoutTable::borderBefore() const {
   if (collapseBorders()) {
     recalcSectionsIfNeeded();
     return outerBorderBefore();
   }
   return LayoutBlock::borderBefore();
@@ skipping 255 matching lines @@
   return LayoutBox::baselinePosition(baselineType, firstLine, direction,
                                      linePositionMode);
 }
 
 int LayoutTable::inlineBlockBaseline(LineDirectionMode) const {
   // Tables are skipped when computing an inline-block's baseline.
   return -1;
 }
 
 int LayoutTable::firstLineBoxBaseline() const {
-  // The baseline of a 'table' is the same as the 'inline-table' baseline per CSS 3 Flexbox (CSS 2.1
-  // doesn't define the baseline of a 'table' only an 'inline-table').
-  // This is also needed to properly determine the baseline of a cell if it has a table child.
+  // The baseline of a 'table' is the same as the 'inline-table' baseline per
+  // CSS 3 Flexbox (CSS 2.1 doesn't define the baseline of a 'table' only an
+  // 'inline-table'). This is also needed to properly determine the baseline of
+  // a cell if it has a table child.
 
   if (isWritingModeRoot())
     return -1;
 
   recalcSectionsIfNeeded();
 
   const LayoutTableSection* topNonEmptySection = this->topNonEmptySection();
   if (!topNonEmptySection)
     return -1;
 
   int baseline = topNonEmptySection->firstLineBoxBaseline();
   if (baseline >= 0)
     return (topNonEmptySection->logicalTop() + baseline).toInt();
 
-  // FF, Presto and IE use the top of the section as the baseline if its first row is empty of cells or content.
+  // FF, Presto and IE use the top of the section as the baseline if its first
+  // row is empty of cells or content.
   // The baseline of an empty row isn't specified by CSS 2.1.
   if (topNonEmptySection->firstRow() &&
       !topNonEmptySection->firstRow()->firstCell())
     return topNonEmptySection->logicalTop().toInt();
 
   return -1;
 }
 
 LayoutRect LayoutTable::overflowClipRect(
     const LayoutPoint& location,
     OverlayScrollbarClipBehavior overlayScrollbarClipBehavior) const {
   LayoutRect rect =
       LayoutBlock::overflowClipRect(location, overlayScrollbarClipBehavior);
 
   // If we have a caption, expand the clip to include the caption.
   // FIXME: Technically this is wrong, but it's virtually impossible to fix this
   // for real until captions have been re-written.
-  // FIXME: This code assumes (like all our other caption code) that only top/bottom are
-  // supported.  When we actually support left/right and stop mapping them to top/bottom,
-  // we might have to hack this code first (depending on what order we do these bug fixes in).
+  // FIXME: This code assumes (like all our other caption code) that only
+  // top/bottom are supported.  When we actually support left/right and stop
+  // mapping them to top/bottom, we might have to hack this code first
+  // (depending on what order we do these bug fixes in).
   if (!m_captions.isEmpty()) {
     if (style()->isHorizontalWritingMode()) {
       rect.setHeight(size().height());
       rect.setY(location.y());
     } else {
       rect.setWidth(size().width());
       rect.setX(location.x());
     }
   }
 
@@ skipping 113 matching lines @@
 }
 
 LayoutUnit LayoutTable::paddingRight() const {
   if (collapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::paddingRight();
 }
 
 }  // namespace blink