Repeat footers in paginated context

third_party/WebKit/Source/core/layout/LayoutTableSection.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, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 1236 matching lines @@
   if (row->GetPaginationBreakability() == kAllowAnyBreaks)
     return 0;
   LayoutUnit page_logical_height = PageLogicalHeightForOffset(logical_offset);
   if (!page_logical_height)
     return 0;
   // If the row is too tall for the page don't insert a strut.
   LayoutUnit row_logical_height = row->LogicalHeight();
   if (row_logical_height > page_logical_height)
     return 0;
 
+  LayoutTableSection* footer = Table()->Footer();

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

This one can be const, I guess?

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

Done.

+  bool footer_wants_to_repeat =

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

make_room_for_repeating_footer?

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

Done.

+      footer && footer != this &&
+      footer->IsRepeatingFooterGroup(const_cast<LayoutTableSection*>(this)) &&

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

Ugh. But is there really any reason not to let the parameter be const?
IsRepeatingFooterGroup() only seems to call PageLogicalHeightForOffset() and
LogicalTop() on the object passed.

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

Done.

+      row->RowIndex();
+  if (footer_wants_to_repeat)
+    row_logical_height += footer->LogicalHeight();
+
   LayoutUnit remaining_logical_height = PageRemainingLogicalHeightForOffset(
       logical_offset, LayoutBlock::kAssociateWithLatterPage);
   if (remaining_logical_height >= row_logical_height)
     return 0;  // It fits fine where it is. No need to break.
   LayoutUnit pagination_strut = CalculatePaginationStrutToFitContent(
       logical_offset, remaining_logical_height, row_logical_height);
   if (pagination_strut == remaining_logical_height &&
       remaining_logical_height == page_logical_height) {
     // Don't break if we were at the top of a page, and we failed to fit the
     // content completely. No point in leaving a page completely blank.
     return 0;
   }
+

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

Back out this?

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

