Let table row and section's self visual overflow cover whole 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 391 matching lines @@
 LayoutSize LayoutTableCell::OffsetFromContainer(const LayoutObject* o) const {
   DCHECK_EQ(o, Container());
 
   LayoutSize offset = LayoutBlockFlow::OffsetFromContainer(o);
   if (Parent())
     offset -= ParentBox()->PhysicalLocationOffset();
 
   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()->ShouldCollapseBorders() || Table()->NeedsSectionRecalc())
-    return LayoutBlockFlow::LocalVisualRect();
+void LayoutTableCell::ComputeOverflow(LayoutUnit old_client_after_edge,
+                                      bool recompute_floats) {
+  LayoutBlockFlow::ComputeOverflow(old_client_after_edge, recompute_floats);
 
+  UpdateCollapsedBorderValues();
+  if (!collapsed_border_values_)
+    return;
+
+  // Calculate local visual rect of collapsed borders.
+  // Our border rect already includes the inner halves of the collapsed borders,
+  // so here we get the outer halves.
   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));
+  LayoutUnit left = CollapsedBorderHalfLeft(true);
+  LayoutUnit right = CollapsedBorderHalfRight(true);
+  LayoutUnit top = CollapsedBorderHalfTop(true);
+  LayoutUnit bottom = CollapsedBorderHalfBottom(true);
+
+  // This cell's borders may be lengthened to match the widths of orthogonal
+  // borders of adjacent cells. Expand visual overflow to cover the lengthened
+  // parts.
   if ((left && !rtl) || (right && rtl)) {
     if (LayoutTableCell* before = Table()->CellBefore(this)) {
       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->CollapsedBorderHalfTop(true));
       bottom = std::max(bottom, after->CollapsedBorderHalfBottom(true));
     }
   }
   if (top) {
     if (LayoutTableCell* above = Table()->CellAbove(this)) {
       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->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()),
-                    location.Y() + std::max(Size().Height() + bottom,
-                                            self_visual_overflow_rect.MaxY()));
+  LayoutRect rect = BorderBoxRect();
+  rect.ExpandEdges(top, right, bottom, left);
+  collapsed_border_values_->SetLocalVisualRect(rect);
+}
+
+LayoutRect LayoutTableCell::LocalVisualRect() const {
+  LayoutRect rect = SelfVisualOverflowRect();
+  if (collapsed_border_values_)
+    rect.Unite(collapsed_border_values_->LocalVisualRect());
+  return rect;
 }
 
 int LayoutTableCell::CellBaselinePosition() const {
   // <http://www.w3.org/TR/2007/CR-CSS21-20070719/tables.html#height-layout>:
   // The baseline of a cell is the baseline of the first in-flow line box in the
   // cell, or the first in-flow table-row in the cell, whichever comes first. If
   // there is no such line box or table-row, the baseline is the bottom of
   // content edge of the cell box.
   int first_line_baseline = FirstLineBoxBaseline();
   if (first_line_baseline != -1)
@@ skipping 784 matching lines @@
   }
   return LayoutUnit();
 }
 
 void LayoutTableCell::Paint(const PaintInfo& paint_info,
                             const LayoutPoint& paint_offset) const {
   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()->ShouldCollapseBorders()) {
     if (collapsed_border_values_) {
       collapsed_borders_visually_changed_ = true;
       collapsed_border_values_ = nullptr;
     }
     return;
   }
 
+  Table()->InvalidateCollapsedBordersForAllCellsIfNeeded();
+  if (collapsed_border_values_valid_)
+    return;
+
+  collapsed_border_values_valid_ = true;
+
   CollapsedBorderValues new_values(
       *this, ComputeCollapsedStartBorder(), ComputeCollapsedEndBorder(),
       ComputeCollapsedBeforeBorder(), ComputeCollapsedAfterBorder());
 
   // We need to save collapsed border if has a non-zero width even if it's
   // invisible because the width affects table layout.
   if (!new_values.StartBorder().Width() && !new_values.EndBorder().Width() &&
       !new_values.BeforeBorder().Width() && !new_values.AfterBorder().Width()) {
     if (collapsed_border_values_) {
       collapsed_borders_visually_changed_ = true;
@@ skipping 188 matching lines @@
 
   return LayoutBlock::HasLineIfEmpty();
 }
 
 PaintInvalidationReason LayoutTableCell::InvalidatePaint(
     const PaintInvalidatorContext& context) const {
   return TableCellPaintInvalidator(*this, context).InvalidatePaint();
 }
 
 }  // namespace blink