Rename LayoutTable::CollapseBorders() to ShouldCollapseBorders()

third_party/WebKit/Source/core/layout/LayoutTableCell.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 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 89 matching lines @@
 
 void LayoutTableCell::WillBeRemovedFromTree() {
   LayoutBlockFlow::WillBeRemovedFromTree();
 
   Section()->SetNeedsCellRecalc();
 
   // When borders collapse, removing a cell can affect the the width of
   // neighboring cells.
   LayoutTable* enclosing_table = Table();
   DCHECK(enclosing_table);
-  if (!enclosing_table->CollapseBorders())
+  if (!enclosing_table->ShouldCollapseBorders())
     return;
   if (PreviousCell()) {
     // TODO(dgrogan): Should this be setChildNeedsLayout or setNeedsLayout?
     // remove-cell-with-border-box.html only passes with setNeedsLayout but
     // other places use setChildNeedsLayout.
     PreviousCell()->SetNeedsLayout(LayoutInvalidationReason::kTableChanged);
     PreviousCell()->SetPreferredLogicalWidthsDirty();
   }
   if (NextCell()) {
     // TODO(dgrogan): Same as above re: setChildNeedsLayout vs setNeedsLayout.
@@ skipping 287 matching lines @@
 
   return offset;
 }
 
 LayoutRect LayoutTableCell::LocalVisualRect() const {
   // If the table grid is dirty, we cannot get reliable information about
   // adjoining cells, so we ignore outside borders. This should not be a problem
   // because it means that the table is going to recalculate the grid, relayout
   // and issue a paint invalidation of its current rect, which includes any
   // outside borders of this cell.
-  if (!Table()->CollapseBorders() || Table()->NeedsSectionRecalc())
+  if (!Table()->ShouldCollapseBorders() || Table()->NeedsSectionRecalc())
     return LayoutBlockFlow::LocalVisualRect();
 
   bool rtl = !StyleForCellFlow().IsLeftToRightDirection();
   LayoutUnit outline_outset(Style()->OutlineOutsetExtent());
   LayoutUnit left(std::max(CollapsedBorderHalfLeft(true), outline_outset));
   LayoutUnit right(std::max(CollapsedBorderHalfRight(true), outline_outset));
   LayoutUnit top(std::max(CollapsedBorderHalfTop(true), outline_outset));
   LayoutUnit bottom(std::max(CollapsedBorderHalfBottom(true), outline_outset));
   if ((left && !rtl) || (right && rtl)) {
     if (LayoutTableCell* before = Table()->CellBefore(this)) {
@@ skipping 666 matching lines @@
                                      table->ResolveColor(after_color_property),
                                      kBorderPrecedenceTable));
     if (!result.Exists())
       return result;
   }
 
   return result;
 }
 
 LayoutUnit LayoutTableCell::BorderLeft() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfLeft(false)
-                                    : LayoutBlockFlow::BorderLeft();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfLeft(false)
+                                          : LayoutBlockFlow::BorderLeft();
 }
 
 LayoutUnit LayoutTableCell::BorderRight() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfRight(false)
-                                    : LayoutBlockFlow::BorderRight();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfRight(false)
+                                          : LayoutBlockFlow::BorderRight();
 }
 
 LayoutUnit LayoutTableCell::BorderTop() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfTop(false)
-                                    : LayoutBlockFlow::BorderTop();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfTop(false)
+                                          : LayoutBlockFlow::BorderTop();
 }
 
 LayoutUnit LayoutTableCell::BorderBottom() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfBottom(false)
-                                    : LayoutBlockFlow::BorderBottom();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfBottom(false)
+                                          : LayoutBlockFlow::BorderBottom();
 }
 
 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=46191, make the collapsed
 // border drawing work with different block flow values instead of being
 // hard-coded to top-to-bottom.
 LayoutUnit LayoutTableCell::BorderStart() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfStart(false)
