Unreviewed, rolling out r234489.
[WebKit-https.git] / Source / WebCore / rendering / FloatingObjects.h
index 31e63fd..11e68a7 100644 (file)
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef FloatingObjects_h
-#define FloatingObjects_h
+#pragma once
 
 #include "PODIntervalTree.h"
 #include "RootInlineBox.h"
 #include <wtf/ListHashSet.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
-class RenderBlock;
+class RenderBlockFlow;
 class RenderBox;
 
-enum ShapeOutsideFloatOffsetMode { ShapeOutsideFloatShapeOffset, ShapeOutsideFloatMarginBoxOffset };
-
 class FloatingObject {
     WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
 public:
     // 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 };
 
-    explicit 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;
-    }
+    static std::unique_ptr<FloatingObject> create(RenderBox&);
+    std::unique_ptr<FloatingObject> copyToNewContainer(LayoutSize, bool shouldPaint = false, bool isDescendant = false) const;
+    std::unique_ptr<FloatingObject> cloneForNewParent() const;
 
-    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;
-    }
+    explicit FloatingObject(RenderBox&);
+    FloatingObject(RenderBox&, Type, const LayoutRect&, const LayoutSize&, bool shouldPaint, bool isDescendant);
 
     Type type() const { return static_cast<Type>(m_type); }
-    RenderBox* renderer() const { return m_renderer; }
+    RenderBox& renderer() const { return *m_renderer; }
 
     bool isPlaced() const { return m_isPlaced; }
     void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
@@ -104,11 +64,13 @@ public:
     void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
     void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
 
+    void setMarginOffset(LayoutSize offset) { ASSERT(!isInPlacedTree()); m_marginOffset = offset; }
+
     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; }
+    LayoutUnit paginationStrut() const { return m_paginationStrut; }
+    void setPaginationStrut(LayoutUnit strut) { m_paginationStrut = strut; }
 
 #ifndef NDEBUG
     bool isInPlacedTree() const { return m_isInPlacedTree; }
@@ -121,55 +83,24 @@ public:
     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)
+    RootInlineBox* originatingLine() const { return m_originatingLine.get(); }
+    void clearOriginatingLine() { m_originatingLine = nullptr; }
+    void setOriginatingLine(RootInlineBox& line) { m_originatingLine = makeWeakPtr(line); }
+
+    LayoutSize locationOffsetOfBorderBox() const
     {
-        if (isHorizontalWritingMode)
-            setWidth(logicalWidth);
-        else
-            setHeight(logicalWidth);
+        ASSERT(isPlaced());
+        return LayoutSize(m_frameRect.location().x() + m_marginOffset.width(), m_frameRect.location().y() + m_marginOffset.height());
     }
+    LayoutSize marginOffset() const { ASSERT(isPlaced()); return m_marginOffset; }
+    LayoutSize translationOffsetToAncestor() const;
 
 private:
-    RenderBox* m_renderer;
-    RootInlineBox* m_originatingLine;
+    WeakPtr<RenderBox> m_renderer;
+    WeakPtr<RootInlineBox> m_originatingLine;
     LayoutRect m_frameRect;
-    int m_paginationStrut; // FIXME: This should be a LayoutUnit, since it's a vertical offset.
+    LayoutUnit m_paginationStrut;
+    LayoutSize m_marginOffset;
 
     unsigned m_type : 2; // Type (left or right aligned)
     unsigned m_shouldPaint : 1;
@@ -181,29 +112,35 @@ private:
 };
 
 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 unsigned hash(const std::unique_ptr<FloatingObject>& key) { return PtrHash<RenderBox*>::hash(&key->renderer()); }
+    static bool equal(const std::unique_ptr<FloatingObject>& a, const std::unique_ptr<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; }
+    static unsigned hash(const RenderBox& key) { return PtrHash<const RenderBox*>::hash(&key); }
+    static unsigned hash(const FloatingObject& key) { return PtrHash<RenderBox*>::hash(&key.renderer()); }
+    static bool equal(const std::unique_ptr<FloatingObject>& a, const RenderBox& b) { return &a->renderer() == &b; }
+    static bool equal(const std::unique_ptr<FloatingObject>& a, const FloatingObject& b) { return &a->renderer() == &b.renderer(); }
 };
-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 ListHashSet<std::unique_ptr<FloatingObject>, FloatingObjectHashFunctions> FloatingObjectSet;
+
+typedef PODInterval<LayoutUnit, FloatingObject*> FloatingObjectInterval;
+typedef PODIntervalTree<LayoutUnit, FloatingObject*> FloatingObjectTree;
+
+// FIXME: This is really the same thing as FloatingObjectSet.
+// Change clients to use that set directly, and replace the moveAllToFloatInfoMap function with a takeSet function.
+typedef HashMap<RenderBox*, std::unique_ptr<FloatingObject>> RendererToFloatInfoMap;
 
 class FloatingObjects {
     WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
 public:
-    FloatingObjects(const RenderBlock*, bool horizontalWritingMode);
+    explicit FloatingObjects(const RenderBlockFlow&);
     ~FloatingObjects();
 
     void clear();
-    void add(FloatingObject*);
+    void moveAllToFloatInfoMap(RendererToFloatInfoMap&);
+    FloatingObject* add(std::unique_ptr<FloatingObject>);
     void remove(FloatingObject*);
     void addPlacedObject(FloatingObject*);
     void removePlacedObject(FloatingObject*);
@@ -213,38 +150,44 @@ public:
     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);
+
+    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 findNextFloatLogicalBottomBelow(LayoutUnit logicalHeight);
+    LayoutUnit findNextFloatLogicalBottomBelowForBlock(LayoutUnit logicalHeight);
+
 private:
+    RenderBlockFlow& renderer() const { return *m_renderer; }
     void computePlacedFloatsTree();
-    const FloatingObjectTree& placedFloatsTree()
-    {
-        if (!m_placedFloatsTree.isInitialized())
-            computePlacedFloatsTree();
-        return m_placedFloatsTree;
-    }
+    const FloatingObjectTree* placedFloatsTree();
     void increaseObjectsCount(FloatingObject::Type);
     void decreaseObjectsCount(FloatingObject::Type);
     FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
 
     FloatingObjectSet m_set;
-    FloatingObjectTree m_placedFloatsTree;
+    std::unique_ptr<FloatingObjectTree> m_placedFloatsTree;
     unsigned m_leftObjectsCount;
     unsigned m_rightObjectsCount;
     bool m_horizontalWritingMode;
-    const RenderBlock* m_renderer;
+    WeakPtr<RenderBlockFlow> m_renderer;
 };
 
+} // namespace WebCore
+
 #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 WTF {
 
-} // namespace WebCore
+// This helper is used by PODIntervalTree for debugging purposes.
+template<> struct ValueToString<WebCore::FloatingObject*> {
+    static String string(const WebCore::FloatingObject* floatingObject)
+    {
+        return String::format("%p (%ix%i %ix%i)", floatingObject, floatingObject->frameRect().x().toInt(), floatingObject->frameRect().y().toInt(), floatingObject->frameRect().maxX().toInt(), floatingObject->frameRect().maxY().toInt());
+    }
+};
 
-#endif // FloatingObjects_h
+} // namespace WTF
+#endif