Reformat comments in core/layout up until LayoutTableRow

third_party/WebKit/Source/core/layout/LayoutTable.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, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2009, 2010 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 111 matching lines @@
 // over effectiveColumns() and effectiveColumnPositions().
 //
 // See absoluteColumnToEffectiveColumn() for converting an absolute column
 // index into an index into effectiveColumns() and effectiveColumnPositions().
 
 class CORE_EXPORT LayoutTable final : public LayoutBlock {
  public:
   explicit LayoutTable(Element*);
   ~LayoutTable() override;
 
-  // Per CSS 3 writing-mode: "The first and second values of the 'border-spacing' property represent spacing between columns
-  // and rows respectively, not necessarily the horizontal and vertical spacing respectively".
+  // Per CSS 3 writing-mode: "The first and second values of the
+  // 'border-spacing' property represent spacing between columns and rows
+  // respectively, not necessarily the horizontal and vertical spacing
+  // respectively".
   int hBorderSpacing() const { return m_hSpacing; }
   int vBorderSpacing() const { return m_vSpacing; }
 
   bool collapseBorders() const { return style()->borderCollapse(); }
 
   int borderStart() const override { return m_borderStart; }
   int borderEnd() const override { return m_borderEnd; }
   int borderBefore() const override;
   int borderAfter() const override;
 
@@ skipping 81 matching lines @@
     recalcSections();
   }
 
   const Vector<ColumnStruct>& effectiveColumns() const {
     return m_effectiveColumns;
   }
   const Vector<int>& effectiveColumnPositions() const {
     return m_effectiveColumnPositions;
   }
   void setEffectiveColumnPosition(unsigned index, int position) {
-    // Note that if our horizontal border-spacing changed, our position will change but not
-    // our column's width. In practice, horizontal border-spacing won't change often.
+    // Note that if our horizontal border-spacing changed, our position will
+    // change but not our column's width. In practice, horizontal border-spacing
+    // won't change often.
     m_columnLogicalWidthChanged |=
         m_effectiveColumnPositions[index] != position;
     m_effectiveColumnPositions[index] = position;
   }
 
   LayoutTableSection* header() const { return m_head; }
   LayoutTableSection* footer() const { return m_foot; }
   LayoutTableSection* firstBody() const { return m_firstBody; }
 
   // This function returns 0 if the table has no section.
@@ skipping 48 matching lines @@
   }
 
   // The collapsing border model dissallows paddings on table, which is why we
   // override those functions.
   // See http://www.w3.org/TR/CSS2/tables.html#collapsing-borders.
   LayoutUnit paddingTop() const override;
   LayoutUnit paddingBottom() const override;
   LayoutUnit paddingLeft() const override;
   LayoutUnit paddingRight() const override;
 
-  // Override paddingStart/End to return pixel values to match behavor of LayoutTableCell.
+  // Override paddingStart/End to return pixel values to match behavor of
+  // LayoutTableCell.
   LayoutUnit paddingEnd() const override {
     return LayoutUnit(LayoutBlock::paddingEnd().toInt());
   }
   LayoutUnit paddingStart() const override {
     return LayoutUnit(LayoutBlock::paddingStart().toInt());
   }
 
   LayoutUnit bordersPaddingAndSpacingInRowDirection() const {
-    // 'border-spacing' only applies to separate borders (see 17.6.1 The separated borders model).
+    // 'border-spacing' only applies to separate borders (see 17.6.1 The
+    // separated borders model).
     return borderStart() + borderEnd() +
            (collapseBorders() ? LayoutUnit() : (paddingStart() + paddingEnd() +
                                                 borderSpacingInRowDirection()));
   }
 
   // Return the first column or column-group.
   LayoutTableCol* firstColumn() const;
 
   struct ColAndColGroup {
     ColAndColGroup()
         : col(nullptr),
           colgroup(nullptr),
           adjoinsStartBorderOfColGroup(false),
           adjoinsEndBorderOfColGroup(false) {}
     LayoutTableCol* col;
     LayoutTableCol* colgroup;
     bool adjoinsStartBorderOfColGroup;
     bool adjoinsEndBorderOfColGroup;
     LayoutTableCol* innermostColOrColGroup() { return col ? col : colgroup; }
   };
   ColAndColGroup colElementAtAbsoluteColumn(
       unsigned absoluteColumnIndex) const {
-    // The common case is to not have col/colgroup elements, make that case fast.
+    // The common case is to not have col/colgroup elements, make that case
+    // fast.
     if (!m_hasColElements)
       return ColAndColGroup();
     return slowColElementAtAbsoluteColumn(absoluteColumnIndex);
   }
 
   bool needsSectionRecalc() const { return m_needsSectionRecalc; }
   void setNeedsSectionRecalc() {
     if (documentBeingDestroyed())
       return;
     m_needsSectionRecalc = true;
@@ skipping 47 matching lines @@
     ASSERT(m_collapsedBordersValid);
     return m_collapsedBorders;
   }
 
   void subtractCaptionRect(LayoutRect&) const;
 
   bool isLogicalWidthAuto() const;
 
   const char* name() const override { return "LayoutTable"; }
 
