#include "core/rendering/RenderBox.h"
#include "core/rendering/RenderView.h"
-using namespace std;
using namespace WTF;
-namespace WebCore {
+namespace blink {
struct SameSizeAsFloatingObject {
void* pointers[2];
, m_shouldPaint(true)
, m_isDescendant(false)
, m_isPlaced(false)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
, m_isInPlacedTree(false)
#endif
{
, m_shouldPaint(shouldPaint)
, m_isDescendant(isDescendant)
, m_isPlaced(true)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
, m_isInPlacedTree(false)
#endif
{
LayoutUnit offset() const { return m_offset; }
protected:
- virtual bool updateOffsetIfNeeded(const FloatingObject*) = 0;
+ virtual bool updateOffsetIfNeeded(const FloatingObject&) = 0;
const RenderBlockFlow* m_renderer;
int m_lineTop;
LayoutUnit heightRemaining() const;
protected:
- virtual bool updateOffsetIfNeeded(const FloatingObject*) OVERRIDE FINAL;
+ virtual bool updateOffsetIfNeeded(const FloatingObject&) OVERRIDE FINAL;
};
template <FloatingObject::Type FloatTypeValue>
virtual ~ComputeFloatOffsetForLineLayoutAdapter() { }
protected:
- virtual bool updateOffsetIfNeeded(const FloatingObject*) OVERRIDE FINAL;
+ virtual bool updateOffsetIfNeeded(const FloatingObject&) OVERRIDE FINAL;
};
FloatingObjects::~FloatingObjects()
{
- // FIXME: m_set should use OwnPtr instead.
- deleteAllValues(m_set);
}
void FloatingObjects::clearLineBoxTreePointers()
{
void FloatingObjects::clear()
{
- deleteAllValues(m_set);
m_set.clear();
m_placedFloatsTree.clear();
m_leftObjectsCount = 0;
return getCachedlowestFloatLogicalBottom(floatType);
} else {
if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatLeft) && hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatRight)) {
- return max(getCachedlowestFloatLogicalBottom(FloatingObject::FloatLeft),
+ return std::max(getCachedlowestFloatLogicalBottom(FloatingObject::FloatLeft),
getCachedlowestFloatLogicalBottom(FloatingObject::FloatRight));
}
}
LayoutUnit lowestFloatBottomLeft = 0;
LayoutUnit lowestFloatBottomRight = 0;
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = *it;
+ FloatingObject* floatingObject = it->get();
if (floatingObject->isPlaced()) {
FloatingObject::Type curType = floatingObject->type();
LayoutUnit curFloatLogicalBottom = m_renderer->logicalBottomForFloat(floatingObject);
if (curType & FloatingObject::FloatLeft)
- lowestFloatBottomLeft = max(lowestFloatBottomLeft, curFloatLogicalBottom);
+ lowestFloatBottomLeft = std::max(lowestFloatBottomLeft, curFloatLogicalBottom);
if (curType & FloatingObject::FloatRight)
- lowestFloatBottomRight = max(lowestFloatBottomRight, curFloatLogicalBottom);
+ lowestFloatBottomRight = std::max(lowestFloatBottomRight, curFloatLogicalBottom);
}
}
- lowestFloatBottom = max(lowestFloatBottomLeft, lowestFloatBottomRight);
+ lowestFloatBottom = std::max(lowestFloatBottomLeft, lowestFloatBottomRight);
setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, FloatingObject::FloatLeft, lowestFloatBottomLeft);
setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, FloatingObject::FloatRight, lowestFloatBottomRight);
} else {
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = *it;
+ FloatingObject* floatingObject = it->get();
if (floatingObject->isPlaced() && floatingObject->type() == floatType)
- lowestFloatBottom = max(lowestFloatBottom, m_renderer->logicalBottomForFloat(floatingObject));
+ lowestFloatBottom = std::max(lowestFloatBottom, m_renderer->logicalBottomForFloat(floatingObject));
}
setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, floatType, lowestFloatBottom);
}
void FloatingObjects::moveAllToFloatInfoMap(RendererToFloatInfoMap& map)
{
- FloatingObjectSetIterator end = m_set.end();
- for (FloatingObjectSetIterator it = m_set.begin(); it != end; ++it)
- map.add((*it)->renderer(), *it);
-
- // clear set before clearing this because we don't want to delete all of
- // the objects we have just transferred.
- m_set.clear();
+ while (!m_set.isEmpty()) {
+ OwnPtr<FloatingObject> floatingObject = m_set.takeFirst();
+ RenderBox* renderer = floatingObject->renderer();
+ map.add(renderer, floatingObject.release());
+ }
clear();
}
if (m_placedFloatsTree.isInitialized())
m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
floatingObject->setIsInPlacedTree(true);
#endif
markLowestFloatLogicalBottomCacheAsDirty();
}
floatingObject->setIsPlaced(false);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
floatingObject->setIsInPlacedTree(false);
#endif
markLowestFloatLogicalBottomCacheAsDirty();
{
FloatingObject* newObject = floatingObject.leakPtr();
increaseObjectsCount(newObject->type());
- m_set.add(newObject);
+ m_set.add(adoptPtr(newObject));
if (newObject->isPlaced())
addPlacedObject(newObject);
markLowestFloatLogicalBottomCacheAsDirty();
return newObject;
}
-void FloatingObjects::remove(FloatingObject* floatingObject)
+void FloatingObjects::remove(FloatingObject* toBeRemoved)
{
- decreaseObjectsCount(floatingObject->type());
- m_set.remove(floatingObject);
+ decreaseObjectsCount(toBeRemoved->type());
+ OwnPtr<FloatingObject> floatingObject = m_set.take(toBeRemoved);
ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
if (floatingObject->isPlaced())
- removePlacedObject(floatingObject);
+ removePlacedObject(floatingObject.get());
markLowestFloatLogicalBottomCacheAsDirty();
ASSERT(!floatingObject->originatingLine());
- delete floatingObject;
}
void FloatingObjects::computePlacedFloatsTree()
FloatingObjectSetIterator it = m_set.begin();
FloatingObjectSetIterator end = m_set.end();
for (; it != end; ++it) {
- FloatingObject* floatingObject = *it;
+ FloatingObject* floatingObject = it->get();
if (floatingObject->isPlaced())
m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
}
if (heightRemaining)
*heightRemaining = adapter.heightRemaining();
- return min(fixedOffset, adapter.offset());
+ return std::min(fixedOffset, adapter.offset());
}
LayoutUnit FloatingObjects::logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight)
ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
placedFloatsTree().allOverlapsWithAdapter(adapter);
- return min(fixedOffset, adapter.offset());
+ return std::min(fixedOffset, adapter.offset());
}
FloatingObjects::FloatBottomCachedValue::FloatBottomCachedValue()
}
template<>
-inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
+inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- LayoutUnit logicalRight = m_renderer->logicalRightForFloat(floatingObject);
+ LayoutUnit logicalRight = m_renderer->logicalRightForFloat(&floatingObject);
if (logicalRight > m_offset) {
m_offset = logicalRight;
return true;
}
template<>
-inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
+inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(floatingObject);
+ LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(&floatingObject);
if (logicalLeft < m_offset) {
m_offset = logicalLeft;
return true;
ASSERT(interval.low() == m_renderer->pixelSnappedLogicalTopForFloat(floatingObject));
ASSERT(interval.high() == m_renderer->pixelSnappedLogicalBottomForFloat(floatingObject));
- bool floatIsNewExtreme = updateOffsetIfNeeded(floatingObject);
+ bool floatIsNewExtreme = updateOffsetIfNeeded(*floatingObject);
if (floatIsNewExtreme)
m_outermostFloat = floatingObject;
}
-static inline ShapeOutsideInfo* shapeInfoForFloat(const FloatingObject& floatingObject, const RenderBlockFlow& containingBlock, LayoutUnit lineTop, LayoutUnit lineBottom)
-{
- if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer()->shapeOutsideInfo()) {
- shapeOutside->updateDeltasForContainingBlockLine(containingBlock, floatingObject, lineTop, lineBottom - lineTop);
- return shapeOutside;
- }
-
- return 0;
-}
-
template<>
-inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
+inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- ASSERT(floatingObject);
- LayoutUnit logicalRight = m_renderer->logicalRightForFloat(floatingObject);
- if (ShapeOutsideInfo* shapeOutside = shapeInfoForFloat(*floatingObject, *m_renderer, m_lineTop, m_lineBottom)) {
- if (!shapeOutside->lineOverlapsShape())
+ LayoutUnit logicalRight = m_renderer->logicalRightForFloat(&floatingObject);
+ if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer()->shapeOutsideInfo()) {
+ ShapeOutsideDeltas shapeDeltas = shapeOutside->computeDeltasForContainingBlockLine(*m_renderer, floatingObject, m_lineTop, m_lineBottom - m_lineTop);
+ if (!shapeDeltas.lineOverlapsShape())
return false;
- logicalRight += shapeOutside->rightMarginBoxDelta();
+ logicalRight += shapeDeltas.rightMarginBoxDelta();
}
if (logicalRight > m_offset) {
m_offset = logicalRight;
}
template<>
-inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
+inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- ASSERT(floatingObject);
- LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(floatingObject);
- if (ShapeOutsideInfo* shapeOutside = shapeInfoForFloat(*floatingObject, *m_renderer, m_lineTop, m_lineBottom)) {
- if (!shapeOutside->lineOverlapsShape())
+ LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(&floatingObject);
+ if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer()->shapeOutsideInfo()) {
+ ShapeOutsideDeltas shapeDeltas = shapeOutside->computeDeltasForContainingBlockLine(*m_renderer, floatingObject, m_lineTop, m_lineBottom - m_lineTop);
+ if (!shapeDeltas.lineOverlapsShape())
return false;
- logicalLeft += shapeOutside->leftMarginBoxDelta();
+ logicalLeft += shapeDeltas.leftMarginBoxDelta();
}
if (logicalLeft < m_offset) {
m_offset = logicalLeft;
#endif
-} // namespace WebCore
+} // namespace blink