Repeat footers in paginated context

third_party/WebKit/Source/core/layout/LayoutTable.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, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 51 matching lines @@
       needs_section_recalc_(false),
       column_logical_width_changed_(false),
       column_layout_objects_valid_(false),
       no_cell_colspan_at_least_(0),
       h_spacing_(0),
       v_spacing_(0),
       border_start_(0),
       border_end_(0) {
   DCHECK(!ChildrenInline());
   effective_column_positions_.Fill(0, 1);
+  position_of_repeating_footer_group_on_page_.Fill(LayoutUnit(), 1);

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

Seems unnecessary if we're not paginating.

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

I'm not sure I can zap this and rebuild it each time I layout the table, because
I won't necessarily lay out each section. So this is why I allocate it here and
grow it as/if necessary. Seems like the simplest approach and not too expensive.

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

How about moving initialization to LayoutTableSection::UpdateLayout() or
something? You already populate the vector from LayoutTableSection. Probably a
good idea to shrink the vector size to fit when done with layout too, so that we
don't keep unused memory around.

 }
 
 LayoutTable::~LayoutTable() {}
 
 void LayoutTable::StyleDidChange(StyleDifference diff,
                                  const ComputedStyle* old_style) {
   LayoutBlock::StyleDidChange(diff, old_style);
 
   bool old_fixed_table_layout =
       old_style ? old_style->IsFixedTableLayout() : false;
@@ skipping 564 matching lines @@
     }
     LayoutUnit current_available_logical_height =
         AvailableLogicalHeight(kIncludeMarginBorderPadding);
     TableHeightChangingValue table_height_changing =
         old_available_logical_height_ && old_available_logical_height_ !=
                                              current_available_logical_height
             ? kTableHeightChanging
             : kTableHeightNotChanging;
     old_available_logical_height_ = current_available_logical_height;
 
+    // Lay out table footer to get its raw height. This will help us decide
+    // if we can repeat it in each page/column.

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

I must say that I'm still a bit concerned about this. We're performing layout
before knowing the position. But maybe it's okay. Having break-inside:avoid,
we're only going to break inside this section if it's taller than the height of
one page, or if there are forced breaks inside. That would disqualify it from
becoming repeated, I suppose, since its logical height will be taller than that
of one page.

Since I cannot think of anything in particular that could go wrong, I suppose I
just have to hold my peace. :)

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

Great. :)

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

But, while I think it's safe, could you please remark in the comment that we're
actually laying out objects out-of-order here?

+    if (LayoutTableSection* section = Footer()) {
+      if (section->GetPaginationBreakability() != kAllowAnyBreaks) {
+        section->LayoutIfNeeded();
+        int section_logical_height = section->CalcRowLogicalHeight();
+        section->SetLogicalHeight(LayoutUnit(section_logical_height));
+      }
+    }
+
     // Lay out table header group.
     if (LayoutTableSection* section = Header()) {
       LayoutSection(*section, layouter, section_logical_left,
                     table_height_changing);
       if (state.IsPaginated()) {
         // If the repeating header group allows at least one row of content,
         // then store the offset for other sections to offset their rows
         // against.
-        LayoutUnit section_logical_height = section->LogicalHeight();
-        if (section_logical_height <
-                section->PageLogicalHeightForOffset(section->LogicalTop()) &&
-            section->GetPaginationBreakability() != kAllowAnyBreaks) {
+        if (section->IsRepeatingHeaderGroup()) {
           // Don't include any strut in the header group - we only want the
           // height from its content.
-          LayoutUnit offset_for_table_headers = section_logical_height;
+          LayoutUnit offset_for_table_headers = section->LogicalHeight();
           if (LayoutTableRow* row = section->FirstRow())
             offset_for_table_headers -= row->PaginationStrut();
           SetRowOffsetFromRepeatingHeader(offset_for_table_headers);
         }
       }
     }
 
     // Lay out table body groups, and column groups.
     for (LayoutObject* child = FirstChild(); child;
          child = child->NextSibling()) {
@@ skipping 181 matching lines @@
   for (LayoutTableSection* section = TopSection(); section;
        section = SectionBelow(section))
     AddOverflowFromChild(*section);
 }
 
 void LayoutTable::PaintObject(const PaintInfo& paint_info,
                               const LayoutPoint& paint_offset) const {
   TablePainter(*this).PaintObject(paint_info, paint_offset);
 }
 
-void LayoutTable::SubtractCaptionRect(LayoutRect& rect) const {
+void LayoutTable::SubtractCaptionRect(LayoutRect& rect, bool after_only) const {
   for (unsigned i = 0; i < captions_.size(); i++) {
     LayoutUnit caption_logical_height = captions_[i]->LogicalHeight() +
                                         captions_[i]->MarginBefore() +
                                         captions_[i]->MarginAfter();
     bool caption_is_before =
         (captions_[i]->Style()->CaptionSide() != ECaptionSide::kBottom) ^
         Style()->IsFlippedBlocksWritingMode();
+    if (caption_is_before && after_only)
+      continue;
     if (Style()->IsHorizontalWritingMode()) {
       rect.SetHeight(rect.Height() - caption_logical_height);
       if (caption_is_before)
         rect.Move(LayoutUnit(), caption_logical_height);
     } else {
       rect.SetWidth(rect.Width() - caption_logical_height);
       if (caption_is_before)
         rect.Move(caption_logical_height, LayoutUnit());
     }
   }
@@ skipping 870 matching lines @@
 }
 
 LayoutUnit LayoutTable::PaddingRight() const {
   if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingRight();
 }
 
 }  // namespace blink