Revert of Remove some duplicated code when accounting for floats at line-end

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 884 matching lines @@
 
         if (!logicalWidthIsAvailable) {
             for (size_t i = 0; i < lineBreaker.positionedObjects().size(); ++i)
                 setStaticPositions(this, lineBreaker.positionedObjects()[i]);
 
             if (!layoutState.lineInfo().isEmpty()) {
                 layoutState.lineInfo().setFirstLine(false);
                 clearFloats(lineBreaker.clear());
             }
 
-            if (appendFloatsToEndOfLine(layoutState, true))
-                checkForEndLineMatch = false;
+            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;
+                }
+                for (; it != end; ++it) {
+                    FloatingObject* f = it->get();
+                    appendFloatingObjectToLastLine(f);
+                    ASSERT(f->layoutObject() == layoutState.floats()[layoutState.floatIndex()].object);
+                    // If a float's geometry has changed, give up on syncing with clean lines.
+                    if (layoutState.floats()[layoutState.floatIndex()].rect != f->frameRect())
+                        checkForEndLineMatch = false;
+                    layoutState.setFloatIndex(layoutState.floatIndex() + 1);
+                }
+                layoutState.setLastFloat(!floatingObjectSet.isEmpty() ? floatingObjectSet.last().get() : 0);
+            }
         }
 
         lineMidpointState.reset();
         resolver.setPosition(endOfLine, numberOfIsolateAncestors(endOfLine));
     }
 
     // In case we already adjusted the line positions during this layout to avoid widows
     // then we need to ignore the possibility of having a new widows situation.
     // Otherwise, we risk leaving empty containers which is against the block fragmentation principles.
     if (paginated && !style()->hasAutoWidows() && !didBreakAtLineToAvoidWidow()) {
@@ skipping 49 matching lines @@
 
             // We now want to break at this line. Remember for next layout and trigger relayout.
             setBreakAtLineToAvoidWidow(lineCount(lineBox));
             markLinesDirtyInBlockRange(lastRootBox()->lineBottomWithLeading(), lineBox->lineBottomWithLeading(), lineBox);
         }
     }
 
     clearDidBreakAtLineToAvoidWidow();
 }
 
-bool LayoutBlockFlow::appendFloatsToEndOfLine(LineLayoutState& layoutState, bool updateFloatIndex)
-{
-    if (!m_floatingObjects || !lastRootBox())
-        return false;
-
-    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;
-    }
-
-    bool floatChangedSize = false;
-    for (; it != end; ++it) {
-        FloatingObject* f = it->get();
-        appendFloatingObjectToLastLine(f);
-        if (updateFloatIndex) {
-            ASSERT(f->layoutObject() == layoutState.floats()[layoutState.floatIndex()].object);
-            // If a float's geometry has changed, give up on syncing with clean lines.
-            if (layoutState.floats()[layoutState.floatIndex()].rect != f->frameRect())
-                floatChangedSize = true;
-            layoutState.setFloatIndex(layoutState.floatIndex() + 1);
-        }
-    }
-    layoutState.setLastFloat(!floatingObjectSet.isEmpty() ? floatingObjectSet.last().get() : 0);
-    return floatChangedSize;
-}
-
 void LayoutBlockFlow::linkToEndLineIfNeeded(LineLayoutState& layoutState)
 {
     if (layoutState.endLine()) {
         if (layoutState.endLineMatched()) {
             bool paginated = view()->layoutState() && view()->layoutState()->isPaginated();
             // Attach all the remaining lines, and then adjust their y-positions as needed.
             LayoutUnit delta = logicalHeight() - layoutState.endLineLogicalTop();
             for (RootInlineBox* line = layoutState.endLine(); line; line = line->nextRootBox()) {
                 line->attachLine();
                 if (paginated) {
@@ skipping 14 matching lines @@
                     }
                 }
             }
             setLogicalHeight(lastRootBox()->lineBottomWithLeading());
         } else {
             // Delete all the remaining lines.
             deleteLineRange(layoutState, layoutState.endLine());
         }
     }
 
-    if (positionNewFloats())
-        appendFloatsToEndOfLine(layoutState, false);
+    if (positionNewFloats() && lastRootBox()) {
+        // In case we have a float on the last line, it might not be positioned up to now.
+        // This has to be done before adding in the bottom border/padding, or the float will
+        // include the padding incorrectly. -dwh
+        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;
+        }
+        layoutState.setLastFloat(!floatingObjectSet.isEmpty() ? floatingObjectSet.last().get() : 0);
+
+        if (it == end)
+            return;
+
+        for (; it != end; ++it)
+            appendFloatingObjectToLastLine(it->get());
+    }
 }
 
 void LayoutBlockFlow::markDirtyFloatsForPaintInvalidation(Vector<FloatWithRect>& floats)
 {
     size_t floatCount = floats.size();
     // Floats that did not have layout did not paint invalidations when we laid them out. They would have
     // painted by now if they had moved, but if they stayed at (0, 0), they still need to be
     // painted.
     for (size_t i = 0; i < floatCount; ++i) {
         if (!floats[i].everHadLayout) {
@@ skipping 973 matching lines @@
     float logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false).toFloat();
     float availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }