Formatting contexts should always expand to enclose floats

Source/core/layout/FloatingObjects.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 30 matching lines @@
 
 static_assert(sizeof(FloatingObject) == sizeof(SameSizeAsFloatingObject), "FloatingObject should stay small");
 
 FloatingObject::FloatingObject(LayoutBox* layoutObject)
     : m_layoutObject(layoutObject)
     , m_originatingLine(0)
     , m_paginationStrut(0)
     , m_shouldPaint(true)
     , m_isDescendant(false)
     , m_isPlaced(false)
+    , m_isLowestNonOverhangingFloatInChild(false)
 #if ENABLE(ASSERT)
     , m_isInPlacedTree(false)
 #endif
 {
     EFloat type = layoutObject->style()->floating();
     ASSERT(type != NoFloat);
     if (type == LeftFloat)
         m_type = FloatLeft;
     else if (type == RightFloat)
         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)
     , m_paginationStrut(0)
     , m_type(type)
     , m_shouldPaint(shouldPaint)
     , m_isDescendant(isDescendant)
     , m_isPlaced(true)
+    , m_isLowestNonOverhangingFloatInChild(isLowestNonOverhangingFloatInChild)
 #if ENABLE(ASSERT)
     , m_isInPlacedTree(false)
 #endif
 {
 }
 
 PassOwnPtr<FloatingObject> FloatingObject::create(LayoutBox* layoutObject)
 {
     OwnPtr<FloatingObject> newObj = adoptPtr(new FloatingObject(layoutObject));
     newObj->setShouldPaint(!layoutObject->hasSelfPaintingLayer()); // If a layer exists, the float will paint itself. Otherwise someone else will.
     newObj->setIsDescendant(true);
 
     return newObj.release();
 }
 
 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();
 }
 
 template <FloatingObject::Type FloatTypeValue>
 class ComputeFloatOffsetAdapter {
 public:
     typedef FloatingObjectInterval IntervalType;
 
@@ skipping 68 matching lines @@
     }
 }
 
 FloatingObjects::FloatingObjects(const LayoutBlockFlow* layoutObject, bool horizontalWritingMode)
     : m_placedFloatsTree(UninitializedTree)
     , m_leftObjectsCount(0)
     , m_rightObjectsCount(0)
     , m_horizontalWritingMode(horizontalWritingMode)
     , m_layoutObject(layoutObject)
     , m_cachedHorizontalWritingMode(false)
+    , m_lowestFloatingObject(nullptr)
 {
 }
 
 void FloatingObjects::clear()
 {
     m_set.clear();
     m_placedFloatsTree.clear();
     m_leftObjectsCount = 0;
     m_rightObjectsCount = 0;
     markLowestFloatLogicalBottomCacheAsDirty();
+    m_lowestFloatingObject = nullptr;
 }
 
 LayoutUnit FloatingObjects::lowestFloatLogicalBottom(FloatingObject::Type floatType)
 {
     bool isInHorizontalWritingMode = m_horizontalWritingMode;
     if (floatType != FloatingObject::FloatLeftRight) {
         if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, floatType))
             return getCachedlowestFloatLogicalBottom(floatType);
     } else {
         if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatLeft) && hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatRight)) {
             return std::max(getCachedlowestFloatLogicalBottom(FloatingObject::FloatLeft),
                 getCachedlowestFloatLogicalBottom(FloatingObject::FloatRight));
         }
     }
 
     LayoutUnit lowestFloatBottom = 0;
     const FloatingObjectSet& floatingObjectSet = set();
+    FloatingObject* lowestFloatingObject = 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))
+                    lowestFloatingObject = floatingObject;
                 if (curType & FloatingObject::FloatLeft)
                     lowestFloatBottomLeft = std::max(lowestFloatBottomLeft, curFloatLogicalBottom);
                 if (curType & FloatingObject::FloatRight)
                     lowestFloatBottomRight = std::max(lowestFloatBottomRight, curFloatLogicalBottom);
             }
         }
         lowestFloatBottom = std::max(lowestFloatBottomLeft, lowestFloatBottomRight);
         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)
+                    lowestFloatingObject = floatingObject;
                 lowestFloatBottom = std::max(lowestFloatBottom, m_layoutObject->logicalBottomForFloat(floatingObject));
+            }
         }
         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, floatType, lowestFloatBottom);
     }
 
+    setLowestFloatingObject(lowestFloatingObject);
     return lowestFloatBottom;
 }
 
 bool FloatingObjects::hasLowestFloatLogicalBottomCached(bool isHorizontal, FloatingObject::Type type) const
 {
     int floatIndex = static_cast<int>(type) - 1;
     ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) / sizeof(FloatBottomCachedValue)));
     ASSERT(floatIndex >= 0);
     return (m_cachedHorizontalWritingMode == isHorizontal && !m_lowestFloatBottomCache[floatIndex].dirty);
 }
@@ skipping 279 matching lines @@
 }
 
 String ValueToString<FloatingObject*>::string(const FloatingObject* floatingObject)
 {
     return String::format("%p (%dx%d %dx%d)", floatingObject, floatingObject->frameRect().pixelSnappedX(), floatingObject->frameRect().pixelSnappedY(), floatingObject->frameRect().pixelSnappedMaxX(), floatingObject->frameRect().pixelSnappedMaxY());
 }
 #endif
 
 
 } // namespace blink