Update our treatment of repeating headers in tables

third_party/WebKit/Source/core/paint/TableSectionPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/TableSectionPainter.h"
 
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/paint/BoxClipper.h"
@@ skipping 15 matching lines @@
   if (!layout_table_section_.IsRepeatingHeaderGroup())
     return;
 
   LayoutTable* table = layout_table_section_.Table();
   LayoutPoint pagination_offset = paint_offset;
   LayoutUnit page_height = table->PageLogicalHeightForOffset(LayoutUnit());
 
   LayoutUnit header_group_offset = table->BlockOffsetToFirstRepeatableHeader();
   // The header may have a pagination strut before it so we need to account for
   // that when establishing its position.
+  LayoutUnit strut_on_first_row;
   if (LayoutTableRow* row = layout_table_section_.FirstRow())
-    header_group_offset += row->PaginationStrut();
+    strut_on_first_row = row->PaginationStrut();
+  header_group_offset += strut_on_first_row;
   LayoutUnit offset_to_next_page =
       page_height - IntMod(header_group_offset, page_height);
   // Move paginationOffset to the top of the next page.
   pagination_offset.Move(LayoutUnit(), offset_to_next_page);
   // Now move paginationOffset to the top of the page the cull rect starts on.
   if (paint_info.GetCullRect().rect_.Y() > pagination_offset.Y()) {
     pagination_offset.Move(LayoutUnit(),
                            page_height * ((paint_info.GetCullRect().rect_.Y() -
                                            pagination_offset.Y()) /
                                           page_height)
                                              .ToInt());
   }
 
   // We only want to consider pages where we going to paint a row, so exclude
   // captions and border spacing from the table.
   LayoutRect sections_rect(LayoutPoint(), table->Size());
   table->SubtractCaptionRect(sections_rect);
   LayoutUnit total_height_of_rows =
       sections_rect.Height() - table->VBorderSpacing();
   LayoutUnit bottom_bound =
       std::min(LayoutUnit(paint_info.GetCullRect().rect_.MaxY()),
                paint_offset.Y() + total_height_of_rows);
 
   while (pagination_offset.Y() < bottom_bound) {
+    LayoutPoint nested_offset =
+        pagination_offset +
+        LayoutPoint(LayoutUnit(), table->RowOffsetFromRepeatingHeader() -

[mstensho (USE GERRIT), 2017/05/22 10:40:44]

If we really want to re-introduce nesting:

Thanks to the current coding style, I think this would look prettier if you
instead did this as part of a separate LayoutPoint::Move(LayoutUnit, LayoutUnit)
step. Maybe even a separate LayoutUnit declaration step for the y thing.

[rhogan, 2017/05/22 18:06:04]

Done.

+                                      layout_table_section_.LogicalHeight() +
+                                      strut_on_first_row);
     if (item_to_paint == kPaintCollapsedBorders) {
-      PaintCollapsedSectionBorders(paint_info, pagination_offset,
+      PaintCollapsedSectionBorders(paint_info, nested_offset,
                                    current_border_value);
     } else {
-      PaintSection(paint_info, pagination_offset);
+      PaintSection(paint_info, nested_offset);
     }
     pagination_offset.Move(0, page_height.ToInt());
   }
 }
 
 void TableSectionPainter::Paint(const PaintInfo& paint_info,
                                 const LayoutPoint& paint_offset) {
   ObjectPainter(layout_table_section_)
       .CheckPaintOffset(paint_info, paint_offset);
   PaintSection(paint_info, paint_offset);
@@ skipping 296 matching lines @@
                                     const PaintInfo& paint_info_for_cells,
                                     const LayoutPoint& paint_offset) {
   if (!cell.HasSelfPaintingLayer() && !cell.Row()->HasSelfPaintingLayer()) {
     LayoutPoint cell_point =
         layout_table_section_.FlipForWritingModeForChild(&cell, paint_offset);
     cell.Paint(paint_info_for_cells, cell_point);
   }
 }
 
 }  // namespace blink