No need to force relayout of children when page logical height changes.

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 260 matching lines @@
 bool LayoutBlockFlow::updateLogicalWidthAndColumnWidth() {
   bool relayoutChildren = LayoutBlock::updateLogicalWidthAndColumnWidth();
   if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
     if (flowThread->needsNewWidth())
       return true;
   }
   return relayoutChildren;
 }
 
 void LayoutBlockFlow::checkForPaginationLogicalHeightChange(
-    LayoutUnit& pageLogicalHeight,
-    bool& pageLogicalHeightChanged,
-    bool& hasSpecifiedPageLogicalHeight) {
+    LayoutUnit& pageLogicalHeight) {
   if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
     // Calculate the non-auto content box height, or set it to 0 if it's auto.
     // We need to know this before layout, so that we can figure out where to
     // insert column breaks. We also treat LayoutView (which may be paginated,
     // which uses the multicol implmentation) as having non-auto height, since
     // its height is deduced from the viewport height.
     // We use computeLogicalHeight() to calculate the content box height. That
     // method will clamp against max-height and min-height. Since we're now at
     // the beginning of layout, and we don't know the actual height of the
     // content yet, only call that method when height is definite, or we might
     // fool ourselves into believing that columns have a definite height when
     // they in fact don't.
     LayoutUnit columnHeight;
     if (hasDefiniteLogicalHeight() || isLayoutView()) {
       LogicalExtentComputedValues computedValues;
       computeLogicalHeight(LayoutUnit(), logicalTop(), computedValues);
       columnHeight = computedValues.m_extent - borderAndPaddingLogicalHeight() -
                      scrollbarLogicalHeight();
     }
-    pageLogicalHeightChanged =
-        columnHeight != flowThread->columnHeightAvailable();
     flowThread->setColumnHeightAvailable(std::max(columnHeight, LayoutUnit()));
   } else if (isLayoutFlowThread()) {
     LayoutFlowThread* flowThread = toLayoutFlowThread(this);
 
     // FIXME: This is a hack to always make sure we have a page logical height,
     // if said height is known. The page logical height thing in LayoutState is
     // meaningless for flow thread-based pagination (page height isn't
     // necessarily uniform throughout the flow thread), but as long as it is
     // used universally as a means to determine whether page height is known or
     // not, we need this. Page height is unknown when column balancing is
     // enabled and flow thread height is still unknown (i.e. during the first
     // layout pass). When it's unknown, we need to prevent the pagination code
     // from assuming page breaks everywhere and thereby eating every top margin.
     // It should be trivial to clean up and get rid of this hack once the old
     // multicol implementation is gone.
     pageLogicalHeight =
         flowThread->isPageLogicalHeightKnown() ? LayoutUnit(1) : LayoutUnit();
-
-    pageLogicalHeightChanged = flowThread->pageLogicalSizeChanged();
   }
 }
 
 void LayoutBlockFlow::setBreakAtLineToAvoidWidow(int lineToBreak) {
   ASSERT(lineToBreak >= 0);
   ensureRareData();
   ASSERT(!m_rareData->m_didBreakAtLineToAvoidWidow);
   m_rareData->m_lineBreakToAvoidWidow = lineToBreak;
 }
 
@@ skipping 134 matching lines @@
 DISABLE_CFI_PERF
 inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
                                              LayoutUnit& pageLogicalHeight,
                                              SubtreeLayoutScope& layoutScope) {
   LayoutUnit oldLeft = logicalLeft();
   bool logicalWidthChanged = updateLogicalWidthAndColumnWidth();
   relayoutChildren |= logicalWidthChanged;
 
   rebuildFloatsFromIntruding();
 
-  bool pageLogicalHeightChanged = false;
-  bool hasSpecifiedPageLogicalHeight = false;
-  checkForPaginationLogicalHeightChange(pageLogicalHeight,
-                                        pageLogicalHeightChanged,
-                                        hasSpecifiedPageLogicalHeight);
-  if (pageLogicalHeightChanged)
-    relayoutChildren = true;
+  checkForPaginationLogicalHeightChange(pageLogicalHeight);
 
   LayoutState state(*this, pageLogicalHeight, logicalWidthChanged);
 
   if (m_paginationStateChanged) {
     // We now need a deep layout to clean up struts after pagination, if we
     // just ceased to be paginated, or, if we just became paginated on the
     // other hand, we now need the deep layout, to insert pagination struts.
     m_paginationStateChanged = false;
     state.setPaginationStateChanged();
   }
@@ skipping 4062 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink