Rename LayoutTable::CollapseBorders() to ShouldCollapseBorders()

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) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 63 matching lines @@
 LayoutTable::~LayoutTable() {}
 
 void LayoutTable::StyleDidChange(StyleDifference diff,
                                  const ComputedStyle* old_style) {
   LayoutBlock::StyleDidChange(diff, old_style);
 
   bool old_fixed_table_layout =
       old_style ? old_style->IsFixedTableLayout() : false;
 
   // In the collapsed border model, there is no cell spacing.
-  h_spacing_ = CollapseBorders() ? 0 : Style()->HorizontalBorderSpacing();
-  v_spacing_ = CollapseBorders() ? 0 : Style()->VerticalBorderSpacing();
+  h_spacing_ = ShouldCollapseBorders() ? 0 : Style()->HorizontalBorderSpacing();
+  v_spacing_ = ShouldCollapseBorders() ? 0 : Style()->VerticalBorderSpacing();
   effective_column_positions_[0] = h_spacing_;
 
   if (!table_layout_ ||
       Style()->IsFixedTableLayout() != old_fixed_table_layout) {
     if (table_layout_)
       table_layout_->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.
@@ skipping 280 matching lines @@
     return ComputeIntrinsicLogicalWidthUsing(
         style_logical_width, available_width,
         BordersPaddingAndSpacingInRowDirection());
 
   // HTML tables' width styles already include borders and paddings, but CSS
   // tables' width styles do not.
   LayoutUnit borders;
   bool is_css_table = !isHTMLTableElement(GetNode());
   if (is_css_table && style_logical_width.IsSpecified() &&
       style_logical_width.IsPositive() &&
-      Style()->BoxSizing() == EBoxSizing::kContentBox)
-    borders =
-        BorderStart() + BorderEnd() +
-        (CollapseBorders() ? LayoutUnit() : PaddingStart() + PaddingEnd());
+      Style()->BoxSizing() == EBoxSizing::kContentBox) {
+    borders = BorderStart() + BorderEnd() +
+              (ShouldCollapseBorders() ? LayoutUnit()
+                                       : PaddingStart() + PaddingEnd());
+  }
 
   return MinimumValueForLength(style_logical_width, available_width) + borders;
 }
 
 LayoutUnit LayoutTable::ConvertStyleLogicalHeightToComputedHeight(
     const Length& style_logical_height) const {
   LayoutUnit border_and_padding_before =
-      BorderBefore() + (CollapseBorders() ? LayoutUnit() : PaddingBefore());
+      BorderBefore() +
+      (ShouldCollapseBorders() ? LayoutUnit() : PaddingBefore());
   LayoutUnit border_and_padding_after =
-      BorderAfter() + (CollapseBorders() ? LayoutUnit() : PaddingAfter());
+      BorderAfter() + (ShouldCollapseBorders() ? LayoutUnit() : PaddingAfter());
   LayoutUnit border_and_padding =
       border_and_padding_before + border_and_padding_after;
   LayoutUnit computed_logical_height;
   if (style_logical_height.IsFixed()) {
     // 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.
     if (isHTMLTableElement(GetNode()) ||
@@ skipping 205 matching lines @@
     }
 
     LayoutTableSection* top_section = this->TopSection();
     LayoutTableSection* bottom_section = this->BottomSection();
 
     // This is the border-before edge of the "table box", relative to the "table
     // wrapper box", i.e. right after all top captions.
     // https://www.w3.org/TR/2011/REC-CSS2-20110607/tables.html#model
     LayoutUnit table_box_logical_top = LogicalHeight();
 
-    bool collapsing = CollapseBorders();
+    bool collapsing = ShouldCollapseBorders();
     if (collapsing) {
       // Need to set up the table borders before we can position the sections.
       for (LayoutTableSection* section = top_section; section;
            section = SectionBelow(section))
         section->RecalcOuterBorder();
     }
 
     LayoutUnit border_and_padding_before =
         BorderBefore() + (collapsing ? LayoutUnit() : PaddingBefore());
     LayoutUnit border_and_padding_after =
@@ skipping 140 matching lines @@
 }
 
 void LayoutTable::InvalidateCollapsedBorders() {
   collapsed_borders_.clear();
   collapsed_borders_valid_ = false;
   needs_invalidate_collapsed_borders_for_all_cells_ = true;
   SetMayNeedPaintInvalidation();
 }
 
 void LayoutTable::InvalidateCollapsedBordersForAllCellsIfNeeded() {
-  DCHECK(CollapseBorders());
+  DCHECK(ShouldCollapseBorders());
 
   if (!needs_invalidate_collapsed_borders_for_all_cells_)
     return;
   needs_invalidate_collapsed_borders_for_all_cells_ = false;
 
   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()) {
         DCHECK_EQ(cell->Table(), this);
         cell->InvalidateCollapsedBorderValues();
       }
     }
   }
 }
 
 // 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.
 void LayoutTable::RecalcCollapsedBordersIfNeeded() {
-  if (collapsed_borders_valid_ || !CollapseBorders())
+  if (collapsed_borders_valid_ || !ShouldCollapseBorders())
     return;
   collapsed_borders_valid_ = true;
   collapsed_borders_.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()) {
         DCHECK_EQ(cell->Table(), this);
         cell->CollectCollapsedBorderValues(collapsed_borders_);
       }
     }
   }
   LayoutTableCell::SortCollapsedBorderValues(collapsed_borders_);
 }
 
 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.
