Move Floats out of RenderBlock

Source/core/rendering/FloatingObjects.h

Index: Source/core/rendering/FloatingObjects.h
diff --git a/Source/core/rendering/FloatingObjects.h b/Source/core/rendering/FloatingObjects.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba8c4e95cb39a9a5310f5dec847f2da79fb1de54
--- /dev/null
+++ b/Source/core/rendering/FloatingObjects.h
@@ -0,0 +1,255 @@
+/*
+ * 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
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef FloatingObjects_h
+#define FloatingObjects_h
+
+#include "core/platform/PODFreeListArena.h"
+#include "core/platform/PODIntervalTree.h"
+#include "core/rendering/RootInlineBox.h"
+#include "wtf/ListHashSet.h"
+
+namespace WebCore {
+
+class RenderBlock;
+class RenderBox;
+
+enum ShapeOutsideFloatOffsetMode { ShapeOutsideFloatShapeOffset, ShapeOutsideFloatMarginBoxOffset };
+
+class FloatingObject {
+    WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
+public:
+#ifndef NDEBUG
+    // Used by the PODIntervalTree for debugging the FloatingObject.
+    template <class> friend struct ValueToString;
+#endif
+
+    // Note that Type uses bits so you can use FloatLeftRight as a mask to query for both left and right.
+    enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
+
+    FloatingObject(EFloat type)
+        : m_renderer(0)
+        , m_originatingLine(0)
+        , m_paginationStrut(0)
+        , m_shouldPaint(true)
+        , m_isDescendant(false)
+        , m_isPlaced(false)
+#ifndef NDEBUG
+        , m_isInPlacedTree(false)
+#endif
+    {
+        ASSERT(type != NoFloat);
+        if (type == LeftFloat)
+            m_type = FloatLeft;
+        else if (type == RightFloat)
+            m_type = FloatRight;
+    }
+
+    FloatingObject(Type type, const LayoutRect& frameRect)
+        : m_renderer(0)
+        , m_originatingLine(0)
+        , m_frameRect(frameRect)
+        , m_paginationStrut(0)
+        , m_type(type)
+        , m_shouldPaint(true)
+        , m_isDescendant(false)
+        , m_isPlaced(true)
+#ifndef NDEBUG
+        , m_isInPlacedTree(false)
+#endif
+    {
+    }
+
+    FloatingObject* clone() const
+    {
+        FloatingObject* cloneObject = new FloatingObject(type(), m_frameRect);
+        cloneObject->m_renderer = m_renderer;
+        cloneObject->m_originatingLine = m_originatingLine;
+        cloneObject->m_paginationStrut = m_paginationStrut;
+        cloneObject->m_shouldPaint = m_shouldPaint;
+        cloneObject->m_isDescendant = m_isDescendant;
+        cloneObject->m_isPlaced = m_isPlaced;
+        return cloneObject;
+    }
+
+    Type type() const { return static_cast<Type>(m_type); }
+    RenderBox* renderer() const { return m_renderer; }
+
+    bool isPlaced() const { return m_isPlaced; }
+    void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
+
+    LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }
+    LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }
+    LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }
+    LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }
+    LayoutUnit width() const { return m_frameRect.width(); }
+    LayoutUnit height() const { return m_frameRect.height(); }
+
+    void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
+    void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
+    void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
+    void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
+
+    const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
+    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 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.
+    void setRenderer(RenderBox* renderer) { m_renderer = renderer; }
+    RootInlineBox* originatingLine() const { return m_originatingLine; }
+    void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
+
+    LayoutUnit logicalTop(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? y() : x(); }
+    LayoutUnit logicalBottom(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? maxY() : maxX(); }
+    LayoutUnit logicalLeft(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? x() : y(); }
+    LayoutUnit logicalRight(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? maxX() : maxY(); }
+    LayoutUnit logicalWidth(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? width() : height(); }
+
+    int pixelSnappedLogicalTop(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedY() : frameRect().pixelSnappedX(); }
+    int pixelSnappedLogicalBottom(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedMaxY() : frameRect().pixelSnappedMaxX(); }
+    int pixelSnappedLogicalLeft(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedX() : frameRect().pixelSnappedY(); }
+    int pixelSnappedLogicalRight(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedMaxX() : frameRect().pixelSnappedMaxY(); }
+
+    void setLogicalTop(LayoutUnit logicalTop, bool isHorizontalWritingMode)
+    {
+        if (isHorizontalWritingMode)
+            setY(logicalTop);
+        else
+            setX(logicalTop);
+    }
+    void setLogicalLeft(LayoutUnit logicalLeft, bool isHorizontalWritingMode)
+    {
+        if (isHorizontalWritingMode)
+            setX(logicalLeft);
+        else
+            setY(logicalLeft);
+    }
+    void setLogicalHeight(LayoutUnit logicalHeight, bool isHorizontalWritingMode)
+    {
+        if (isHorizontalWritingMode)
+            setHeight(logicalHeight);
+        else
+            setWidth(logicalHeight);
+    }
+    void setLogicalWidth(LayoutUnit logicalWidth, bool isHorizontalWritingMode)
+    {
+        if (isHorizontalWritingMode)
+            setWidth(logicalWidth);
+        else
+            setHeight(logicalWidth);
+    }
+
+private:
+    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
+};
+
+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;
+
+class FloatingObjects {
+    WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
+public:
+    FloatingObjects(const RenderBlock*, bool horizontalWritingMode);
+    ~FloatingObjects();
+
+    void clear();
+    void add(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();
+    LayoutUnit logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode = ShapeOutsideFloatShapeOffset, LayoutUnit* heightRemaining = 0);
+    LayoutUnit logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode = ShapeOutsideFloatShapeOffset, LayoutUnit* heightRemaining = 0);
+private:
+    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 RenderBlock* m_renderer;
+};
+
+#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