Formatting contexts should always expand to enclose floats

Source/core/layout/FloatingObjects.cpp

Index: Source/core/layout/FloatingObjects.cpp
diff --git a/Source/core/layout/FloatingObjects.cpp b/Source/core/layout/FloatingObjects.cpp
index e66ab9afcd87c414ec3412e2c6eba190166a192e..530c3572c75db9d32a356804954fac91dc0f0883 100644
--- a/Source/core/layout/FloatingObjects.cpp
+++ b/Source/core/layout/FloatingObjects.cpp
@@ -51,6 +51,7 @@ FloatingObject::FloatingObject(LayoutBox* layoutObject)
 #if ENABLE(ASSERT)
     , m_isInPlacedTree(false)
 #endif
+    , m_isLowestNonOverhangingFloatInChild(false)
 {
     EFloat type = layoutObject->style()->floating();
     ASSERT(type != NoFloat);
@@ -60,7 +61,7 @@ FloatingObject::FloatingObject(LayoutBox* layoutObject)
         m_type = FloatRight;
 }
 
-FloatingObject::FloatingObject(LayoutBox* layoutObject, Type type, const LayoutRect& frameRect, bool shouldPaint, bool isDescendant)
+FloatingObject::FloatingObject(LayoutBox* layoutObject, Type type, const LayoutRect& frameRect, bool shouldPaint, bool isDescendant, bool isLowestNonOverhangingFloatInChild)
     : m_layoutObject(layoutObject)
     , m_originatingLine(0)
     , m_frameRect(frameRect)
@@ -72,6 +73,7 @@ FloatingObject::FloatingObject(LayoutBox* layoutObject, Type type, const LayoutR
 #if ENABLE(ASSERT)
     , m_isInPlacedTree(false)
 #endif
+    , m_isLowestNonOverhangingFloatInChild(isLowestNonOverhangingFloatInChild)
 {
 }
 
@@ -86,12 +88,12 @@ PassOwnPtr<FloatingObject> FloatingObject::create(LayoutBox* layoutObject)
 
 PassOwnPtr<FloatingObject> FloatingObject::copyToNewContainer(LayoutSize offset, bool shouldPaint, bool isDescendant) const
 {
-    return adoptPtr(new FloatingObject(layoutObject(), type(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant));
+    return adoptPtr(new FloatingObject(layoutObject(), type(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant, isLowestNonOverhangingFloatInChild()));
 }
 
 PassOwnPtr<FloatingObject> FloatingObject::unsafeClone() const
 {
-    OwnPtr<FloatingObject> cloneObject = adoptPtr(new FloatingObject(layoutObject(), type(), m_frameRect, m_shouldPaint, m_isDescendant));
+    OwnPtr<FloatingObject> cloneObject = adoptPtr(new FloatingObject(layoutObject(), type(), m_frameRect, m_shouldPaint, m_isDescendant, false));
     cloneObject->m_paginationStrut = m_paginationStrut;
     cloneObject->m_isPlaced = m_isPlaced;
     return cloneObject.release();
@@ -180,6 +182,7 @@ FloatingObjects::FloatingObjects(const LayoutBlockFlow* layoutObject, bool horiz
     , m_horizontalWritingMode(horizontalWritingMode)
     , m_layoutObject(layoutObject)
     , m_cachedHorizontalWritingMode(false)
+    , m_lowestFloatObject(nullptr)
 {
 }
 
@@ -190,6 +193,7 @@ void FloatingObjects::clear()
     m_leftObjectsCount = 0;
     m_rightObjectsCount = 0;
     markLowestFloatLogicalBottomCacheAsDirty();
+    m_lowestFloatObject = nullptr;
 }
 
 LayoutUnit FloatingObjects::lowestFloatLogicalBottom(FloatingObject::Type floatType)
@@ -207,15 +211,19 @@ LayoutUnit FloatingObjects::lowestFloatLogicalBottom(FloatingObject::Type floatT
 
     LayoutUnit lowestFloatBottom = 0;
     const FloatingObjectSet& floatingObjectSet = set();
+    FloatingObject* lowestFloatObject = nullptr;
     FloatingObjectSetIterator end = floatingObjectSet.end();
     if (floatType == FloatingObject::FloatLeftRight) {
         LayoutUnit lowestFloatBottomLeft = 0;
         LayoutUnit lowestFloatBottomRight = 0;
+        FloatingObject* floatingObject = nullptr;
         for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
-            FloatingObject* floatingObject = it->get();
+            floatingObject = it->get();
             if (floatingObject->isPlaced()) {
                 FloatingObject::Type curType = floatingObject->type();
                 LayoutUnit curFloatLogicalBottom = m_layoutObject->logicalBottomForFloat(floatingObject);
+                if (curFloatLogicalBottom > std::max(lowestFloatBottomLeft, lowestFloatBottomRight))
+                    lowestFloatObject = floatingObject;
                 if (curType & FloatingObject::FloatLeft)
                     lowestFloatBottomLeft = std::max(lowestFloatBottomLeft, curFloatLogicalBottom);
                 if (curType & FloatingObject::FloatRight)
@@ -223,14 +231,20 @@ LayoutUnit FloatingObjects::lowestFloatLogicalBottom(FloatingObject::Type floatT
             }
         }
         lowestFloatBottom = std::max(lowestFloatBottomLeft, lowestFloatBottomRight);
+        setLowestFloatObject(lowestFloatObject);
         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, FloatingObject::FloatLeft, lowestFloatBottomLeft);
         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, FloatingObject::FloatRight, lowestFloatBottomRight);
     } else {
+        FloatingObject* floatingObject = nullptr;
         for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
-            FloatingObject* floatingObject = it->get();
-            if (floatingObject->isPlaced() && floatingObject->type() == floatType)
+            floatingObject = it->get();
+            if (floatingObject->isPlaced() && floatingObject->type() == floatType) {
+                if (m_layoutObject->logicalBottomForFloat(floatingObject) > lowestFloatBottom)
+                    lowestFloatObject = floatingObject;
                 lowestFloatBottom = std::max(lowestFloatBottom, m_layoutObject->logicalBottomForFloat(floatingObject));
+            }
         }
+        setLowestFloatObject(lowestFloatObject);
         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, floatType, lowestFloatBottom);
     }