s/Border/CollapsedBorder/ in method names handling collapsed borders

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 399 matching lines @@
   // 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())
     return LayoutBlockFlow::LocalVisualRect();
 
   bool rtl = !StyleForCellFlow().IsLeftToRightDirection();
   LayoutUnit outline_outset(Style()->OutlineOutsetExtent());
-  LayoutUnit left(std::max(BorderHalfLeft(true), outline_outset));
-  LayoutUnit right(std::max(BorderHalfRight(true), outline_outset));
-  LayoutUnit top(std::max(BorderHalfTop(true), outline_outset));
-  LayoutUnit bottom(std::max(BorderHalfBottom(true), outline_outset));
+  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)) {
-      top = std::max(top, before->BorderHalfTop(true));
-      bottom = std::max(bottom, before->BorderHalfBottom(true));
+      top = std::max(top, before->CollapsedBorderHalfTop(true));
+      bottom = std::max(bottom, before->CollapsedBorderHalfBottom(true));
     }
   }
   if ((left && rtl) || (right && !rtl)) {
     if (LayoutTableCell* after = Table()->CellAfter(this)) {
-      top = std::max(top, after->BorderHalfTop(true));
-      bottom = std::max(bottom, after->BorderHalfBottom(true));
+      top = std::max(top, after->CollapsedBorderHalfTop(true));
+      bottom = std::max(bottom, after->CollapsedBorderHalfBottom(true));
     }
   }
   if (top) {
     if (LayoutTableCell* above = Table()->CellAbove(this)) {
-      left = std::max(left, above->BorderHalfLeft(true));
-      right = std::max(right, above->BorderHalfRight(true));
+      left = std::max(left, above->CollapsedBorderHalfLeft(true));
+      right = std::max(right, above->CollapsedBorderHalfRight(true));
     }
   }
   if (bottom) {
     if (LayoutTableCell* below = Table()->CellBelow(this)) {
-      left = std::max(left, below->BorderHalfLeft(true));
-      right = std::max(right, below->BorderHalfRight(true));
+      left = std::max(left, below->CollapsedBorderHalfLeft(true));
+      right = std::max(right, below->CollapsedBorderHalfRight(true));
     }
   }
 
   LayoutRect self_visual_overflow_rect = this->SelfVisualOverflowRect();
   LayoutPoint location(
       std::max(LayoutUnit(left), -self_visual_overflow_rect.X()),
       std::max(LayoutUnit(top), -self_visual_overflow_rect.Y()));
   return LayoutRect(-location.X(), -location.Y(),
                     location.X() + std::max(Size().Width() + right,
                                             self_visual_overflow_rect.MaxX()),
@@ skipping 696 matching lines @@
             include_color ? table->ResolveColor(after_color_property) : Color(),
             kBorderPrecedenceTable));
     if (!result.Exists())
       return result;
   }
 
   return result;
 }
 
 LayoutUnit LayoutTableCell::BorderLeft() const {
-  return Table()->CollapseBorders() ? BorderHalfLeft(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfLeft(false)
                                     : LayoutBlockFlow::BorderLeft();
 }
 
 LayoutUnit LayoutTableCell::BorderRight() const {
-  return Table()->CollapseBorders() ? BorderHalfRight(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfRight(false)
                                     : LayoutBlockFlow::BorderRight();
 }
 
 LayoutUnit LayoutTableCell::BorderTop() const {
-  return Table()->CollapseBorders() ? BorderHalfTop(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfTop(false)
                                     : LayoutBlockFlow::BorderTop();
 }
 
 LayoutUnit LayoutTableCell::BorderBottom() const {
-  return Table()->CollapseBorders() ? BorderHalfBottom(false)
+  return Table()->CollapseBorders() ? 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() ? BorderHalfStart(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfStart(false)
                                     : LayoutBlockFlow::BorderStart();
 }
 
 LayoutUnit LayoutTableCell::BorderEnd() const {
-  return Table()->CollapseBorders() ? BorderHalfEnd(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfEnd(false)
                                     : LayoutBlockFlow::BorderEnd();
 }
 
 LayoutUnit LayoutTableCell::BorderBefore() const {
-  return Table()->CollapseBorders() ? BorderHalfBefore(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfBefore(false)
                                     : LayoutBlockFlow::BorderBefore();
 }
 
 LayoutUnit LayoutTableCell::BorderAfter() const {
-  return Table()->CollapseBorders() ? BorderHalfAfter(false)
+  return Table()->CollapseBorders() ? CollapsedBorderHalfAfter(false)
                                     : LayoutBlockFlow::BorderAfter();
 }
 
-LayoutUnit LayoutTableCell::BorderHalfLeft(bool outer) const {
+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() ? BorderHalfStart(outer)
-                                                        : BorderHalfEnd(outer);
+  if (style_for_cell_flow.IsHorizontalWritingMode()) {
+    return style_for_cell_flow.IsLeftToRightDirection()
+               ? CollapsedBorderHalfStart(outer)
+               : CollapsedBorderHalfEnd(outer);
+  }
   return style_for_cell_flow.IsFlippedBlocksWritingMode()
-             ? BorderHalfAfter(outer)
-             : BorderHalfBefore(outer);
+             ? CollapsedBorderHalfAfter(outer)
+             : CollapsedBorderHalfBefore(outer);
 }
 
-LayoutUnit LayoutTableCell::BorderHalfRight(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfRight(bool outer) const {
   const ComputedStyle& style_for_cell_flow = this->StyleForCellFlow();
-  if (style_for_cell_flow.IsHorizontalWritingMode())
+  if (style_for_cell_flow.IsHorizontalWritingMode()) {
     return style_for_cell_flow.IsLeftToRightDirection()
-               ? BorderHalfEnd(outer)
-               : BorderHalfStart(outer);
+               ? CollapsedBorderHalfEnd(outer)
+               : CollapsedBorderHalfStart(outer);
+  }
   return style_for_cell_flow.IsFlippedBlocksWritingMode()
-             ? BorderHalfBefore(outer)
-             : BorderHalfAfter(outer);
+             ? CollapsedBorderHalfBefore(outer)
+             : CollapsedBorderHalfAfter(outer);
 }
 
-LayoutUnit LayoutTableCell::BorderHalfTop(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfTop(bool outer) const {
   const ComputedStyle& style_for_cell_flow = this->StyleForCellFlow();
-  if (style_for_cell_flow.IsHorizontalWritingMode())
+  if (style_for_cell_flow.IsHorizontalWritingMode()) {
     return style_for_cell_flow.IsFlippedBlocksWritingMode()
-               ? BorderHalfAfter(outer)
-               : BorderHalfBefore(outer);
-  return style_for_cell_flow.IsLeftToRightDirection() ? BorderHalfStart(outer)
-                                                      : BorderHalfEnd(outer);
+               ? CollapsedBorderHalfAfter(outer)
+               : CollapsedBorderHalfBefore(outer);
+  }
+  return style_for_cell_flow.IsLeftToRightDirection()
+             ? CollapsedBorderHalfStart(outer)
+             : CollapsedBorderHalfEnd(outer);
 }
 
-LayoutUnit LayoutTableCell::BorderHalfBottom(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfBottom(bool outer) const {
   const ComputedStyle& style_for_cell_flow = this->StyleForCellFlow();
-  if (style_for_cell_flow.IsHorizontalWritingMode())
+  if (style_for_cell_flow.IsHorizontalWritingMode()) {
     return style_for_cell_flow.IsFlippedBlocksWritingMode()
-               ? BorderHalfBefore(outer)
-               : BorderHalfAfter(outer);
-  return style_for_cell_flow.IsLeftToRightDirection() ? BorderHalfEnd(outer)
-                                                      : BorderHalfStart(outer);
+               ? CollapsedBorderHalfBefore(outer)
+               : CollapsedBorderHalfAfter(outer);
+  }
+  return style_for_cell_flow.IsLeftToRightDirection()
+             ? CollapsedBorderHalfEnd(outer)
+             : CollapsedBorderHalfStart(outer);
 }
 
-LayoutUnit LayoutTableCell::BorderHalfStart(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfStart(bool outer) const {
   CollapsedBorderValue border =
       ComputeCollapsedStartBorder(kDoNotIncludeBorderColor);
   if (border.Exists()) {
     return LayoutUnit(
         (border.Width() +
          ((StyleForCellFlow().IsLeftToRightDirection() ^ outer) ? 1 : 0)) /
         2);  // Give the extra pixel to top and left.
   }
   return LayoutUnit();
 }
 
-LayoutUnit LayoutTableCell::BorderHalfEnd(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfEnd(bool outer) const {
   CollapsedBorderValue border =
       ComputeCollapsedEndBorder(kDoNotIncludeBorderColor);
   if (border.Exists()) {
     return LayoutUnit(
         (border.Width() +
          ((StyleForCellFlow().IsLeftToRightDirection() ^ outer) ? 0 : 1)) /
         2);
   }
   return LayoutUnit();
 }
 
-LayoutUnit LayoutTableCell::BorderHalfBefore(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfBefore(bool outer) const {
   CollapsedBorderValue border =
       ComputeCollapsedBeforeBorder(kDoNotIncludeBorderColor);
   if (border.Exists()) {
     return LayoutUnit(
         (border.Width() +
          ((StyleForCellFlow().IsFlippedBlocksWritingMode() ^ outer) ? 0 : 1)) /
         2);  // Give the extra pixel to top and left.
   }
   return LayoutUnit();
 }
 
-LayoutUnit LayoutTableCell::BorderHalfAfter(bool outer) const {
+LayoutUnit LayoutTableCell::CollapsedBorderHalfAfter(bool outer) const {
   CollapsedBorderValue border =
       ComputeCollapsedAfterBorder(kDoNotIncludeBorderColor);
   if (border.Exists()) {
     return LayoutUnit(
         (border.Width() +
          ((StyleForCellFlow().IsFlippedBlocksWritingMode() ^ outer) ? 1 : 0)) /
         2);
   }
   return LayoutUnit();
 }
 
 void LayoutTableCell::Paint(const PaintInfo& paint_info,
                             const LayoutPoint& paint_offset) const {
   TableCellPainter(*this).Paint(paint_info, paint_offset);
 }
 
 static void AddBorderStyle(LayoutTable::CollapsedBorderValues& border_values,
                            CollapsedBorderValue border_value) {
   if (!border_value.IsVisible())
     return;
   size_t count = border_values.size();
   for (size_t i = 0; i < count; ++i) {
     if (border_values[i].IsSameIgnoringColor(border_value))
       return;
   }
   border_values.push_back(border_value);
 }
 
-void LayoutTableCell::CollectBorderValues(
+void LayoutTableCell::CollectCollapsedBorderValues(
     LayoutTable::CollapsedBorderValues& border_values) {
   CollapsedBorderValues new_values(
       *this, ComputeCollapsedStartBorder(), ComputeCollapsedEndBorder(),
       ComputeCollapsedBeforeBorder(), ComputeCollapsedAfterBorder());
 
   bool changed = false;
   if (!new_values.StartBorder().IsVisible() &&
       !new_values.EndBorder().IsVisible() &&
       !new_values.BeforeBorder().IsVisible() &&
       !new_values.AfterBorder().IsVisible()) {
@@ skipping 28 matching lines @@
         .SlowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
             *this, kPaintInvalidationStyleChange);
   }
 
   AddBorderStyle(border_values, new_values.StartBorder());
   AddBorderStyle(border_values, new_values.EndBorder());
   AddBorderStyle(border_values, new_values.BeforeBorder());
   AddBorderStyle(border_values, new_values.AfterBorder());
 }
 
-void LayoutTableCell::SortBorderValues(
+void LayoutTableCell::SortCollapsedBorderValues(
     LayoutTable::CollapsedBorderValues& border_values) {
   std::sort(border_values.begin(), border_values.end(), CompareBorders);
 }
 
 void LayoutTableCell::PaintBoxDecorationBackground(
     const PaintInfo& paint_info,
     const LayoutPoint& paint_offset) const {
   TableCellPainter(*this).PaintBoxDecorationBackground(paint_info,
                                                        paint_offset);
 }
@@ skipping 108 matching lines @@
 }
 
 bool LayoutTableCell::HasLineIfEmpty() const {
   if (GetNode() && HasEditableStyle(*GetNode()))
     return true;
 
   return LayoutBlock::HasLineIfEmpty();
 }
 
 }  // namespace blink