Resurrect ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut()).

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ColumnBalancer.h"
 
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/api/LineLayoutBlockFlow.h"
 
@@ skipping 84 matching lines @@
     unsigned index = contentRunIndexWithTallestColumns();
     LayoutUnit startOffset = index > 0 ? m_contentRuns[index - 1].breakOffset() : group().logicalTopInFlowThread();
     return m_contentRuns[index].columnLogicalHeight(startOffset);
 }
 
 void InitialColumnHeightFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
         if (box.needsForcedBreakBefore(previousBreakAfterValue())) {
             addContentRun(flowThreadOffset());
-        } else if (isFirstAfterBreak(flowThreadOffset())) {
-            // This box is first after a soft break.
+        } else {
             ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
-            recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
+            if (isFirstAfterBreak(flowThreadOffset())) {
+                // This box is first after a soft break.
+                recordStrutBeforeOffset(flowThreadOffset(), box.paginationStrut());
+            }
         }
     }
 
     if (box.getPaginationBreakability() != LayoutBox::AllowAnyBreaks) {
         LayoutUnit unsplittableLogicalHeight = box.logicalHeight();
         if (box.isFloating())
             unsplittableLogicalHeight += box.marginBefore() + box.marginAfter();
         m_tallestUnbreakableLogicalHeight = std::max(m_tallestUnbreakableLogicalHeight, unsplittableLogicalHeight);
         return;
     }
@@ skipping 119 matching lines @@
 }
 
 void MinimumSpaceShortageFinder::examineBoxAfterEntering(const LayoutBox& box)
 {
     LayoutBox::PaginationBreakability breakability = box.getPaginationBreakability();
 
     // Look for breaks before the child box.
     if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {
         if (box.needsForcedBreakBefore(previousBreakAfterValue())) {
             m_forcedBreaksCount++;
-        } else if (isFirstAfterBreak(flowThreadOffset())) {
-            // This box is first after a soft break.
+        } else {
             ASSERT(isFirstAfterBreak(flowThreadOffset()) || !box.paginationStrut());
-            LayoutUnit strut = box.paginationStrut();
-            // Figure out how much more space we would need to prevent it from being pushed to the next column.
-            recordSpaceShortage(box.logicalHeight() - strut);
-            if (breakability != LayoutBox::ForbidBreaks && m_pendingStrut == LayoutUnit::min()) {
-                // We now want to look for the first piece of unbreakable content (e.g. a line or a
-                // block-displayed image) inside this block. That ought to be a good candidate for
-                // minimum space shortage; a much better one than reporting space shortage for the
-                // entire block (which we'll also do (further down), in case we couldn't find anything
-                // more suitable).
-                m_pendingStrut = strut;
+            if (isFirstAfterBreak(flowThreadOffset())) {
+                // This box is first after a soft break.
+                LayoutUnit strut = box.paginationStrut();
+                // Figure out how much more space we would need to prevent it from being pushed to the next column.
+                recordSpaceShortage(box.logicalHeight() - strut);
+                if (breakability != LayoutBox::ForbidBreaks && m_pendingStrut == LayoutUnit::min()) {
+                    // We now want to look for the first piece of unbreakable content (e.g. a line or a
+                    // block-displayed image) inside this block. That ought to be a good candidate for
+                    // minimum space shortage; a much better one than reporting space shortage for the
+                    // entire block (which we'll also do (further down), in case we couldn't find anything
+                    // more suitable).
+                    m_pendingStrut = strut;
+                }
             }
         }
     }
 
     if (breakability != LayoutBox::ForbidBreaks) {
         // See if this breakable box crosses column boundaries.
         LayoutUnit bottomInFlowThread = flowThreadOffset() + box.logicalHeight();
         if (isFirstAfterBreak(flowThreadOffset())
             || group().columnLogicalTopForOffset(flowThreadOffset()) != group().columnLogicalTopForOffset(bottomInFlowThread)) {
             // If the child crosses a column boundary, record space shortage, in case nothing
@@ skipping 46 matching lines @@
         recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight - m_pendingStrut);
         m_pendingStrut = LayoutUnit::min();
         return;
     }
     ASSERT(isFirstAfterBreak(lineTopInFlowThread) || !line.paginationStrut() || !isLogicalTopWithinBounds(lineTopInFlowThread - line.paginationStrut()));
     if (isFirstAfterBreak(lineTopInFlowThread))
         recordSpaceShortage(lineHeight - line.paginationStrut());
 }
 
 } // namespace blink