Improve LayoutTable outer collapsed border calculation

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 40 matching lines @@
 
 using namespace HTMLNames;
 
 LayoutTable::LayoutTable(Element* element)
     : LayoutBlock(element),
       head_(nullptr),
       foot_(nullptr),
       first_body_(nullptr),
       collapsed_borders_valid_(false),
       needs_invalidate_collapsed_borders_for_all_cells_(false),
+      collapsed_outer_borders_valid_(false),
       has_col_elements_(false),
       needs_section_recalc_(false),
       column_logical_width_changed_(false),
       column_layout_objects_valid_(false),
       no_cell_colspan_at_least_(0),
       h_spacing_(0),
       v_spacing_(0),
-      border_start_(0),
-      border_end_(0) {
+      collapsed_outer_border_start_(0),
+      collapsed_outer_border_end_(0),
+      collapsed_outer_border_before_(0),
+      collapsed_outer_border_after_(0) {
   DCHECK(!ChildrenInline());
   effective_column_positions_.Fill(0, 1);
 }
 
 LayoutTable::~LayoutTable() {}
 
 void LayoutTable::StyleDidChange(StyleDifference diff,
                                  const ComputedStyle* old_style) {
   LayoutBlock::StyleDidChange(diff, old_style);
 
@@ skipping 493 matching lines @@
 
   if (SimplifiedLayout())
     return;
 
   // Note: LayoutTable is handled differently than other LayoutBlocks and the
   // LayoutScope
   //       must be created before the table begins laying out.
   TextAutosizer::LayoutScope text_autosizer_layout_scope(this);
 
   RecalcSectionsIfNeeded();
-  // FIXME: We should do this recalc lazily in borderStart/borderEnd so that we
-  // don't have to make sure to call this before we call borderStart/borderEnd
-  // to avoid getting a stale value.
-  RecalcBordersInRowDirection();
 
   SubtreeLayoutScope layouter(*this);
 
   {
     LayoutState state(*this);
     LayoutUnit old_logical_width = LogicalWidth();
     LayoutUnit old_logical_height = LogicalHeight();
 
     SetLogicalHeight(LayoutUnit());
     UpdateLogicalWidth();
@@ skipping 20 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 = 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 =
         BorderAfter() + (collapsing ? LayoutUnit() : PaddingAfter());
 
     SetLogicalHeight(table_box_logical_top + border_and_padding_before);
 
     LayoutUnit section_logical_left = LayoutUnit(
         Style()->IsLeftToRightDirection() ? BorderStart() : BorderEnd());
     if (!collapsing) {
@@ skipping 129 matching lines @@
   SetIntrinsicContentLogicalHeight(ContentLogicalHeight());
 
   column_logical_width_changed_ = false;
   ClearNeedsLayout();
 }
 
 void LayoutTable::InvalidateCollapsedBorders() {
   collapsed_borders_.clear();
   collapsed_borders_valid_ = false;
   needs_invalidate_collapsed_borders_for_all_cells_ = true;
+  collapsed_outer_borders_valid_ = false;
   SetMayNeedPaintInvalidation();
 }
 
 void LayoutTable::InvalidateCollapsedBordersForAllCellsIfNeeded() {
   DCHECK(ShouldCollapseBorders());
 
   if (!needs_invalidate_collapsed_borders_for_all_cells_)
     return;
   needs_invalidate_collapsed_borders_for_all_cells_ = false;
 
@@ skipping 31 matching lines @@
            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 (ShouldCollapseBorders()) {
     LayoutUnit right_border_overflow =
-        Size().Width() + OuterBorderRight() - BorderRight();
-    LayoutUnit left_border_overflow = BorderLeft() - OuterBorderLeft();
+        Size().Width() + CollapsedOuterBorderRight() - BorderRight();
+    LayoutUnit left_border_overflow = BorderLeft() - CollapsedOuterBorderLeft();
     LayoutUnit bottom_border_overflow =
-        Size().Height() + OuterBorderBottom() - BorderBottom();
-    LayoutUnit top_border_overflow = BorderTop() - OuterBorderTop();
+        Size().Height() + CollapsedOuterBorderBottom() - BorderBottom();
+    LayoutUnit top_border_overflow = BorderTop() - CollapsedOuterBorderTop();
     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());
     if (border_overflow_rect != PixelSnappedBorderBoxRect()) {
       LayoutRect border_layout_rect(border_overflow_rect);
       AddLayoutOverflow(border_layout_rect);
       AddContentsVisualOverflow(border_layout_rect);
     }
-  }
+  }*/
+  // TODO: Add a test.
 
   // Add overflow from our caption.
   for (unsigned i = 0; i < captions_.size(); i++)
     AddOverflowFromChild(*captions_[i]);
 
   // Add overflow from our sections.
   for (LayoutTableSection* section = TopSection(); section;
        section = SectionBelow(section))
     AddOverflowFromChild(*section);
 }
@@ skipping 41 matching lines @@
 }
 
 void LayoutTable::PaintMask(const PaintInfo& paint_info,
                             const LayoutPoint& paint_offset) const {
   TablePainter(*this).PaintMask(paint_info, paint_offset);
 }
 
 void LayoutTable::ComputeIntrinsicLogicalWidths(LayoutUnit& min_width,
                                                 LayoutUnit& max_width) const {
   RecalcSectionsIfNeeded();
-  // FIXME: Do the recalc in borderStart/borderEnd and make those const_cast
-  // this call.
-  // Then m_borderStart/m_borderEnd will be transparent a cache and it removes
-  // the possibility of reading out stale values.
-  const_cast<LayoutTable*>(this)->RecalcBordersInRowDirection();
   // FIXME: Restructure the table layout code so that we can make this method
   // const.
   const_cast<LayoutTable*>(this)->table_layout_->ComputeIntrinsicLogicalWidths(
       min_width, max_width);
 
   // FIXME: We should include captions widths here like we do in
   // computePreferredLogicalWidths.
 }
 
 void LayoutTable::ComputePreferredLogicalWidths() {
@@ skipping 48 matching lines @@
   ClearPreferredLogicalWidthsDirty();
 }
 
 LayoutTableSection* LayoutTable::TopNonEmptySection() const {
   LayoutTableSection* section = TopSection();
   if (section && !section->NumRows())
     section = SectionBelow(section, kSkipEmptySections);
   return section;
 }
 
+LayoutTableSection* LayoutTable::BottomNonEmptySection() const {
+  LayoutTableSection* section = BottomSection();
+  if (section && !section->NumRows())
+    section = SectionAbove(section, kSkipEmptySections);
+  return section;
+}
+
 void LayoutTable::SplitEffectiveColumn(unsigned index, unsigned first_span) {
   // We split the column at |index|, taking |firstSpan| cells from the span.
   DCHECK_GT(effective_columns_[index].span, first_span);
   effective_columns_.insert(index, first_span);
   effective_columns_[index + 1].span -= first_span;
 
   // Propagate the change in our columns representation to the sections that
   // don't need cell recalc. If they do, they will be synced up directly with
   // m_columns later.
   for (LayoutObject* child = FirstChild(); child;
@@ skipping 171 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 (!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();
-  if (table_start_border.Style() == kBorderStyleHidden)
-    return 0;
-  if (table_start_border.Style() > kBorderStyleHidden)
-    border_width = table_start_border.Width();
-
-  // TODO(dgrogan): This logic doesn't properly account for the first column in
-  // the first column-group case.
-  if (LayoutTableCol* column =
-          ColElementAtEffectiveColumn(0).InnermostColOrColGroup()) {
-    // FIXME: We don't account for direction on columns and column groups.
-    const BorderValue& column_adjoining_border = column->Style()->BorderStart();
-    if (column_adjoining_border.Style() == kBorderStyleHidden)
-      return 0;
-    if (column_adjoining_border.Style() > kBorderStyleHidden)
-      border_width =
-          std::max<int>(border_width, column_adjoining_border.Width());
-  }
-
-  if (const LayoutTableSection* top_non_empty_section =
-          this->TopNonEmptySection()) {
-    const BorderValue& section_adjoining_border =
-        top_non_empty_section->BorderAdjoiningTableStart();
-    if (section_adjoining_border.Style() == kBorderStyleHidden)
-      return 0;
-
-    if (section_adjoining_border.Style() > kBorderStyleHidden)
-      border_width =
-          std::max<int>(border_width, section_adjoining_border.Width());
-
-    if (const LayoutTableCell* adjoining_start_cell =
-            top_non_empty_section->FirstRowCellAdjoiningTableStart()) {
-      // FIXME: Make this work with perpendicular and flipped cells.
-      const BorderValue& start_cell_adjoining_border =
-          adjoining_start_cell->BorderAdjoiningTableStart();
-      if (start_cell_adjoining_border.Style() == kBorderStyleHidden)
-        return 0;
-
-      const BorderValue& first_row_adjoining_border =
-          adjoining_start_cell->Row()->BorderAdjoiningTableStart();
-      if (first_row_adjoining_border.Style() == kBorderStyleHidden)
-        return 0;
-
-      if (start_cell_adjoining_border.Style() > kBorderStyleHidden) {
-        border_width =
-            std::max<int>(border_width, start_cell_adjoining_border.Width());
-      }
-      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 (!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();
-  if (table_end_border.Style() == kBorderStyleHidden)
-    return 0;
-  if (table_end_border.Style() > kBorderStyleHidden)
-    border_width = table_end_border.Width();
-
-  unsigned end_column = NumEffectiveColumns() - 1;
-
-  // TODO(dgrogan): This logic doesn't properly account for the last column in
-  // the last column-group case.
-  if (LayoutTableCol* column =
-          ColElementAtEffectiveColumn(end_column).InnermostColOrColGroup()) {
-    // FIXME: We don't account for direction on columns and column groups.
-    const BorderValue& column_adjoining_border = column->Style()->BorderEnd();
-    if (column_adjoining_border.Style() == kBorderStyleHidden)
-      return 0;
-    if (column_adjoining_border.Style() > kBorderStyleHidden)
-      border_width =
-          std::max<int>(border_width, column_adjoining_border.Width());
-  }
-
-  if (const LayoutTableSection* top_non_empty_section =
-          this->TopNonEmptySection()) {
-    const BorderValue& section_adjoining_border =
-        top_non_empty_section->BorderAdjoiningTableEnd();
-    if (section_adjoining_border.Style() == kBorderStyleHidden)
-      return 0;
-
-    if (section_adjoining_border.Style() > kBorderStyleHidden)
-      border_width =
-          std::max<int>(border_width, section_adjoining_border.Width());
-
-    if (const LayoutTableCell* adjoining_end_cell =
-            top_non_empty_section->FirstRowCellAdjoiningTableEnd()) {
-      // FIXME: Make this work with perpendicular and flipped cells.
-      const BorderValue& end_cell_adjoining_border =
-          adjoining_end_cell->BorderAdjoiningTableEnd();
-      if (end_cell_adjoining_border.Style() == kBorderStyleHidden)
-        return 0;
-
-      const BorderValue& first_row_adjoining_border =
-          adjoining_end_cell->Row()->BorderAdjoiningTableEnd();
-      if (first_row_adjoining_border.Style() == kBorderStyleHidden)
-        return 0;
-
-      if (end_cell_adjoining_border.Style() > kBorderStyleHidden) {
-        border_width =
-            std::max<int>(border_width, end_cell_adjoining_border.Width());
-      }
-      if (first_row_adjoining_border.Style() > kBorderStyleHidden) {
-        border_width =
-            std::max<int>(border_width, first_row_adjoining_border.Width());
-      }
-    }
-  }
-  return (border_width + (Style()->IsLeftToRightDirection() ? 1 : 0)) / 2;
-}
-
-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 (ShouldCollapseBorders()) {
-    RecalcSectionsIfNeeded();
-    return LayoutUnit(OuterBorderBefore());
+    UpdateCollapsedOuterBorders();
+    return LayoutUnit(collapsed_outer_border_before_);
   }
   return LayoutBlock::BorderBefore();
 }
 
 LayoutUnit LayoutTable::BorderAfter() const {
   if (ShouldCollapseBorders()) {
-    RecalcSectionsIfNeeded();
-    return LayoutUnit(OuterBorderAfter());
+    UpdateCollapsedOuterBorders();
+    return LayoutUnit(collapsed_outer_border_after_);
   }
   return LayoutBlock::BorderAfter();
 }
 
-int LayoutTable::OuterBorderBefore() const {
-  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
+LayoutUnit LayoutTable::BorderStart() const {
+  if (ShouldCollapseBorders()) {
+    UpdateCollapsedOuterBorders();
+    return LayoutUnit(collapsed_outer_border_start_);
   }
-  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;
+  return LayoutBlock::BorderStart();
 }
 
-int LayoutTable::OuterBorderAfter() const {
-  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
+LayoutUnit LayoutTable::BorderEnd() const {
+  if (ShouldCollapseBorders()) {
+    UpdateCollapsedOuterBorders();
+    return LayoutUnit(collapsed_outer_border_end_);
   }
-  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 (!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 (!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;
-
-  bool all_hidden = true;
-  for (LayoutTableSection* section = TopSection(); section;
-       section = SectionBelow(section)) {
-    int sw = section->OuterBorderEnd();
-    if (sw < 0)
-      continue;
-    all_hidden = false;
-    border_width = std::max(border_width, sw);
-  }
-  if (all_hidden)
-    return 0;
-
-  return border_width;
+  return LayoutBlock::BorderEnd();
 }
 
 LayoutTableSection* LayoutTable::SectionAbove(
     const LayoutTableSection* section,
     SkipEmptySectionsValue skip_empty_sections) const {
   RecalcSectionsIfNeeded();
 
   if (section == head_)
     return 0;
 
@@ skipping 311 matching lines @@
   return LayoutBlock::PaddingLeft();
 }
 
 LayoutUnit LayoutTable::PaddingRight() const {
   if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingRight();
 }
 
+unsigned LayoutTable::ComputeCollapsedOuterBorderBefore() const {
+  DCHECK(ShouldCollapseBorders());
+
+  const auto* section = TopNonEmptySection();
+  if (!section)
+    return 0;
+
+  unsigned n_cols = section->NumEffectiveColumns(0);
+  unsigned result = 0;
+  for (unsigned col = 0; col < n_cols; ++col) {
+    if (const auto* cell = section->PrimaryCellAt(0, col))
+      result = std::max(result, cell->CollapsedOuterBorderBefore());
+  }
+  return result;
+}
+
+unsigned LayoutTable::ComputeCollapsedOuterBorderAfter() const {
+  DCHECK(ShouldCollapseBorders());
+
+  const auto* section = BottomNonEmptySection();
+  if (!section)
+    return 0;
+
+  unsigned row = section->NumRows() - 1;
+  unsigned n_cols = section->NumEffectiveColumns(row);
+  unsigned result = 0;
+  for (unsigned col = 0; col < n_cols; ++col) {
+    if (const auto* cell = section->PrimaryCellAt(row, col))
+      result = std::max(result, cell->CollapsedOuterBorderAfter());
+  }
+  return result;
+}
+
+unsigned LayoutTable::ComputeCollapsedOuterBorderStart() const {
+  DCHECK(ShouldCollapseBorders());
+
+  unsigned result = 0;
+  for (const auto* section = TopNonEmptySection(); section;
+       section = SectionBelow(section, kSkipEmptySections)) {
+    for (unsigned row = 0; row < section->NumRows(); ++row) {
+      if (const auto* cell = section->PrimaryCellAt(row, 0))
+        result = std::max(result, cell->CollapsedOuterBorderStart());
+    }
+  }
+  return result;
+}
+
+unsigned LayoutTable::ComputeCollapsedOuterBorderEnd() const {
+  DCHECK(ShouldCollapseBorders());
+
+  unsigned n_cols = NumEffectiveColumns();
+  if (!n_cols)
+    return 0;
+
+  unsigned result = 0;
+  for (const auto* section = TopNonEmptySection(); section;
+       section = SectionBelow(section, kSkipEmptySections)) {
+    for (unsigned row = 0; row < section->NumRows(); ++row) {
+      if (const auto* cell = section->PrimaryCellAt(row, n_cols - 1))
+        result = std::max(result, cell->CollapsedOuterBorderEnd());
+    }
+  }
+  return result;
+}
+
+void LayoutTable::UpdateCollapsedOuterBorders() const {
+  if (collapsed_outer_borders_valid_)
+    return;
+
+  collapsed_outer_borders_valid_ = true;
+  if (ShouldCollapseBorders()) {
+    collapsed_outer_border_before_ = ComputeCollapsedOuterBorderBefore();
+    collapsed_outer_border_after_ = ComputeCollapsedOuterBorderAfter();
+    collapsed_outer_border_start_ = ComputeCollapsedOuterBorderStart();
+    collapsed_outer_border_end_ = ComputeCollapsedOuterBorderEnd();
+  }
+}
+
 }  // namespace blink