No longer store page logical height in LayoutState.

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 259 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) {
-  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();
-    }
-    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();
-  }
-}
-
 void LayoutBlockFlow::setBreakAtLineToAvoidWidow(int lineToBreak) {
   ASSERT(lineToBreak >= 0);
   ensureRareData();
   ASSERT(!m_rareData->m_didBreakAtLineToAvoidWidow);
   m_rareData->m_lineBreakToAvoidWidow = lineToBreak;
 }
 
 void LayoutBlockFlow::setDidBreakAtLineToAvoidWidow() {
   ASSERT(!shouldBreakAtLineToAvoidWidow());
 
@@ skipping 106 matching lines @@
 
   if (!relayoutChildren && simplifiedLayout())
     return;
 
   LayoutAnalyzer::BlockScope analyzer(*this);
   SubtreeLayoutScope layoutScope(*this);
 
   // Multiple passes might be required for column based layout.
   // The number of passes could be as high as the number of columns.
   bool done = false;
-  LayoutUnit pageLogicalHeight;
   while (!done)
-    done = layoutBlockFlow(relayoutChildren, pageLogicalHeight, layoutScope);
+    done = layoutBlockFlow(relayoutChildren, layoutScope);
 
   updateLayerTransformAfterLayout();
 
   updateAfterLayout();
 
   if (isHTMLDialogElement(node()) && isOutOfFlowPositioned())
     positionDialog();
 
   clearNeedsLayout();
   updateIsSelfCollapsing();
 }
 
 DISABLE_CFI_PERF
 inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
-                                             LayoutUnit& pageLogicalHeight,
                                              SubtreeLayoutScope& layoutScope) {
   LayoutUnit oldLeft = logicalLeft();
   bool logicalWidthChanged = updateLogicalWidthAndColumnWidth();
   relayoutChildren |= logicalWidthChanged;
 
   rebuildFloatsFromIntruding();
 
-  checkForPaginationLogicalHeightChange(pageLogicalHeight);
-
-  LayoutState state(*this, pageLogicalHeight, logicalWidthChanged);
+  LayoutState state(*this, 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();
   }
 
   // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg,
@@ skipping 52 matching lines @@
     layoutBlockChildren(relayoutChildren, layoutScope, beforeEdge, afterEdge);
 
   bool preferredLogicalWidthsBecameDirty =
       !preferredLogicalWidthsWereDirty && preferredLogicalWidthsDirty();
   if (preferredLogicalWidthsBecameDirty) {
     // The only thing that should dirty preferred widths at this point is the
     // addition of overflow:auto scrollbars in a descendant. To avoid a
     // potential infinite loop, run layout again with auto scrollbars frozen in
     // their current state.
     PaintLayerScrollableArea::FreezeScrollbarsScope freezeScrollbars;
-    return layoutBlockFlow(relayoutChildren, pageLogicalHeight, layoutScope);
+    return layoutBlockFlow(relayoutChildren, layoutScope);
   }
 
   // Expand our intrinsic height to encompass floats.
   if (lowestFloatLogicalBottom() > (logicalHeight() - afterEdge) &&
       createsNewFormattingContext())
     setLogicalHeight(lowestFloatLogicalBottom() + afterEdge);
 
   if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
     if (flowThread->columnHeightsChanged()) {
       setChildNeedsLayout(MarkOnlyThis);
@@ skipping 3980 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink