Formatting contexts should always expand to enclose floats

Source/core/layout/FloatingObjects.h

 /*
  * 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 69 matching lines @@
 
 #if ENABLE(ASSERT)
     bool isInPlacedTree() const { return m_isInPlacedTree; }
     void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
 #endif
 
     bool shouldPaint() const { return m_shouldPaint; }
     void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
     bool isDescendant() const { return m_isDescendant; }
     void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
+    bool isLowestNonOverhangingFloatInChild() const { return m_isLowestNonOverhangingFloatInChild; }
+    void setIsLowestNonOverhangingFloatInChild(bool isLowestNonOverhangingFloatInChild) { m_isLowestNonOverhangingFloatInChild = isLowestNonOverhangingFloatInChild; }
 
     // FIXME: Callers of these methods are dangerous and should be whitelisted explicitly or removed.
     RootInlineBox* originatingLine() const { return m_originatingLine; }
     void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
 
 private:
     explicit FloatingObject(LayoutBox*);
-    FloatingObject(LayoutBox*, Type, const LayoutRect&, bool shouldPaint, bool isDescendant);
+    FloatingObject(LayoutBox*, Type, const LayoutRect&, bool shouldPaint, bool isDescendant, bool isLowestNonOverhangingFloatInChild);
 
     LayoutBox* m_layoutObject;
     RootInlineBox* m_originatingLine;
     LayoutRect m_frameRect;
     int m_paginationStrut; // FIXME: Is this class size-sensitive? Does this need 32-bits?
 
     unsigned m_type : 2; // Type (left or right aligned)
     unsigned m_shouldPaint : 1;
     unsigned m_isDescendant : 1;
     unsigned m_isPlaced : 1;
 #if ENABLE(ASSERT)
     unsigned m_isInPlacedTree : 1;
 #endif
+    unsigned m_isLowestNonOverhangingFloatInChild : 1;

[leviw_travelin_and_unemployed, 2015/05/22 20:52:01]

Nit: I'd put this above the assertion-only member.

 };
 
 struct FloatingObjectHashFunctions {
     static unsigned hash(FloatingObject* key) { return DefaultHash<LayoutBox*>::Hash::hash(key->layoutObject()); }
     static unsigned hash(const OwnPtr<FloatingObject>& key) { return hash(key.get()); }
     static unsigned hash(const PassOwnPtr<FloatingObject>& key) { return hash(key.get()); }
     static bool equal(OwnPtr<FloatingObject>& a, FloatingObject* b) { return a->layoutObject() == b->layoutObject(); }
     static bool equal(OwnPtr<FloatingObject>& a, const OwnPtr<FloatingObject>& b) { return equal(a, b.get()); }
     static bool equal(OwnPtr<FloatingObject>& a, const PassOwnPtr<FloatingObject>& b) { return equal(a, b.get()); }
 
@@ skipping 30 matching lines @@
     const FloatingObjectSet& set() const { return m_set; }
     void clearLineBoxTreePointers();
 
     LayoutUnit logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
     LayoutUnit logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
 
     LayoutUnit logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
     LayoutUnit logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
 
     LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type);
+    FloatingObject* lowestFloatObject() { return m_lowestFloatObject; }
 
 private:
     bool hasLowestFloatLogicalBottomCached(bool isHorizontal, FloatingObject::Type floatType) const;
     LayoutUnit getCachedlowestFloatLogicalBottom(FloatingObject::Type floatType) const;
     void setCachedLowestFloatLogicalBottom(bool isHorizontal, FloatingObject::Type floatType, LayoutUnit value);
+    void setLowestFloatObject(FloatingObject* object) { m_lowestFloatObject = object; }
     void markLowestFloatLogicalBottomCacheAsDirty();
 
     void computePlacedFloatsTree();
     const FloatingObjectTree& placedFloatsTree()
     {
         if (!m_placedFloatsTree.isInitialized())
             computePlacedFloatsTree();
         return m_placedFloatsTree;
     }
     void increaseObjectsCount(FloatingObject::Type);
     void decreaseObjectsCount(FloatingObject::Type);
     FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
 
     FloatingObjectSet m_set;
     FloatingObjectTree m_placedFloatsTree;
     unsigned m_leftObjectsCount;
     unsigned m_rightObjectsCount;
     bool m_horizontalWritingMode;
     const LayoutBlockFlow* m_layoutObject;
 
     struct FloatBottomCachedValue {
         FloatBottomCachedValue();
         LayoutUnit value;
         bool dirty;
     };
     FloatBottomCachedValue m_lowestFloatBottomCache[2];
     bool m_cachedHorizontalWritingMode;
+    FloatingObject* m_lowestFloatObject;

[leviw_travelin_and_unemployed, 2015/05/22 20:52:01]

m_lowestFloatingObject?

Would it maybe make sense to roll this into the lowest float bottom cache?
(Understanding of course we'd have to look at both values to answer the
question).

[rhogan, 2015/05/23 11:56:51]

Yes, I think it might. I'll try it and see.

[rhogan, 2015/05/23 12:12:08]

It doesn't fit well with m_lowestFloatBottomCache because the latter cares about
left/right floats and we don't. So I'll just leave it out by itself I think.

 };
 
 #ifndef NDEBUG
 // These structures are used by PODIntervalTree for debugging purposes.
 template <> struct ValueToString<int> {
     static String string(const int value);
 };
 template<> struct ValueToString<FloatingObject*> {
     static String string(const FloatingObject*);
 };
 #endif
 
 } // namespace blink
 
 #endif // FloatingObjects_h