Reformat comments in core/layout

third_party/WebKit/Source/core/layout/LayoutTableSection.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, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 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.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef LayoutTableSection_h
 #define LayoutTableSection_h
 
 #include "core/CoreExport.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTableBoxComponent.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
-// This variable is used to balance the memory consumption vs the paint invalidation time on big tables.
+// This variable is used to balance the memory consumption vs the paint
+// invalidation time on big tables.
 const float gMaxAllowedOverflowingCellRatioForFastPaintPath = 0.1f;
 
 // Helper class for paintObject.
 class CellSpan {
   STACK_ALLOCATED();
 
  public:
   CellSpan(unsigned start, unsigned end) : m_start(start), m_end(end) {}
 
   unsigned start() const { return m_start; }
@@ skipping 172 matching lines @@
   LayoutTableCell* primaryCellAt(unsigned row, unsigned effectiveColumn) {
     CellStruct& c = m_grid[row].row[effectiveColumn];
     return c.primaryCell();
   }
   const LayoutTableCell* primaryCellAt(unsigned row,
                                        unsigned effectiveColumn) const {
     return const_cast<LayoutTableSection*>(this)->primaryCellAt(
         row, effectiveColumn);
   }
 
-  // Returns null for cells with a rowspan that exceed the last row. Possibly others.
+  // Returns null for cells with a rowspan that exceed the last row. Possibly
+  // others.
   LayoutTableRow* rowLayoutObjectAt(unsigned row) {
     return m_grid[row].rowLayoutObject;
   }
   const LayoutTableRow* rowLayoutObjectAt(unsigned row) const {
     return m_grid[row].rowLayoutObject;
   }
 
   void appendEffectiveColumn(unsigned pos);
   void splitEffectiveColumn(unsigned pos, unsigned first);
 
@@ skipping 29 matching lines @@
       recalcCells();
   }
 
   bool needsCellRecalc() const { return m_needsCellRecalc; }
   void setNeedsCellRecalc();
 
   int rowBaseline(unsigned row) { return m_grid[row].baseline; }
 
   void rowLogicalHeightChanged(LayoutTableRow*);
 
-  // distributeExtraLogicalHeightToRows methods return the *consumed* extra logical height.
-  // FIXME: We may want to introduce a structure holding the in-flux layout information.
+  // distributeExtraLogicalHeightToRows methods return the *consumed* extra
+  // logical height.
+  // FIXME: We may want to introduce a structure holding the in-flux layout
+  // information.
   int distributeExtraLogicalHeightToRows(int extraLogicalHeight);
 
   static LayoutTableSection* createAnonymousWithParent(const LayoutObject*);
   LayoutBox* createAnonymousBoxWithSameTypeAs(
       const LayoutObject* parent) const override {
     return createAnonymousWithParent(parent);
   }
 
   void paint(const PaintInfo&, const LayoutPoint&) const override;
 
-  // Flip the rect so it aligns with the coordinates used by the rowPos and columnPos vectors.
+  // Flip the rect so it aligns with the coordinates used by the rowPos and
+  // columnPos vectors.
   LayoutRect logicalRectForWritingModeAndDirection(const LayoutRect&) const;
 
   CellSpan dirtiedRows(const LayoutRect& paintInvalidationRect) const;
   CellSpan dirtiedEffectiveColumns(
       const LayoutRect& paintInvalidationRect) const;
   const HashSet<LayoutTableCell*>& overflowingCells() const {
     return m_overflowingCells;
   }
   bool hasMultipleCellLevels() const { return m_hasMultipleCellLevels; }
 
   const char* name() const override { return "LayoutTableSection"; }
 
-  // Whether a section has opaque background depends on many factors, e.g. border spacing,
-  // border collapsing, missing cells, etc.
-  // For simplicity, just conservatively assume all table sections are not opaque.
+  // Whether a section has opaque background depends on many factors, e.g.
+  // border spacing, border collapsing, missing cells, etc. For simplicity,
+  // just conservatively assume all table sections are not opaque.
   bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect&,
                                          unsigned) const override {
     return false;
   }
   bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const override {
     return false;
   }
 
   int paginationStrutForRow(LayoutTableRow*, LayoutUnit logicalOffset) const;
 
@@ skipping 78 matching lines @@
     return m_overflowingCells.size() || m_forceSlowPaintPathWithOverflowingCell;
   }
 
   void computeOverflowFromCells(unsigned totalRows, unsigned nEffCols);
 
   CellSpan fullTableRowSpan() const { return CellSpan(0, m_grid.size()); }
   CellSpan fullTableEffectiveColumnSpan() const {
     return CellSpan(0, table()->numEffectiveColumns());
   }
 
-  // These two functions take a rectangle as input that has been flipped by logicalRectForWritingModeAndDirection.
-  // The returned span of rows or columns is end-exclusive, and empty if start==end.
+  // These two functions take a rectangle as input that has been flipped by
+  // logicalRectForWritingModeAndDirection.
+  // The returned span of rows or columns is end-exclusive, and empty if
+  // start==end.
   CellSpan spannedRows(const LayoutRect& flippedRect) const;
   CellSpan spannedEffectiveColumns(const LayoutRect& flippedRect) const;
 
   void setLogicalPositionForCell(LayoutTableCell*,
                                  unsigned effectiveColumn) const;
 
   void relayoutCellIfFlexed(LayoutTableCell&, int rowIndex, int rowHeight);
 
   // The representation of the rows and their cells (CellStruct).
   Vector<RowStruct> m_grid;
@@ skipping 22 matching lines @@
   unsigned m_cRow;
 
   int m_outerBorderStart;
   int m_outerBorderEnd;
   int m_outerBorderBefore;
   int m_outerBorderAfter;
 
   bool m_needsCellRecalc;
 
   // This HashSet holds the overflowing cells for faster painting.
-  // If we have more than gMaxAllowedOverflowingCellRatio * total cells, it will be empty
-  // and m_forceSlowPaintPathWithOverflowingCell will be set to save memory.
+  // If we have more than gMaxAllowedOverflowingCellRatio * total cells, it will
+  // be empty and m_forceSlowPaintPathWithOverflowingCell will be set to save
+  // memory.
   HashSet<LayoutTableCell*> m_overflowingCells;
   bool m_forceSlowPaintPathWithOverflowingCell;
 
   // This boolean tracks if we have cells overlapping due to rowspan / colspan
   // (see class comment above about when it could appear).
   //
   // The use is to disable a painting optimization where we just paint the
   // invalidated cells.
   bool m_hasMultipleCellLevels;
 
   LayoutUnit m_offsetForRepeatingHeader;
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutTableSection, isTableSection());
 
 }  // namespace blink
 
 #endif  // LayoutTableSection_h