Reformat comments in core/layout up until LayoutTableRow

third_party/WebKit/Source/core/layout/LayoutTableCell.h

 /*
  * 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, 2009, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2013 Apple Inc.
+ *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 127 matching lines @@
       return logicalWidthFromColumns(firstColumn, styleWidth);
     return styleWidth;
   }
 
   int logicalHeightFromStyle() const {
     Length height = style()->logicalHeight();
     int styleLogicalHeight = height.isIntrinsicOrAuto()
                                  ? 0
                                  : valueForLength(height, LayoutUnit()).toInt();
 
-    // In strict mode, box-sizing: content-box do the right thing and actually add in the border and padding.
+    // In strict mode, box-sizing: content-box do the right thing and actually
+    // add in the border and padding.
     // Call computedCSSPadding* directly to avoid including implicitPadding.
     if (!document().inQuirksMode() &&
         style()->boxSizing() != BoxSizingBorderBox)
       styleLogicalHeight +=
           (computedCSSPaddingBefore() + computedCSSPaddingAfter()).floor() +
           borderBefore() + borderAfter();
     return styleLogicalHeight;
   }
 
   int logicalHeightForRowSizing() const {
-    // FIXME: This function does too much work, and is very hot during table layout!
+    // FIXME: This function does too much work, and is very hot during table
+    // layout!
     int adjustedLogicalHeight =
         pixelSnappedLogicalHeight() -
         (intrinsicPaddingBefore() + intrinsicPaddingAfter());
     int styleLogicalHeight = logicalHeightFromStyle();
     return max(styleLogicalHeight, adjustedLogicalHeight);
   }
 
   void setCellLogicalWidth(int constrainedLogicalWidth, SubtreeLayoutScope&);
 
   int borderLeft() const override;
@@ skipping 24 matching lines @@
   void clearIntrinsicPadding() { setIntrinsicPadding(0, 0); }
 
   int intrinsicPaddingBefore() const { return m_intrinsicPaddingBefore; }
   int intrinsicPaddingAfter() const { return m_intrinsicPaddingAfter; }
 
   LayoutUnit paddingTop() const override;
   LayoutUnit paddingBottom() const override;
   LayoutUnit paddingLeft() const override;
   LayoutUnit paddingRight() const override;
 
-  // FIXME: For now we just assume the cell has the same block flow direction as the table. It's likely we'll
-  // create an extra anonymous LayoutBlock to handle mixing directionality anyway, in which case we can lock
-  // the block flow directionality of the cells to the table's directionality.
+  // FIXME: For now we just assume the cell has the same block flow direction as
+  // the table. It's likely we'll create an extra anonymous LayoutBlock to
+  // handle mixing directionality anyway, in which case we can lock the block
+  // flow directionality of the cells to the table's directionality.
   LayoutUnit paddingBefore() const override;
   LayoutUnit paddingAfter() const override;
 
   void setOverrideLogicalContentHeightFromRowHeight(LayoutUnit);
 
   void scrollbarsChanged(bool horizontalScrollbarChanged,
                          bool verticalScrollbarChanged) override;
 
   bool cellWidthChanged() const { return m_cellWidthChanged; }
   void setCellWidthChanged(bool b = true) { m_cellWidthChanged = b; }
 
   static LayoutTableCell* createAnonymous(Document*);
   static LayoutTableCell* createAnonymousWithParent(const LayoutObject*);
   LayoutBox* createAnonymousBoxWithSameTypeAs(
       const LayoutObject* parent) const override {
     return createAnonymousWithParent(parent);
   }
 
-  // This function is used to unify which table part's style we use for computing direction and
-  // writing mode. Writing modes are not allowed on row group and row but direction is.
-  // This means we can safely use the same style in all cases to simplify our code.
-  // FIXME: Eventually this function should replaced by style() once we support direction
-  // on all table parts and writing-mode on cells.
+  // This function is used to unify which table part's style we use for
+  // computing direction and writing mode. Writing modes are not allowed on row
+  // group and row but direction is. This means we can safely use the same style
+  // in all cases to simplify our code.
+  // FIXME: Eventually this function should replaced by style() once we support
+  // direction on all table parts and writing-mode on cells.
   const ComputedStyle& styleForCellFlow() const { return row()->styleRef(); }
 
   const BorderValue& borderAdjoiningTableStart() const {
     ASSERT(isFirstOrLastCellInRow());
     if (section()->hasSameDirectionAs(table()))
       return style()->borderStart();
 
     return style()->borderEnd();
   }
 
   const BorderValue& borderAdjoiningTableEnd() const {
     ASSERT(isFirstOrLastCellInRow());
     if (section()->hasSameDirectionAs(table()))
       return style()->borderEnd();
 
     return style()->borderStart();
   }
 
   const BorderValue& borderAdjoiningCellBefore(const LayoutTableCell* cell) {
     DCHECK_EQ(table()->cellAfter(cell), this);
-    // FIXME: https://webkit.org/b/79272 - Add support for mixed directionality at the cell level.
+    // FIXME: https://webkit.org/b/79272 - Add support for mixed directionality
+    // at the cell level.
     return style()->borderStart();
   }
 
   const BorderValue& borderAdjoiningCellAfter(const LayoutTableCell* cell) {
     DCHECK_EQ(table()->cellBefore(cell), this);
-    // FIXME: https://webkit.org/b/79272 - Add support for mixed directionality at the cell level.
+    // FIXME: https://webkit.org/b/79272 - Add support for mixed directionality
+    // at the cell level.
     return style()->borderEnd();
   }
 
 #if ENABLE(ASSERT)
   bool isFirstOrLastCellInRow() const {
     return !table()->cellAfter(this) || !table()->cellBefore(this);
   }
 #endif
 
   const char* name() const override { return "LayoutTableCell"; }
@@ skipping 97 matching lines @@
                                  Length widthFromStyle) const;
 
   void updateColAndRowSpanFlags();
 
   unsigned parseRowSpanFromDOM() const;
   unsigned parseColSpanFromDOM() const;
 
   void nextSibling() const = delete;
   void previousSibling() const = delete;
 
-  // Note MSVC will only pack members if they have identical types, hence we use unsigned instead of bool here.
+  // Note MSVC will only pack members if they have identical types, hence we use
+  // unsigned instead of bool here.
   unsigned m_absoluteColumnIndex : 29;
   unsigned m_cellWidthChanged : 1;
   unsigned m_hasColSpan : 1;
   unsigned m_hasRowSpan : 1;
 
   // The intrinsic padding.
   // See class comment for what they are.
   //
   // Note: Those fields are using non-subpixel units (int)
   // because we don't do fractional arithmetic on tables.
@@ skipping 17 matching lines @@
   return toLayoutTableCell(firstChild());
 }
 
 inline LayoutTableCell* LayoutTableRow::lastCell() const {
   return toLayoutTableCell(lastChild());
 }
 
 }  // namespace blink
 
 #endif  // LayoutTableCell_h