-                                    : LayoutBlockFlow::BorderStart();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfStart(false)
+                                          : LayoutBlockFlow::BorderStart();
 }
 
 LayoutUnit LayoutTableCell::BorderEnd() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfEnd(false)
-                                    : LayoutBlockFlow::BorderEnd();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfEnd(false)
+                                          : LayoutBlockFlow::BorderEnd();
 }
 
 LayoutUnit LayoutTableCell::BorderBefore() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfBefore(false)
-                                    : LayoutBlockFlow::BorderBefore();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfBefore(false)
+                                          : LayoutBlockFlow::BorderBefore();
 }
 
 LayoutUnit LayoutTableCell::BorderAfter() const {
-  return Table()->CollapseBorders() ? CollapsedBorderHalfAfter(false)
-                                    : LayoutBlockFlow::BorderAfter();
+  return Table()->ShouldCollapseBorders() ? CollapsedBorderHalfAfter(false)
+                                          : LayoutBlockFlow::BorderAfter();
 }
 
 LayoutUnit LayoutTableCell::CollapsedBorderHalfLeft(bool outer) const {
   const ComputedStyle& style_for_cell_flow = this->StyleForCellFlow();
   if (style_for_cell_flow.IsHorizontalWritingMode()) {
     return style_for_cell_flow.IsLeftToRightDirection()
                ? CollapsedBorderHalfStart(outer)
                : CollapsedBorderHalfEnd(outer);
   }
   return style_for_cell_flow.IsFlippedBlocksWritingMode()
@@ skipping 106 matching lines @@
   TableCellPainter(*this).Paint(paint_info, paint_offset);
 }
 
 void LayoutTableCell::UpdateCollapsedBorderValues() const {
   Table()->InvalidateCollapsedBordersForAllCellsIfNeeded();
   if (collapsed_border_values_valid_)
     return;
 
   collapsed_border_values_valid_ = true;
 
-  if (!Table()->CollapseBorders()) {
+  if (!Table()->ShouldCollapseBorders()) {
     if (collapsed_border_values_) {
       collapsed_borders_visually_changed_ = true;
       collapsed_border_values_ = nullptr;
     }
     return;
   }
 
   CollapsedBorderValues new_values(
       *this, ComputeCollapsedStartBorder(), ComputeCollapsedEndBorder(),
       ComputeCollapsedBeforeBorder(), ComputeCollapsedAfterBorder());
@@ skipping 137 matching lines @@
                                                      EDisplay::kTableCell);
   new_cell->SetStyle(std::move(new_style));
   return new_cell;
 }
 
 bool LayoutTableCell::BackgroundIsKnownToBeOpaqueInRect(
     const LayoutRect& local_rect) const {
   // If this object has layer, the area of collapsed borders should be
   // transparent to expose the collapsed borders painted on the underlying
   // layer.
-  if (HasLayer() && Table()->CollapseBorders())
+  if (HasLayer() && Table()->ShouldCollapseBorders())
     return false;
   return LayoutBlockFlow::BackgroundIsKnownToBeOpaqueInRect(local_rect);
 }
 
 bool LayoutTableCell::UsesCompositedCellDisplayItemClients() const {
   // In certain cases such as collapsed borders for composited table cells we
   // paint content for the cell into the table graphics layer backing and so
   // must use the table's visual rect.
   return (HasLayer() && Layer()->GetCompositingState() != kNotComposited) ||
          RuntimeEnabledFeatures::slimmingPaintV2Enabled();
@@ skipping 42 matching lines @@
     const PaintInvalidatorContext& context) const {
   return TableCellPaintInvalidator(*this, context).InvalidatePaint();
 }
 
 PaintInvalidationReason LayoutTableCell::InvalidatePaint(
     const PaintInvalidationState& state) {
   return LayoutBlockFlow::InvalidatePaint(state);
 }
 
 }  // namespace blink