-  // Whether a table has opaque foreground depends on many factors, e.g. border spacing, missing cells, etc.
-  // For simplicity, just conservatively assume foreground of all tables are not opaque.
+  // Whether a table has opaque foreground depends on many factors, e.g. border
+  // spacing, missing cells, etc. For simplicity, just conservatively assume
+  // foreground of all tables are not opaque.
   bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect&,
                                          unsigned) const override {
     return false;
   }
 
   enum WhatToMarkAllCells { MarkDirtyOnly, MarkDirtyAndNeedsLayout };
   void markAllCellsWidthsDirtyAndOrNeedsLayout(WhatToMarkAllCells);
 
  protected:
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override;
@@ skipping 47 matching lines @@
 
   void addOverflowFromChildren() override;
 
   void recalcSections() const;
   void layoutCaption(LayoutTableCaption&);
 
   void distributeExtraLogicalHeight(int extraLogicalHeight);
 
   void recalcCollapsedBordersIfNeeded();
 
-  // TODO(layout-dev): All mutables in this class are lazily updated by recalcSections()
-  // which is called by various getter methods (e.g. borderBefore(), borderAfter()).
-  // They allow dirty layout even after DocumentLifecycle::LayoutClean which seems not proper. crbug.com/538236.
+  // TODO(layout-dev): All mutables in this class are lazily updated by
+  // recalcSections() which is called by various getter methods (e.g.
+  // borderBefore(), borderAfter()).
+  // They allow dirty layout even after DocumentLifecycle::LayoutClean which
+  // seems not proper. crbug.com/538236.
 
   // Holds spans (number of absolute columns) of effective columns.
-  // See "absolute column index vs effective column index" in comments of LayoutTable.
+  // See "absolute column index vs effective column index" in comments of
+  // LayoutTable.
   mutable Vector<ColumnStruct> m_effectiveColumns;
 
-  // Holds the logical layout positions of effective columns, and the last item (whose index
-  // is numEffectiveColumns()) holds the position of the imaginary column after the last column.
-  // Because of the last item, m_effectiveColumnPositions.size() is always numEffectiveColumns() + 1.
+  // Holds the logical layout positions of effective columns, and the last item
+  // (whose index is numEffectiveColumns()) holds the position of the imaginary
+  // column after the last column.
+  // Because of the last item, m_effectiveColumnPositions.size() is always
+  // numEffectiveColumns() + 1.
   mutable Vector<int> m_effectiveColumnPositions;
 
   // The captions associated with this object.
   mutable Vector<LayoutTableCaption*> m_captions;
 
-  // Holds pointers to LayoutTableCol objects for <col>s and <colgroup>s under this table.
-  // There is no direct relationship between the size of and index into this vector and
-  // those of m_effectiveColumns because they hold different things.
+  // Holds pointers to LayoutTableCol objects for <col>s and <colgroup>s under
+  // this table.
+  // There is no direct relationship between the size of and index into this
+  // vector and those of m_effectiveColumns because they hold different things.
   mutable Vector<LayoutTableCol*> m_columnLayoutObjects;
 
   mutable LayoutTableSection* m_head;
   mutable LayoutTableSection* m_foot;
   mutable LayoutTableSection* m_firstBody;
 
   // The layout algorithm used by this table.
   //
   // CSS 2.1 defines 2 types of table layouts toggled with 'table-layout':
   // fixed (TableLayoutAlgorithmFixed) and auto (TableLayoutAlgorithmAuto).
@@ skipping 42 matching lines @@
   if (m_firstBody)
     return m_firstBody;
   return m_foot;
 }
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTable, isTable());
 
 }  // namespace blink
 
 #endif  // LayoutTable_h