Floats on an empty line should still get positioned.

Source/core/layout/LayoutBlockFlowLine.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 728 matching lines @@
     BidiStatus cleanLineBidiStatus;
     if (!layoutState.isFullLayout() && startLine)
         determineEndPosition(layoutState, startLine, cleanLineStart, cleanLineBidiStatus);
 
     if (startLine) {
         if (!layoutState.usesPaintInvalidationBounds())
             layoutState.setPaintInvalidationRange(logicalHeight());
         deleteLineRange(layoutState, startLine);
     }
 
-    if (!layoutState.isFullLayout() && lastRootBox() && lastRootBox()->endsWithBreak()) {
-        // If the last line before the start line ends with a line break that clear floats,
-        // adjust the height accordingly.
-        // A line break can be either the first or the last object on a line, depending on its direction.
-        if (InlineBox* lastLeafChild = lastRootBox()->lastLeafChild()) {
-            LayoutObject* lastObject = &lastLeafChild->layoutObject();
-            if (!lastObject->isBR())
-                lastObject = &lastRootBox()->firstLeafChild()->layoutObject();
-            if (lastObject->isBR()) {
-                EClear clear = lastObject->style()->clear();
-                if (clear != CNONE)
-                    clearFloats(clear);
-            }
-        }
-    }
-
     layoutRunsAndFloatsInRange(layoutState, resolver, cleanLineStart, cleanLineBidiStatus);
     linkToEndLineIfNeeded(layoutState);
     markDirtyFloatsForPaintInvalidation(layoutState.floats());
 }
 
 // Before restarting the layout loop with a new logicalHeight, remove all floats that were added and reset the resolver.
 inline const InlineIterator& LayoutBlockFlow::restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight,  FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver& resolver,  const InlineIterator& oldEnd)
 {
     removeFloatingObjectsBelow(lastFloatFromPreviousLine, oldLogicalHeight);
     setLogicalHeight(newLogicalHeight);
@@ skipping 106 matching lines @@
                         }
                     }
                 }
             }
         }
 
         if (!logicalWidthIsAvailable) {
             for (size_t i = 0; i < lineBreaker.positionedObjects().size(); ++i)
                 setStaticPositions(this, lineBreaker.positionedObjects()[i]);
 
-            if (!layoutState.lineInfo().isEmpty()) {
+            if (!layoutState.lineInfo().isEmpty())
                 layoutState.lineInfo().setFirstLine(false);
-                clearFloats(lineBreaker.clear());
-            }
+            clearFloats(lineBreaker.clear());
 
             if (m_floatingObjects && lastRootBox()) {
                 const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
                 FloatingObjectSetIterator it = floatingObjectSet.begin();
                 FloatingObjectSetIterator end = floatingObjectSet.end();
                 if (layoutState.lastFloat()) {
                     FloatingObjectSetIterator lastFloatIterator = floatingObjectSet.find(layoutState.lastFloat());
                     ASSERT(lastFloatIterator != end);
                     ++lastFloatIterator;
                     it = lastFloatIterator;
@@ skipping 734 matching lines @@
             dirtiedByFloat = true;
         }
         floatIndex++;
     }
 }
 
 RootInlineBox* LayoutBlockFlow::determineStartPosition(LineLayoutState& layoutState, InlineBidiResolver& resolver)
 {
     RootInlineBox* curr = nullptr;
     RootInlineBox* last = nullptr;
+    RootInlineBox* firstLineBoxWithBreakAndClearance = 0;
 
     // FIXME: This entire float-checking block needs to be broken into a new function.
     bool dirtiedByFloat = false;
     if (!layoutState.isFullLayout()) {
         // Paginate all of the clean lines.
         bool paginated = view()->layoutState() && view()->layoutState()->isPaginated();
         LayoutUnit paginationDelta = 0;
         size_t floatIndex = 0;
         for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
             if (paginated) {
                 paginationDelta -= curr->paginationStrut();
                 adjustLinePositionForPagination(*curr, paginationDelta, layoutState.flowThread());
                 if (paginationDelta) {
                     if (containsFloats() || !layoutState.floats().isEmpty()) {
                         // FIXME: Do better eventually.  For now if we ever shift because of pagination and floats are present just go to a full layout.
                         layoutState.markForFullLayout();
                         break;
                     }
 
                     layoutState.updatePaintInvalidationRangeFromBox(curr, paginationDelta);
                     curr->adjustBlockDirectionPosition(paginationDelta.toFloat());
                 }
             }
 
+            // If the linebox breaks cleanly and with clearance then dirty from at least this point onwards so that we can clear the correct floats without difficulty.
+            if (!firstLineBoxWithBreakAndClearance && curr->endsWithBreak()) {
+                InlineBox* lastBox = style()->isLeftToRightDirection() ? curr->lastLeafChild() : curr->firstLeafChild();
+                if (lastBox && lastBox->layoutObject().isBR() && lastBox->layoutObject().style()->clear() != CNONE)
+                    firstLineBoxWithBreakAndClearance = curr;
+            }
+
             // If a new float has been inserted before this line or before its last known float, just do a full layout.
             bool encounteredNewFloat = false;
             checkFloatsInCleanLine(curr, layoutState.floats(), floatIndex, encounteredNewFloat, dirtiedByFloat);
             if (encounteredNewFloat)
                 layoutState.markForFullLayout();
 
             if (dirtiedByFloat || layoutState.isFullLayout())
                 break;
         }
         // Check if a new float has been inserted after the last known float.
         if (!curr && floatIndex < layoutState.floats().size())
             layoutState.markForFullLayout();
     }
 
     if (layoutState.isFullLayout()) {
         // If we encountered a new float and have inline children, mark ourself to force us to issue paint invalidations.
         if (layoutState.hasInlineChild() && !selfNeedsLayout()) {
             setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::FloatDescendantChanged, MarkOnlyThis);
             setShouldDoFullPaintInvalidation();
         }
 
         deleteLineBoxTree();
         curr = nullptr;
         ASSERT(!firstLineBox() && !lastLineBox());
     } else {
+        if (firstLineBoxWithBreakAndClearance)
+            curr = firstLineBoxWithBreakAndClearance;
         if (curr) {
             // We have a dirty line.
             if (RootInlineBox* prevRootBox = curr->prevRootBox()) {
                 // We have a previous line.
                 if (!dirtiedByFloat && (!prevRootBox->endsWithBreak() || !prevRootBox->lineBreakObj() || (prevRootBox->lineBreakObj()->isText() && prevRootBox->lineBreakPos() >= toLayoutText(prevRootBox->lineBreakObj())->textLength()))) {
                     // The previous line didn't break cleanly or broke at a newline
                     // that has been deleted, so treat it as dirty too.
                     curr = prevRootBox;
                 }
             }
@@ skipping 359 matching lines @@
     LayoutUnit logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false);
     LayoutUnit availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }