Use unique_ptr instead of deleteAllValues in FloatingObject code
[WebKit-https.git] / Source / WebCore / rendering / FloatingObjects.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2007 David Smith (catfish.man@gmail.com)
5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #ifndef FloatingObjects_h
25 #define FloatingObjects_h
26
27 #include "PODIntervalTree.h"
28 #include "RootInlineBox.h"
29 #include <wtf/ListHashSet.h>
30
31 namespace WebCore {
32
33 class RenderBlock;
34 class RenderBox;
35
36 enum ShapeOutsideFloatOffsetMode { ShapeOutsideFloatShapeOffset, ShapeOutsideFloatMarginBoxOffset };
37
38 class FloatingObject {
39     WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
40 public:
41     // Note that Type uses bits so you can use FloatLeftRight as a mask to query for both left and right.
42     enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
43
44     static std::unique_ptr<FloatingObject> create(RenderBox&);
45     std::unique_ptr<FloatingObject> copyToNewContainer(LayoutSize, bool shouldPaint = false, bool isDescendant = false) const;
46     std::unique_ptr<FloatingObject> unsafeClone() const;
47
48     explicit FloatingObject(RenderBox&);
49     FloatingObject(RenderBox&, Type, const LayoutRect&, bool shouldPaint, bool isDescendant);
50
51     Type type() const { return static_cast<Type>(m_type); }
52     RenderBox& renderer() const { return m_renderer; }
53
54     bool isPlaced() const { return m_isPlaced; }
55     void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
56
57     LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }
58     LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }
59     LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }
60     LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }
61     LayoutUnit width() const { return m_frameRect.width(); }
62     LayoutUnit height() const { return m_frameRect.height(); }
63
64     void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
65     void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
66     void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
67     void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
68
69     const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
70     void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }
71
72     int paginationStrut() const { return m_paginationStrut; }
73     void setPaginationStrut(int strut) { m_paginationStrut = strut; }
74
75 #ifndef NDEBUG
76     bool isInPlacedTree() const { return m_isInPlacedTree; }
77     void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
78 #endif
79
80     bool shouldPaint() const { return m_shouldPaint; }
81     void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
82     bool isDescendant() const { return m_isDescendant; }
83     void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
84
85     // FIXME: Callers of these methods are dangerous and should be whitelisted explicitly or removed.
86     RootInlineBox* originatingLine() const { return m_originatingLine; }
87     void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
88
89     LayoutUnit logicalTop(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? y() : x(); }
90     LayoutUnit logicalBottom(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? maxY() : maxX(); }
91     LayoutUnit logicalLeft(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? x() : y(); }
92     LayoutUnit logicalRight(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? maxX() : maxY(); }
93     LayoutUnit logicalWidth(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? width() : height(); }
94
95     int pixelSnappedLogicalTop(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedY() : frameRect().pixelSnappedX(); }
96     int pixelSnappedLogicalBottom(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedMaxY() : frameRect().pixelSnappedMaxX(); }
97     int pixelSnappedLogicalLeft(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedX() : frameRect().pixelSnappedY(); }
98     int pixelSnappedLogicalRight(bool isHorizontalWritingMode) const { return isHorizontalWritingMode ? frameRect().pixelSnappedMaxX() : frameRect().pixelSnappedMaxY(); }
99
100     void setLogicalTop(LayoutUnit logicalTop, bool isHorizontalWritingMode)
101     {
102         if (isHorizontalWritingMode)
103             setY(logicalTop);
104         else
105             setX(logicalTop);
106     }
107     void setLogicalLeft(LayoutUnit logicalLeft, bool isHorizontalWritingMode)
108     {
109         if (isHorizontalWritingMode)
110             setX(logicalLeft);
111         else
112             setY(logicalLeft);
113     }
114     void setLogicalHeight(LayoutUnit logicalHeight, bool isHorizontalWritingMode)
115     {
116         if (isHorizontalWritingMode)
117             setHeight(logicalHeight);
118         else
119             setWidth(logicalHeight);
120     }
121     void setLogicalWidth(LayoutUnit logicalWidth, bool isHorizontalWritingMode)
122     {
123         if (isHorizontalWritingMode)
124             setWidth(logicalWidth);
125         else
126             setHeight(logicalWidth);
127     }
128
129 private:
130     RenderBox& m_renderer;
131     RootInlineBox* m_originatingLine;
132     LayoutRect m_frameRect;
133     int m_paginationStrut; // FIXME: This should be a LayoutUnit, since it's a vertical offset.
134
135     unsigned m_type : 2; // Type (left or right aligned)
136     unsigned m_shouldPaint : 1;
137     unsigned m_isDescendant : 1;
138     unsigned m_isPlaced : 1;
139 #ifndef NDEBUG
140     unsigned m_isInPlacedTree : 1;
141 #endif
142 };
143
144 struct FloatingObjectHashFunctions {
145     static unsigned hash(const std::unique_ptr<FloatingObject>& key) { return PtrHash<RenderBox*>::hash(&key->renderer()); }
146     static bool equal(const std::unique_ptr<FloatingObject>& a, const std::unique_ptr<FloatingObject>& b) { return &a->renderer() == &b->renderer(); }
147     static const bool safeToCompareToEmptyOrDeleted = true;
148 };
149 struct FloatingObjectHashTranslator {
150     static unsigned hash(const RenderBox& key) { return PtrHash<const RenderBox*>::hash(&key); }
151     static unsigned hash(const FloatingObject& key) { return PtrHash<RenderBox*>::hash(&key.renderer()); }
152     static bool equal(const std::unique_ptr<FloatingObject>& a, const RenderBox& b) { return &a->renderer() == &b; }
153     static bool equal(const std::unique_ptr<FloatingObject>& a, const FloatingObject& b) { return &a->renderer() == &b.renderer(); }
154 };
155
156 typedef ListHashSet<std::unique_ptr<FloatingObject>, 4, FloatingObjectHashFunctions> FloatingObjectSet;
157
158 typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;
159 typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;
160 typedef PODFreeListArena<PODRedBlackTree<FloatingObjectInterval>::Node> IntervalArena;
161
162 // FIXME: This is really the same thing as FloatingObjectSet.
163 // Change clients to use that set directly, and replace the moveAllToFloatInfoMap function with a takeSet function.
164 typedef HashMap<RenderBox*, std::unique_ptr<FloatingObject>> RendererToFloatInfoMap;
165
166 class FloatingObjects {
167     WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
168 public:
169     FloatingObjects(const RenderBlock*, bool horizontalWritingMode);
170     ~FloatingObjects();
171
172     void clear();
173     void moveAllToFloatInfoMap(RendererToFloatInfoMap&);
174     FloatingObject* add(std::unique_ptr<FloatingObject>);
175     void remove(FloatingObject*);
176     void addPlacedObject(FloatingObject*);
177     void removePlacedObject(FloatingObject*);
178     void setHorizontalWritingMode(bool b = true) { m_horizontalWritingMode = b; }
179
180     bool hasLeftObjects() const { return m_leftObjectsCount > 0; }
181     bool hasRightObjects() const { return m_rightObjectsCount > 0; }
182     const FloatingObjectSet& set() const { return m_set; }
183     void clearLineBoxTreePointers();
184     LayoutUnit logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode = ShapeOutsideFloatShapeOffset, LayoutUnit* heightRemaining = 0);
185     LayoutUnit logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode = ShapeOutsideFloatShapeOffset, LayoutUnit* heightRemaining = 0);
186
187 private:
188     void computePlacedFloatsTree();
189     const FloatingObjectTree& placedFloatsTree();
190     void increaseObjectsCount(FloatingObject::Type);
191     void decreaseObjectsCount(FloatingObject::Type);
192     FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
193
194     FloatingObjectSet m_set;
195     FloatingObjectTree m_placedFloatsTree;
196     unsigned m_leftObjectsCount;
197     unsigned m_rightObjectsCount;
198     bool m_horizontalWritingMode;
199     const RenderBlock* m_renderer;
200 };
201
202 #ifndef NDEBUG
203 // These structures are used by PODIntervalTree for debugging purposes.
204 template <> struct ValueToString<int> {
205     static String string(const int value);
206 };
207 template<> struct ValueToString<FloatingObject*> {
208     static String string(const FloatingObject*);
209 };
210 #endif
211
212 } // namespace WebCore
213
214 #endif // FloatingObjects_h