Update our treatment of repeating headers in tables

third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1112 matching lines @@
   //
   // FIXME: Another problem with simply moving lines is that the available line
   // width may change (because of floats). Technically if the location we move
   // the line to has a different line width than our old position, then we need
   // to dirty the line and all following lines.
   LayoutUnit logical_offset = line_box.LineTopWithLeading();
   LayoutUnit line_height = line_box.LineBottomWithLeading() - logical_offset;
   logical_offset += delta;
   line_box.SetPaginationStrut(LayoutUnit());
   line_box.SetIsFirstAfterPageBreak(false);
-  if (!View()->GetLayoutState()->IsPaginated())
+  LayoutState* layout_state = View()->GetLayoutState();
+  if (!layout_state->IsPaginated())
     return;
   LayoutUnit page_logical_height = PageLogicalHeightForOffset(logical_offset);
   if (!page_logical_height)
     return;
   LayoutUnit remaining_logical_height = PageRemainingLogicalHeightForOffset(
       logical_offset, kAssociateWithLatterPage);
   int line_index = LineCount(&line_box);
   if (remaining_logical_height < line_height ||
       (ShouldBreakAtLineToAvoidWidow() &&
        LineBreakToAvoidWidow() == line_index)) {
@@ skipping 17 matching lines @@
     // We need to insert a break now, either because there's no room for the
     // line in the current column / page, or because we have determined that we
     // need a break to satisfy widow requirements.
     if (ShouldBreakAtLineToAvoidWidow() &&
         LineBreakToAvoidWidow() == line_index) {
       ClearShouldBreakAtLineToAvoidWidow();
       SetDidBreakAtLineToAvoidWidow();
     }
     if (ShouldSetStrutOnBlock(*this, line_box, logical_offset, line_index,
                               page_logical_height)) {
+      DCHECK(!IsTableCell());
+      pagination_strut += layout_state->HeightOffsetForTableHeaders();

[mstensho (USE GERRIT), 2017/05/29 10:22:00]

I was actually expecting this one to go away, now that
CalculatePaginationStrutToFitContent() always adds in this.

       // Note that when setting the strut on a block, it may be propagated to
       // parent blocks later on, if a block's logical top is flush with that of
       // its parent. We don't want content-less portions (struts) at the
       // beginning of a block before a break, if it can be avoided. After all,
       // that's the reason for setting struts on blocks and not lines in the
       // first place.
       SetPaginationStrutPropagatedFromChild(pagination_strut + logical_offset);
     } else {
       delta += pagination_strut;
       line_box.SetPaginationStrut(pagination_strut);
       line_box.SetIsFirstAfterPageBreak(true);
     }
     PaginatedContentWasLaidOut(new_logical_offset + line_height);
     return;
   }
 
   LayoutUnit strut_to_propagate;
   if (remaining_logical_height == page_logical_height) {
     // We're at the very top of a page or column.
     if (line_box != FirstRootBox())
       line_box.SetIsFirstAfterPageBreak(true);
     // If this is the first line in the block, and the block has a top border or
     // padding, we may want to set a strut on the block, so that everything ends
     // up in the next column or page. Setting a strut on the block is also
     // important when it comes to satisfying orphan requirements.
     if (ShouldSetStrutOnBlock(*this, line_box, logical_offset, line_index,
-                              page_logical_height))
-      strut_to_propagate = logical_offset;
+                              page_logical_height)) {
+      DCHECK(!IsTableCell());
+      strut_to_propagate =
+          logical_offset + layout_state->HeightOffsetForTableHeaders();

[mstensho (USE GERRIT), 2017/05/29 10:22:00]

This one we need to keep, though, since CalculatePaginationStrutToFitContent()
isn't used.

+    }
   } else if (line_box == FirstRootBox() && AllowsPaginationStrut()) {
     // This is the first line in the block. The block may still start in the
     // previous column or page, and if that's the case, attempt to pull it over
     // to where this line is, so that we don't split the top border or padding.
     LayoutUnit strut =

[mstensho (USE GERRIT), 2017/05/29 10:22:00]

How about here? Looks like we're going to end up pushing the block to the very
top of some fragmentainer, overlapping any repeated table header.

         remaining_logical_height + logical_offset - page_logical_height;
     if (strut > LayoutUnit()) {
       // The block starts in a previous column or page. Set a strut on the block
       // if there's room for the top border, padding and the line in one column
       // or page.
       if (logical_offset + line_height <= page_logical_height)
         strut_to_propagate = strut;
     }
   }
 
@@ skipping 3482 matching lines @@
   return LayoutBlock::DeprecatedInvalidatePaint(paint_invalidation_state);
 }
 
 void LayoutBlockFlow::InvalidateDisplayItemClients(
     PaintInvalidationReason invalidation_reason) const {
   BlockFlowPaintInvalidator(*this).InvalidateDisplayItemClients(
       invalidation_reason);
 }
 
 }  // namespace blink