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 1214 matching lines @@
   }
 
   DCHECK(!NeedsLayout());
 
   SetLogicalHeight(LayoutUnit(row_pos_[total_rows]));
 
   ComputeOverflowFromCells(total_rows, Table()->NumEffectiveColumns());
 }
 
 int LayoutTableSection::PaginationStrutForRow(LayoutTableRow* row,
-                                              LayoutUnit logical_offset) const {
+                                              LayoutUnit logical_offset,
+                                              bool& can_repeat_footer) const {

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

I think calculating can_repeat_footer should be omitted from this method; it
already does enough work.

Since there's only one call site, we could just do it there, rather than
introducing a utility method for it.

   DCHECK(row);
   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();
+  bool footer_wants_to_repeat =
+      footer && footer != this &&
+      footer->GetPaginationBreakability() != kAllowAnyBreaks &&
+      Table()->RowOffsetFromRepeatingHeader() && row->RowIndex();

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

RowOffsetFromRepeatingHeader() suggests that we depend on a repeating header for
a repeating footer to work, but that can't be right, can it?

+  if (footer_wants_to_repeat) {
+    if (row_logical_height + footer->LogicalHeight() <= page_logical_height) {

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

... however, if there *is* a repeating header, we need to add in its height here
in the comparison, don't we?

+      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;
   }
+
+  if (footer && remaining_logical_height >=
+                    (footer->LogicalHeight() - Table()->VBorderSpacing()))
+    can_repeat_footer = true;
   // 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 775 matching lines @@
         MinimumValueForLength(grid_[row_index].logical_height, LayoutUnit());
     logical_height = std::max(logical_height, specified_logical_height.ToInt());
   }
   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());
+  bool can_repeat_footer = false;
+  int pagination_strut = PaginationStrutForRow(
+      &row_object, row_object.LogicalTop(), can_repeat_footer);
   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()->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();
 
+  LayoutTableSection* footer = Table()->Footer();
+  if (footer && footer != this && header != this &&
+      footer->GetPaginationBreakability() != kAllowAnyBreaks &&
+      Table()->RowOffsetFromRepeatingHeader() && can_repeat_footer) {

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

Check can_repeat_footer first.

+    unsigned page = FloorToInt((LogicalTop() + row_object.LogicalTop()) /
+                               PageLogicalHeightForOffset(LayoutUnit()));

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

PageLogicalHeightForOffset() may be 0 (initial column balancing pass), so better
check that before doing any of this.

+    Table()->SetPositionOfRepeatingFooterGroupOnPage(
+        page, LogicalTop() + row_object.LogicalTop());

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

Then again, do we really need to allow individual positions for the footer on
each page? Why not just bottom-align it (unless we're at the last page for the
table)? Edge seems to do that.

+  }
+
   // 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::IsRepeatingFooterGroup() const {
+  if (GetPaginationBreakability() == LayoutBox::kAllowAnyBreaks)

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

LayoutBox:: scope unnecessary.

+    return false;
+  // TODO(rhogan): Should we paint a header repeatedly if it's self-painting?

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

I don't think it's currently possible to have a self painting layer for a table
section. If I'm right, you might as well DCHECK.

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

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

If "page" height isn't uniform (e.g. a multicol container nested inside another
fragmentation context), you end up with incorrect heights here. Need to specify
the correct offset instead of LayoutUnit().

+  if (!page_height)
+    return false;
+  if (LogicalHeight() > page_height)
+    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
+  if (Table()->Header() && !Table()->Header()->IsRepeatingHeaderGroup())
+    return false;
+  return true;
+}
+
 bool LayoutTableSection::IsRepeatingHeaderGroup() const {
   if (GetPaginationBreakability() == LayoutBox::kAllowAnyBreaks)
     return false;
   // TODO(rhogan): Should we paint a header repeatedly if it's self-painting?
   if (HasSelfPaintingLayer())
     return false;
   LayoutUnit page_height = Table()->PageLogicalHeightForOffset(LayoutUnit());
   if (!page_height)
     return false;
 
@@ skipping 14 matching lines @@
 
   return true;
 }
 
 bool LayoutTableSection::MapToVisualRectInAncestorSpaceInternal(
     const LayoutBoxModelObject* ancestor,
     TransformState& transform_state,
     VisualRectFlags flags) const {
   if (ancestor == this)
     return true;
+
+  if (Table()->Footer() == this && IsRepeatingFooterGroup()) {
+    transform_state.Flatten();
+    FloatRect rect = transform_state.LastPlanarQuad().BoundingBox();
+    rect.SetHeight(Table()->LogicalHeight());

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

Introducing a lot of duplicated code here (shared with the code below for
repeating headers). Is there a better way?

+    transform_state.SetQuad(FloatQuad(rect));
+    bool mapped = Table()->MapToVisualRectInAncestorSpaceInternal(

[mstensho (USE GERRIT), 2017/04/24 11:57:16]

We here skip the table section, ignoring its position. Why don't we do the same
below, for repeated table headers?

+        ancestor, transform_state, flags);
+    return mapped;
+  }
+
   // 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()) {
     transform_state.Flatten();
     FloatRect rect = transform_state.LastPlanarQuad().BoundingBox();
     rect.SetHeight(Table()->LogicalHeight());
     transform_state.SetQuad(FloatQuad(rect));
   }
   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