Repeat footers in paginated context

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 first_row_offset;

[mstensho (USE GERRIT), 2017/05/08 13:56:00]

Could you make "pagination" or at least "strut" part of that variable name?

What does this have to do with repeated footers (this CL), BTW?

[rhogan, 2017/05/09 19:57:17]

This isn't necessary anymore for some reason. ¯\_(ツ)_/¯

   if (LayoutTableRow* row = layout_table_section_.FirstRow())
-    header_group_offset += row->PaginationStrut();
+    first_row_offset = row->PaginationStrut();
+  header_group_offset += first_row_offset;
   LayoutUnit offset_to_next_page =
       page_height - IntMod(header_group_offset, page_height);
-  // Move paginationOffset to the top of the next page.
+  // Move pagination_offset 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.
+  // Now move pagination_offset 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);
+               paint_offset.Y() - first_row_offset + total_height_of_rows);
 
   while (pagination_offset.Y() < bottom_bound) {
     if (item_to_paint == kPaintCollapsedBorders) {
       PaintCollapsedSectionBorders(paint_info, pagination_offset,
                                    current_border_value);
     } else {
       PaintSection(paint_info, pagination_offset);
     }
     pagination_offset.Move(0, page_height.ToInt());
   }
 }
 
+void TableSectionPainter::PaintRepeatingFooterGroup(
+    const PaintInfo& paint_info,
+    const LayoutPoint& paint_offset,
+    const CollapsedBorderValue& current_border_value,
+    ItemToPaint item_to_paint) {
+  if (!layout_table_section_.IsRepeatingFooterGroup())
+    return;
+  LayoutTable* table = layout_table_section_.Table();
+  LayoutRect sections_rect(LayoutPoint(), table->Size());
+  // Include the top captions as we need top_offset to be

[mstensho (USE GERRIT), 2017/05/08 13:56:00]

Include, as in exclude from subtraction? How about "Keep"? :)

OK, I think I want something other than bool to express this.

How about enum class CaptionSelector { TopCaptionsOnly, BottomCaptionsOnly,
AllCaptions } (should probably remove TopCaptionsOnly, though, since it's not
used)

[rhogan, 2017/05/09 19:57:17]

Done.

+  // the offset from the top of table.
+  table->SubtractCaptionRect(sections_rect, true);
+  LayoutUnit total_height_of_rows =
+      sections_rect.Height() - table->OuterBorderBottom();
+  // The footer section may be at the top of a page.
+  total_height_of_rows -= (layout_table_section_.LogicalHeight() -
+                           layout_table_section_.FirstRow()->PaginationStrut());
+  LayoutPoint top_offset = paint_offset;
+  top_offset.Move(0, -total_height_of_rows.ToInt());
+  IntRect cull_rect = paint_info.GetCullRect().rect_;
+  cull_rect.Move(0, -total_height_of_rows.ToInt());
+  for (unsigned page = 0;
+       page < table->PositionOfRepeatingFooterGroupOnPage().size(); page++) {
+    LayoutPoint pagination_offset = top_offset;
+    int footer_position =
+        table->GetPositionOfRepeatingFooterGroupOnPage(page).ToInt();

[mstensho (USE GERRIT), 2017/05/08 13:56:00]

Since the whole vector has already been made accessible via
table->PositionOfRepeatingFooterGroupOnPage() anyway, why not use it directly?
Alternatively, maybe remove PositionOfRepeatingFooterGroupOnPage(), and add
whatever functionality is required to encapsulate the vector completely.

[rhogan, 2017/05/09 19:57:17]

Done.

+    if (!footer_position)

[mstensho (USE GERRIT), 2017/05/08 13:56:00]

When is it 0?

[rhogan, 2017/05/09 19:57:17]

We don't repeat the footer on every page. For example it might not fit on the
first page, e.g.
fragmentation/single-line-cells-repeating-thead-tfoot-starts-middle-of-page-break-after-avoid.html

+      continue;
+    pagination_offset.Move(0, footer_position);
+    if (item_to_paint == kPaintCollapsedBorders) {
+      PaintCollapsedSectionBorders(paint_info, pagination_offset,
+                                   current_border_value);
+    } else {
+      PaintSection(paint_info, pagination_offset);
+    }
+  }
+}
+
 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);
   LayoutTable* table = layout_table_section_.Table();
-  if (table->Header() == layout_table_section_)
+  if (table->Header() == layout_table_section_) {
     PaintRepeatingHeaderGroup(paint_info, paint_offset, CollapsedBorderValue(),
                               kPaintSection);
+  } else if (table->Footer() == layout_table_section_) {
+    PaintRepeatingFooterGroup(paint_info, paint_offset, CollapsedBorderValue(),
+                              kPaintSection);
+  }
 }
 
 void TableSectionPainter::PaintSection(const PaintInfo& paint_info,
                                        const LayoutPoint& paint_offset) {
   DCHECK(!layout_table_section_.NeedsLayout());
   // avoid crashing on bugs that cause us to paint with dirty layout
   if (layout_table_section_.NeedsLayout())
     return;
 
   unsigned total_rows = layout_table_section_.NumRows();
@@ skipping 34 matching lines @@
 
   return elem1->AbsoluteColumnIndex() < elem2->AbsoluteColumnIndex();
 }
 
 void TableSectionPainter::PaintCollapsedBorders(
     const PaintInfo& paint_info,
     const LayoutPoint& paint_offset,
     const CollapsedBorderValue& current_border_value) {
   PaintCollapsedSectionBorders(paint_info, paint_offset, current_border_value);
   LayoutTable* table = layout_table_section_.Table();
-  if (table->Header() == layout_table_section_)
+  if (table->Header() == layout_table_section_) {
     PaintRepeatingHeaderGroup(paint_info, paint_offset, current_border_value,
                               kPaintCollapsedBorders);
+  } else if (table->Footer() == layout_table_section_) {
+    PaintRepeatingFooterGroup(paint_info, paint_offset, current_border_value,
+                              kPaintCollapsedBorders);
+  }
 }
 
 void TableSectionPainter::PaintCollapsedSectionBorders(
     const PaintInfo& paint_info,
     const LayoutPoint& paint_offset,
     const CollapsedBorderValue& current_border_value) {
   if (!layout_table_section_.NumRows() ||
       !layout_table_section_.Table()->EffectiveColumns().size())
     return;
 
@@ skipping 248 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