-  if (CollapseBorders()) {
+  if (ShouldCollapseBorders()) {
     LayoutUnit right_border_overflow =
         Size().Width() + OuterBorderRight() - BorderRight();
     LayoutUnit left_border_overflow = BorderLeft() - OuterBorderLeft();
     LayoutUnit bottom_border_overflow =
         Size().Height() + OuterBorderBottom() - BorderBottom();
     LayoutUnit top_border_overflow = BorderTop() - OuterBorderTop();
     IntRect border_overflow_rect(
         left_border_overflow.ToInt(), top_border_overflow.ToInt(),
         (right_border_overflow - left_border_overflow).ToInt(),
         (bottom_border_overflow - top_border_overflow).ToInt());
@@ skipping 322 matching lines @@
   effective_columns_.resize(max_cols);
   effective_column_positions_.resize(max_cols + 1);
   no_cell_colspan_at_least_ = CalcNoCellColspanAtLeast();
 
   DCHECK(SelfNeedsLayout());
 
   needs_section_recalc_ = false;
 }
 
 int LayoutTable::CalcBorderStart() const {
-  if (!CollapseBorders())
+  if (!ShouldCollapseBorders())
     return LayoutBlock::BorderStart().ToInt();
 
   // Determined by the first cell of the first row. See the CSS 2.1 spec,
   // section 17.6.2.
   if (!NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& table_start_border = Style()->BorderStart();
@@ skipping 46 matching lines @@
       if (first_row_adjoining_border.Style() > kBorderStyleHidden) {
         border_width =
             std::max<int>(border_width, first_row_adjoining_border.Width());
       }
     }
   }
   return (border_width + (Style()->IsLeftToRightDirection() ? 0 : 1)) / 2;
 }
 
 int LayoutTable::CalcBorderEnd() const {
-  if (!CollapseBorders())
+  if (!ShouldCollapseBorders())
     return LayoutBlock::BorderEnd().ToInt();
 
   // Determined by the last cell of the first row. See the CSS 2.1 spec, section
   // 17.6.2.
   if (!NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& table_end_border = Style()->BorderEnd();
@@ skipping 55 matching lines @@
 }
 
 void LayoutTable::RecalcBordersInRowDirection() {
   // FIXME: We need to compute the collapsed before / after borders in the same
   // fashion.
   border_start_ = CalcBorderStart();
   border_end_ = CalcBorderEnd();
 }
 
 LayoutUnit LayoutTable::BorderBefore() const {
-  if (CollapseBorders()) {
+  if (ShouldCollapseBorders()) {
     RecalcSectionsIfNeeded();
     return LayoutUnit(OuterBorderBefore());
   }
   return LayoutBlock::BorderBefore();
 }
 
 LayoutUnit LayoutTable::BorderAfter() const {
-  if (CollapseBorders()) {
+  if (ShouldCollapseBorders()) {
     RecalcSectionsIfNeeded();
     return LayoutUnit(OuterBorderAfter());
   }
   return LayoutBlock::BorderAfter();
 }
 
 int LayoutTable::OuterBorderBefore() const {
-  if (!CollapseBorders())
+  if (!ShouldCollapseBorders())
     return 0;
   int border_width = 0;
   if (LayoutTableSection* top_section = this->TopSection()) {
     border_width = top_section->OuterBorderBefore();
     if (border_width < 0)
       return 0;  // Overridden by hidden
   }
   const BorderValue& tb = Style()->BorderBefore();
   if (tb.Style() == kBorderStyleHidden)
     return 0;
   if (tb.Style() > kBorderStyleHidden)
     border_width = std::max<int>(border_width, tb.Width() / 2);
   return border_width;
 }
 
 int LayoutTable::OuterBorderAfter() const {
-  if (!CollapseBorders())
+  if (!ShouldCollapseBorders())
     return 0;
   int border_width = 0;
 
   if (LayoutTableSection* section = BottomSection()) {
     border_width = section->OuterBorderAfter();
     if (border_width < 0)
       return 0;  // Overridden by hidden
   }
   const BorderValue& tb = Style()->BorderAfter();
   if (tb.Style() == kBorderStyleHidden)
     return 0;
   if (tb.Style() > kBorderStyleHidden)
     border_width = std::max<int>(border_width, (tb.Width() + 1) / 2);
   return border_width;
 }
 
 int LayoutTable::OuterBorderStart() const {
-  if (!CollapseBorders())
+  if (!ShouldCollapseBorders())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& tb = Style()->BorderStart();
   if (tb.Style() == kBorderStyleHidden)
     return 0;
   if (tb.Style() > kBorderStyleHidden)
     border_width =
         (tb.Width() + (Style()->IsLeftToRightDirection() ? 0 : 1)) / 2;
 
   bool all_hidden = true;
   for (LayoutTableSection* section = TopSection(); section;
        section = SectionBelow(section)) {
     int sw = section->OuterBorderStart();
     if (sw < 0)
       continue;
     all_hidden = false;
     border_width = std::max(border_width, sw);
   }
   if (all_hidden)
     return 0;
 
   return border_width;
 }
 
 int LayoutTable::OuterBorderEnd() const {
-  if (!CollapseBorders())
+  if (!ShouldCollapseBorders())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& tb = Style()->BorderEnd();
   if (tb.Style() == kBorderStyleHidden)
     return 0;
   if (tb.Style() > kBorderStyleHidden)
     border_width =
         (tb.Width() + (Style()->IsLeftToRightDirection() ? 1 : 0)) / 2;
@@ skipping 304 matching lines @@
   return Style()->BorderStart();
 }
 
 void LayoutTable::EnsureIsReadyForPaintInvalidation() {
   LayoutBlock::EnsureIsReadyForPaintInvalidation();
   RecalcCollapsedBordersIfNeeded();
 }
 
 PaintInvalidationReason LayoutTable::InvalidatePaint(
     const PaintInvalidationState& paint_invalidation_state) {
-  if (CollapseBorders() && !collapsed_borders_.IsEmpty())
+  if (ShouldCollapseBorders() && !collapsed_borders_.IsEmpty())
     paint_invalidation_state.PaintingLayer()
         .SetNeedsPaintPhaseDescendantBlockBackgrounds();
 
   return LayoutBlock::InvalidatePaint(paint_invalidation_state);
 }
 
 PaintInvalidationReason LayoutTable::InvalidatePaint(
     const PaintInvalidatorContext& context) const {
   return TablePaintInvalidator(*this, context).InvalidatePaint();
 }
 
 LayoutUnit LayoutTable::PaddingTop() const {
-  if (CollapseBorders())
+  if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingTop();
 }
 
 LayoutUnit LayoutTable::PaddingBottom() const {
-  if (CollapseBorders())
+  if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingBottom();
 }
 
 LayoutUnit LayoutTable::PaddingLeft() const {
-  if (CollapseBorders())
+  if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingLeft();
 }
 
 LayoutUnit LayoutTable::PaddingRight() const {
-  if (CollapseBorders())
+  if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingRight();
 }
 
 }  // namespace blink