reflow comments in core/layout/[M-Z]*.{cpp,h}

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

 /*
  * Copyright (C) 2002 Lars Knoll (knoll@kde.org)
  *           (C) 2002 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple 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
  * version 2 of the License.
  *
@@ skipping 56 matching lines @@
   uses the 'overflow' property to determine whether to clip the
   overflow content.
 */
 
 namespace blink {
 
 TableLayoutAlgorithmFixed::TableLayoutAlgorithmFixed(LayoutTable* table)
     : TableLayoutAlgorithm(table) {}
 
 int TableLayoutAlgorithmFixed::calcWidthArray() {
-  // FIXME: We might want to wait until we have all of the first row before computing for the first time.
+  // FIXME: We might want to wait until we have all of the first row before
+  // computing for the first time.
   int usedWidth = 0;
 
   // iterate over all <col> elements
   unsigned nEffCols = m_table->numEffectiveColumns();
   m_width.resize(nEffCols);
   m_width.fill(Length(Auto));
 
   unsigned currentEffectiveColumn = 0;
   for (LayoutTableCol* col = m_table->firstColumn(); col;
        col = col->nextColumn()) {
-    // LayoutTableCols don't have the concept of preferred logical width, but we need to clear their dirty bits
-    // so that if we call setPreferredWidthsDirty(true) on a col or one of its descendants, we'll mark it's
-    // ancestors as dirty.
+    // LayoutTableCols don't have the concept of preferred logical width, but we
+    // need to clear their dirty bits so that if we call
+    // setPreferredWidthsDirty(true) on a col or one of its descendants, we'll
+    // mark it's ancestors as dirty.
     col->clearPreferredLogicalWidthsDirtyBits();
 
-    // Width specified by column-groups that have column child does not affect column width in fixed layout tables
+    // Width specified by column-groups that have column child does not affect
+    // column width in fixed layout tables
     if (col->isTableColumnGroupWithColumnChildren())
       continue;
 
     Length colStyleLogicalWidth = col->style()->logicalWidth();
     int effectiveColWidth = 0;
     if (colStyleLogicalWidth.isFixed() && colStyleLogicalWidth.value() > 0)
       effectiveColWidth = colStyleLogicalWidth.value();
 
     unsigned span = col->span();
     while (span) {
@@ skipping 30 matching lines @@
   if (!section)
     return usedWidth;
 
   unsigned currentColumn = 0;
 
   LayoutTableRow* firstRow = section->firstRow();
   for (LayoutTableCell* cell = firstRow->firstCell(); cell;
        cell = cell->nextCell()) {
     Length logicalWidth = cell->styleOrColLogicalWidth();
 
-    // FIXME: calc() on tables should be handled consistently with other lengths. See bug: https://crbug.com/382725
+    // FIXME: calc() on tables should be handled consistently with other
+    // lengths. See bug: https://crbug.com/382725
     if (logicalWidth.isCalculated())
       logicalWidth = Length();  // Make it Auto
 
     unsigned span = cell->colSpan();
     int fixedBorderBoxLogicalWidth = 0;
-    // FIXME: Support other length types. If the width is non-auto, it should probably just use
-    // LayoutBox::computeLogicalWidthUsing to compute the width.
+    // FIXME: Support other length types. If the width is non-auto, it should
+    // probably just use LayoutBox::computeLogicalWidthUsing to compute the
+    // width.
     if (logicalWidth.isFixed() && logicalWidth.isPositive()) {
       fixedBorderBoxLogicalWidth =
           cell->adjustBorderBoxLogicalWidthForBoxSizing(logicalWidth.value())
               .toInt();
       logicalWidth.setValue(fixedBorderBoxLogicalWidth);
     }
 
     unsigned usedSpan = 0;
     while (usedSpan < span && currentColumn < nEffCols) {
       float eSpan = m_table->spanOfEffectiveColumn(currentColumn);
       // Only set if no col element has already set it.
       if (m_width[currentColumn].isAuto() && logicalWidth.type() != Auto) {
         m_width[currentColumn] = logicalWidth;
         m_width[currentColumn] *= eSpan / span;
         usedWidth += fixedBorderBoxLogicalWidth * eSpan / span;
       }
       usedSpan += eSpan;
       ++currentColumn;
     }
 
-    // TableLayoutAlgorithmFixed doesn't use min/maxPreferredLogicalWidths, but we need to clear the
-    // dirty bit on the cell so that we'll correctly mark its ancestors dirty
-    // in case we later call setPreferredLogicalWidthsDirty() on it later.
+    // TableLayoutAlgorithmFixed doesn't use min/maxPreferredLogicalWidths, but
+    // we need to clear the dirty bit on the cell so that we'll correctly mark
+    // its ancestors dirty in case we later call
+    // setPreferredLogicalWidthsDirty() on it later.
     if (cell->preferredLogicalWidthsDirty())
       cell->clearPreferredLogicalWidthsDirty();
   }
 
   return usedWidth;
 }
 
 void TableLayoutAlgorithmFixed::computeIntrinsicLogicalWidths(
     LayoutUnit& minWidth,
     LayoutUnit& maxWidth) {
   minWidth = maxWidth = LayoutUnit(calcWidthArray());
 }
 
 void TableLayoutAlgorithmFixed::applyPreferredLogicalWidthQuirks(
     LayoutUnit& minWidth,
     LayoutUnit& maxWidth) const {
   Length tableLogicalWidth = m_table->style()->logicalWidth();
   if (tableLogicalWidth.isFixed() && tableLogicalWidth.isPositive()) {
     minWidth = maxWidth = LayoutUnit(
         max(minWidth,
             LayoutUnit(tableLogicalWidth.value() -
                        m_table->bordersPaddingAndSpacingInRowDirection()))
             .floor());
   }
 
   /*
         <table style="width:100%; background-color:red"><tr><td>
             <table style="background-color:blue"><tr><td>
-                <table style="width:100%; background-color:green; table-layout:fixed"><tr><td>
+                <table style="width:100%; background-color:green;
+                              table-layout:fixed"><tr><td>
                     Content
                 </td></tr></table>
             </td></tr></table>
         </td></tr></table>
     */
-  // In this example, the two inner tables should be as large as the outer table.
-  // We can achieve this effect by making the maxwidth of fixed tables with percentage
-  // widths be infinite.
+  // In this example, the two inner tables should be as large as the outer
+  // table. We can achieve this effect by making the maxwidth of fixed tables
+  // with percentage widths be infinite.
   if (m_table->style()->logicalWidth().isPercentOrCalc() &&
       maxWidth < tableMaxWidth)
     maxWidth = LayoutUnit(tableMaxWidth);
 }
 
 void TableLayoutAlgorithmFixed::layout() {
   int tableLogicalWidth = (m_table->logicalWidth() -
                            m_table->bordersPaddingAndSpacingInRowDirection())
                               .toInt();
   unsigned nEffCols = m_table->numEffectiveColumns();
 
-  // FIXME: It is possible to be called without having properly updated our internal representation.
-  // This means that our preferred logical widths were not recomputed as expected.
+  // FIXME: It is possible to be called without having properly updated our
+  // internal representation. This means that our preferred logical widths were
+  // not recomputed as expected.
   if (nEffCols != m_width.size()) {
     calcWidthArray();
-    // FIXME: Table layout shouldn't modify our table structure (but does due to columns and column-groups).
+    // FIXME: Table layout shouldn't modify our table structure (but does due to
+    // columns and column-groups).
     nEffCols = m_table->numEffectiveColumns();
   }
 
   Vector<int> calcWidth(nEffCols, 0);
 
   unsigned numAuto = 0;
   unsigned autoSpan = 0;
   int totalFixedWidth = 0;
   int totalPercentWidth = 0;
   float totalPercent = 0;
@@ skipping 99 matching lines @@
 void TableLayoutAlgorithmFixed::willChangeTableLayout() {
   // When switching table layout algorithm, we need to dirty the preferred
   // logical widths as we cleared the bits without computing them.
   // (see calcWidthArray above.) This optimization is preferred to always
   // computing the logical widths we never intended to use.
   m_table->recalcSectionsIfNeeded();
   m_table->markAllCellsWidthsDirtyAndOrNeedsLayout(LayoutTable::MarkDirtyOnly);
 }
 
 }  // namespace blink