Track intruding and overhanging floats

Source/core/rendering/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 66 matching lines @@
     void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }
 
     int paginationStrut() const { return m_paginationStrut; }
     void setPaginationStrut(int strut) { m_paginationStrut = strut; }
 
 #ifndef NDEBUG
     bool isInPlacedTree() const { return m_isInPlacedTree; }
     void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
 #endif
 
+    bool isOverhangingOrIntruding() const { return m_isOverhangingOrIntruding; }
+    void setIsOverhangingOrIntruding(bool value) { m_isOverhangingOrIntruding = value; }
+
     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; }
 
     // 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(RenderBox*);
     FloatingObject(RenderBox*, Type, const LayoutRect&, bool shouldPaint, bool isDescendant);
 
     RenderBox* m_renderer;
     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;
 #ifndef NDEBUG
     unsigned m_isInPlacedTree : 1;
 #endif
+    unsigned m_isOverhangingOrIntruding : 1;
 };
 
 struct FloatingObjectHashFunctions {
     static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->renderer()); }
     static bool equal(FloatingObject* a, FloatingObject* b) { return a->renderer() == b->renderer(); }
     static const bool safeToCompareToEmptyOrDeleted = true;
 };
 struct FloatingObjectHashTranslator {
     static unsigned hash(RenderBox* key) { return DefaultHash<RenderBox*>::Hash::hash(key); }
     static bool equal(FloatingObject* a, RenderBox* b) { return a->renderer() == b; }
 };
 typedef ListHashSet<FloatingObject*, 4, FloatingObjectHashFunctions> FloatingObjectSet;
 typedef FloatingObjectSet::const_iterator FloatingObjectSetIterator;
 typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;
 typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;
 typedef PODFreeListArena<PODRedBlackTree<FloatingObjectInterval>::Node> IntervalArena;
 typedef HashMap<RenderBox*, FloatingObject*> RendererToFloatInfoMap;
 
 class FloatingObjects {
     WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
 public:
     FloatingObjects(const RenderBlockFlow*, bool horizontalWritingMode);
     ~FloatingObjects();
 
     void clear();
+    void clearOverhangingAndIntrudingFloats();
     void moveAllToFloatInfoMap(RendererToFloatInfoMap&);
     FloatingObject* add(PassOwnPtr<FloatingObject>);
+    FloatingObject* addOverhangingOrIntrudingFloat(PassOwnPtr<FloatingObject>);
     void remove(FloatingObject*);
     void addPlacedObject(FloatingObject*);
     void removePlacedObject(FloatingObject*);
     void setHorizontalWritingMode(bool b = true) { m_horizontalWritingMode = b; }
 
     bool hasLeftObjects() const { return m_leftObjectsCount > 0; }
     bool hasRightObjects() const { return m_rightObjectsCount > 0; }
     const FloatingObjectSet& set() const { return m_set; }
     void clearLineBoxTreePointers();
 
@@ skipping 16 matching lines @@
     {
         if (!m_placedFloatsTree.isInitialized())
             computePlacedFloatsTree();
         return m_placedFloatsTree;
     }
     void increaseObjectsCount(FloatingObject::Type);
     void decreaseObjectsCount(FloatingObject::Type);
     FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
 
     FloatingObjectSet m_set;
+    FloatingObjectSet m_overhangingOrIntrudingSet;
     FloatingObjectTree m_placedFloatsTree;
     unsigned m_leftObjectsCount;
     unsigned m_rightObjectsCount;
     bool m_horizontalWritingMode;
     const RenderBlockFlow* m_renderer;
 
     struct FloatBottomCachedValue {
         FloatBottomCachedValue();
         LayoutUnit value;
         bool dirty;
     };
     FloatBottomCachedValue m_lowestFloatBottomCache[2];
     bool m_cachedHorizontalWritingMode;
 };
 
 #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 WebCore
 
 #endif // FloatingObjects_h