Done.

   // Table layout parts only work on integers, so we have to round. Round up, to
   // make sure that no fraction ever gets left behind in the previous
   // fragmentainer.
   return pagination_strut.Ceil();
 }
 
 void LayoutTableSection::ComputeOverflowFromCells() {
   unsigned total_rows = grid_.size();
   unsigned n_eff_cols = Table()->NumEffectiveColumns();
   ComputeOverflowFromCells(total_rows, n_eff_cols);
@@ skipping 777 matching lines @@
   }
   return logical_height;
 }
 
 void LayoutTableSection::AdjustRowForPagination(LayoutTableRow& row_object,
                                                 SubtreeLayoutScope& layouter) {
   row_object.SetPaginationStrut(LayoutUnit());
   row_object.SetLogicalHeight(LayoutUnit(LogicalHeightForRow(row_object)));
   int pagination_strut =
       PaginationStrutForRow(&row_object, row_object.LogicalTop());
+  LayoutTableSection* footer = Table()->Footer();

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

Can you push it a few lines down, next to where it's actually used?

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

Done.

   bool row_is_at_top_of_column = false;
   LayoutUnit offset_from_top_of_page;
   if (!pagination_strut) {
     LayoutUnit page_logical_height =
         PageLogicalHeightForOffset(row_object.LogicalTop());
     if (page_logical_height && Table()->Header() && Table()->Header() != this &&
         Table()->RowOffsetFromRepeatingHeader()) {
       offset_from_top_of_page =
           page_logical_height -
           PageRemainingLogicalHeightForOffset(row_object.LogicalTop(),
@@ skipping 13 matching lines @@
 
   LayoutTableSection* header = Table()->Header();
   if (row_object.IsFirstRowInSectionAfterHeader())
     Table()->SetRowOffsetFromRepeatingHeader(LayoutUnit());
   // Border spacing from the previous row has pushed this row just past the top
   // of the page, so we must reposition it to the top of the page and avoid any
   // repeating header.
   if (row_is_at_top_of_column && offset_from_top_of_page)
     pagination_strut -= offset_from_top_of_page.ToInt();
 
+  if (footer && footer != this && header != this &&

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

If the header isn't repeating, there should be no reason to exclude it here?

Also, it seems kind of harder than necessary to exercise this code. You either
need a repeating header to help, or table rows with break-inside:avoid. If
there's neither, we don't get repeated footers.

Consider this:

I'd expect the footer to be repeated here:

<!DOCTYPE html>
<p>There should be a blue <em>square</em> below.</p>
<div style="columns:2; width:20px; column-gap:0; column-fill:auto; height:90px;
line-height:20px;">
    <table style="width:100%;" cellspacing="0" cellpadding="0">
        <tbody>
            <tr>
                <td><br></td>
            </tr>
            <tr>
                <td><br></td>
            </tr>
            <tr>
                <td><br></td>
            </tr>
            <tr>
                <td><br></td>
            </tr>
            <tr>
                <td><br></td>
            </tr>
            <tr>
                <td><br></td>
            </tr>
        </tbody>
        <tfoot style="break-inside:avoid;">
            <tr>
                <td style="background:blue;">
                    <br>
                </td>
            </tr>
        </tfoot>
    </table>
</div>

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

Done.

+      footer->IsRepeatingFooterGroup(this)) {
+    DCHECK(PageLogicalHeightForOffset(LayoutUnit()));
+    LayoutUnit offset_from_top = LogicalTop() + row_object.LogicalTop();
+    unsigned page =
+        FloorToInt(offset_from_top / PageLogicalHeightForOffset(LayoutUnit()));

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

To cope with non-uniform page heights, you should consider passing the correct
offset to PageLogicalHeightForOffset().

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

Done.

+    LayoutUnit remaining_logical_height = PageRemainingLogicalHeightForOffset(
+        row_object.LogicalTop(), LayoutBlock::kAssociateWithLatterPage);

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

LayoutBlock:: scope should be unnecessary. This one is defined in LayoutBox.

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

Done.

+    if (remaining_logical_height >=
+        (footer->LogicalHeight() - Table()->VBorderSpacing()))
+      Table()->SetPositionOfRepeatingFooterGroupOnPage(page, offset_from_top);
+  }
+
   // If we have a header group we will paint it at the top of each page,
   // move the rows down to accomodate it.
   if (header && header != this)
     pagination_strut += Table()->RowOffsetFromRepeatingHeader().ToInt();
   row_object.SetPaginationStrut(LayoutUnit(pagination_strut));
 
   // We have inserted a pagination strut before the row. Adjust the logical top
   // and re-lay out. We no longer want to break inside the row, but rather
   // *before* it. From the previous layout pass, there are most likely
   // pagination struts inside some cell in this row that we need to get rid of.
   row_object.SetLogicalTop(row_object.LogicalTop() + pagination_strut);
   layouter.SetChildNeedsLayout(&row_object);
   row_object.LayoutIfNeeded();
 
   // It's very likely that re-laying out (and nuking pagination struts inside
   // cells) gave us a new height.
   row_object.SetLogicalHeight(LayoutUnit(LogicalHeightForRow(row_object)));
 }
 
-bool LayoutTableSection::IsRepeatingHeaderGroup() const {
-  if (GetPaginationBreakability() == LayoutBox::kAllowAnyBreaks)
+bool LayoutTableSection::IsRepeatingFooterGroup(

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

This belongs AFTER IsRepeatingHeaderGroup().

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

Done.

+    LayoutTableSection* section_for_page) const {
+  if (GetPaginationBreakability() == kAllowAnyBreaks)
     return false;
-  // TODO(rhogan): Should we paint a header repeatedly if it's self-painting?
+
+  // TODO(rhogan): Sections can be self-painting.

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

Can you tell me how they can be self-painting?

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

Yes, if you put an opacity: 0.5 on them for example. See
fast/table/backgr_layers-opacity.html for example.

[mstensho (USE GERRIT), 2017/05/10 10:59:03]

Ah, thanks!

   if (HasSelfPaintingLayer())
     return false;
-  LayoutUnit page_height = Table()->PageLogicalHeightForOffset(LayoutUnit());
+
+  LayoutUnit page_height = section_for_page
+                               ? section_for_page->PageLogicalHeightForOffset(

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

This is to avoid assertion failures and the bugs that follow? (since you can't
call PageLogicalHeightForOffset() for any other object than the one you're
currently laying out)

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

Correct.

+                                     section_for_page->LogicalTop())
+                               : PageLogicalHeightForOffset(LogicalTop());
   if (!page_height)
     return false;
 
-  if (LogicalHeight() > page_height)
+  if (LogicalHeight() > 0 && page_height / LogicalHeight() < 4)

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

The code looks fine, but I'd like a comment that mumbles something about about
25%...

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

Done.

     return false;
 
-  // If the first row of the section after the header group doesn't fit on the
-  // page, then don't repeat the header on each page.
-  // See https://drafts.csswg.org/css-tables-3/#repeated-headers
+  return true;
+}
+
+bool LayoutTableSection::IsRepeatingHeaderGroup() const {
+  if (GetPaginationBreakability() == kAllowAnyBreaks)
+    return false;
+
+  // TODO(rhogan): Sections can be self-painting.
+  if (HasSelfPaintingLayer())
+    return false;
+
+  LayoutUnit page_height = PageLogicalHeightForOffset(LogicalTop());
+  if (!page_height)
+    return false;
+
+  if (LogicalHeight() > 0 && page_height / LogicalHeight() < 4)

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

The code looks fine, but I'd like a comment that mumbles something about 25%...

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

Done.

+    return false;
+
+  // TODO(crbug.com/710387): If the first row of the section after the header
+  // group doesn't fit on the page, then we don't repeat the header on each page
+  // and by extension only support repeating headers on the innermost table in a
+  // set of nested tables.
   LayoutTableSection* section_below = Table()->SectionBelow(this);
   if (!section_below)
     return true;
   if (LayoutTableRow* first_row = section_below->FirstRow()) {
     if (first_row->PaginationStrut() ||
         first_row->LogicalHeight() > page_height)
       return false;
   }
 
   return true;
 }
 
 bool LayoutTableSection::MapToVisualRectInAncestorSpaceInternal(
     const LayoutBoxModelObject* ancestor,
     TransformState& transform_state,
     VisualRectFlags flags) const {
   if (ancestor == this)
     return true;
-  // Repeating table headers are painted once per fragmentation page/column.
-  // This does not go through the regular fragmentation machinery, so we need
-  // special code to expand the invalidation rect to contain all positions of
-  // the header in all columns.
-  // Note that this is in flow thread coordinates, not visual coordinates. The
-  // enclosing LayoutFlowThread will convert to visual coordinates.
-  if (Table()->Header() == this && IsRepeatingHeaderGroup()) {
+
+  // Repeating table headers and footers are painted once per fragmentation
+  // page/column. This does not go through the regular fragmentation machinery,
+  // so we need special code to expand the invalidation rect to contain all
+  // positions of the header in all columns. Note that this is in flow thread
+  // coordinates, not visual coordinates. The enclosing LayoutFlowThread will
+  // convert to visual coordinates.
+  if ((Table()->Header() == this && IsRepeatingHeaderGroup()) ||
+      (Table()->Footer() == this && IsRepeatingFooterGroup())) {
     transform_state.Flatten();
     FloatRect rect = transform_state.LastPlanarQuad().BoundingBox();
     rect.SetHeight(Table()->LogicalHeight());
     transform_state.SetQuad(FloatQuad(rect));
+    return Table()->MapToVisualRectInAncestorSpaceInternal(

[mstensho (USE GERRIT), 2017/05/08 13:55:59]

How can we just skip one ancestor in the chain like this and ignore the location
of the table section?

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

I've updated the comment to explain this. For both headers and footers we really
need to return the table quads because the headers/footers are painted
throughout it. That's what this achieves. The alternative would be to dive
further into LayoutBox::MapToVisualRectInAncestorSpaceInternal and special case
repeating footers to make sure the top/left and top/right points are at least
above the first place we paint a footer. This wouldn't be the top of the table
obviously, so the quads we come up with here are overgenerous for sure.

+        ancestor, transform_state, flags);
   }
   return LayoutTableBoxComponent::MapToVisualRectInAncestorSpaceInternal(
       ancestor, transform_state, flags);
 }
 
 bool LayoutTableSection::PaintedOutputOfObjectHasNoEffectRegardlessOfSize()
     const {
   // LayoutTableSection paints background from columns.
   if (Table()->HasColElements())
     return false;
   return LayoutTableBoxComponent::
       PaintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink