#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
{
{
}
+ virtual ~ComputeFloatOffsetAdapter() { }
+
int lowValue() const { return m_lineTop; }
int highValue() const { return m_lineBottom; }
void collectIfNeeded(const IntervalType&);
LayoutUnit offset() const { return m_offset; }
- LayoutUnit shapeOffset() const;
- LayoutUnit heightRemaining() const;
-private:
- bool updateOffsetIfNeeded(const FloatingObject*);
+protected:
+ virtual bool updateOffsetIfNeeded(const FloatingObject&) = 0;
const RenderBlockFlow* m_renderer;
int m_lineTop;
const FloatingObject* m_outermostFloat;
};
+template <FloatingObject::Type FloatTypeValue>
+class ComputeFloatOffsetForFloatLayoutAdapter : public ComputeFloatOffsetAdapter<FloatTypeValue> {
+public:
+ ComputeFloatOffsetForFloatLayoutAdapter(const RenderBlockFlow* renderer, LayoutUnit lineTop, LayoutUnit lineBottom, LayoutUnit offset)
+ : ComputeFloatOffsetAdapter<FloatTypeValue>(renderer, lineTop, lineBottom, offset)
+ {
+ }
+
+ virtual ~ComputeFloatOffsetForFloatLayoutAdapter() { }
+
+ LayoutUnit heightRemaining() const;
+
+protected:
+ virtual bool updateOffsetIfNeeded(const FloatingObject&) OVERRIDE FINAL;
+};
+
+template <FloatingObject::Type FloatTypeValue>
+class ComputeFloatOffsetForLineLayoutAdapter : public ComputeFloatOffsetAdapter<FloatTypeValue> {
+public:
+ ComputeFloatOffsetForLineLayoutAdapter(const RenderBlockFlow* renderer, LayoutUnit lineTop, LayoutUnit lineBottom, LayoutUnit offset)
+ : ComputeFloatOffsetAdapter<FloatTypeValue>(renderer, lineTop, lineBottom, offset)
+ {
+ }
+
+ virtual ~ComputeFloatOffsetForLineLayoutAdapter() { }
+
+protected:
+ virtual bool updateOffsetIfNeeded(const FloatingObject&) OVERRIDE FINAL;
+};
+
FloatingObjects::~FloatingObjects()
{
- // FIXME: m_set should use OwnPtr instead.
- deleteAllValues(m_set);
}
void FloatingObjects::clearLineBoxTreePointers()
{
}
}
-template<>
-inline bool ComputeFloatOffsetAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
-{
- LayoutUnit logicalRight = m_renderer->logicalRightForFloat(floatingObject);
- if (logicalRight > m_offset) {
- m_offset = logicalRight;
- return true;
- }
- return false;
-}
-
FloatingObjects::FloatingObjects(const RenderBlockFlow* renderer, bool horizontalWritingMode)
: m_placedFloatsTree(UninitializedTree)
, m_leftObjectsCount(0)
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));
}
}
-static inline ShapeOutsideInfo* shapeInfoForFloat(const FloatingObject* floatingObject, const RenderBlockFlow* containingBlock, LayoutUnit lineTop, LayoutUnit lineBottom)
-{
- if (floatingObject) {
- if (ShapeOutsideInfo* shapeOutside = floatingObject->renderer()->shapeOutsideInfo()) {
- shapeOutside->updateDeltasForContainingBlockLine(containingBlock, floatingObject, lineTop, lineBottom - lineTop);
- return shapeOutside;
- }
- }
-
- return 0;
-}
-
-template<>
-inline LayoutUnit ComputeFloatOffsetAdapter<FloatingObject::FloatLeft>::shapeOffset() const
-{
- if (ShapeOutsideInfo* shapeOutside = shapeInfoForFloat(m_outermostFloat, m_renderer, m_lineTop, m_lineBottom))
- return m_offset + shapeOutside->rightMarginBoxDelta();
-
- return m_offset;
-}
-
-template<>
-inline LayoutUnit ComputeFloatOffsetAdapter<FloatingObject::FloatRight>::shapeOffset() const
-{
- if (ShapeOutsideInfo* shapeOutside = shapeInfoForFloat(m_outermostFloat, m_renderer, m_lineTop, m_lineBottom))
- return m_offset + shapeOutside->leftMarginBoxDelta();
-
- return m_offset;
-}
-
LayoutUnit FloatingObjects::logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit *heightRemaining)
{
int logicalTopAsInt = roundToInt(logicalTop);
- ComputeFloatOffsetAdapter<FloatingObject::FloatLeft> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
+ ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
placedFloatsTree().allOverlapsWithAdapter(adapter);
if (heightRemaining)
LayoutUnit FloatingObjects::logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit *heightRemaining)
{
int logicalTopAsInt = roundToInt(logicalTop);
- ComputeFloatOffsetAdapter<FloatingObject::FloatRight> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
+ ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatRight> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
placedFloatsTree().allOverlapsWithAdapter(adapter);
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)
{
- ComputeFloatOffsetAdapter<FloatingObject::FloatLeft> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
+ ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
placedFloatsTree().allOverlapsWithAdapter(adapter);
- return adapter.shapeOffset();
+ return adapter.offset();
}
LayoutUnit FloatingObjects::logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight)
{
- ComputeFloatOffsetAdapter<FloatingObject::FloatRight> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
+ ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
placedFloatsTree().allOverlapsWithAdapter(adapter);
- return min(fixedOffset, adapter.shapeOffset());
+ return std::min(fixedOffset, adapter.offset());
}
FloatingObjects::FloatBottomCachedValue::FloatBottomCachedValue()
}
template<>
-inline bool ComputeFloatOffsetAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
+inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
+{
+ LayoutUnit logicalRight = m_renderer->logicalRightForFloat(&floatingObject);
+ if (logicalRight > m_offset) {
+ m_offset = logicalRight;
+ return true;
+ }
+ return false;
+}
+
+template<>
+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;
}
template <FloatingObject::Type FloatTypeValue>
+LayoutUnit ComputeFloatOffsetForFloatLayoutAdapter<FloatTypeValue>::heightRemaining() const
+{
+ return this->m_outermostFloat ? this->m_renderer->logicalBottomForFloat(this->m_outermostFloat) - this->m_lineTop : LayoutUnit(1);
+}
+
+template <FloatingObject::Type FloatTypeValue>
inline void ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded(const IntervalType& interval)
{
const FloatingObject* floatingObject = interval.data();
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;
}
-template <FloatingObject::Type FloatTypeValue>
-LayoutUnit ComputeFloatOffsetAdapter<FloatTypeValue>::heightRemaining() const
+template<>
+inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
+{
+ 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 += shapeDeltas.rightMarginBoxDelta();
+ }
+ if (logicalRight > m_offset) {
+ m_offset = logicalRight;
+ return true;
+ }
+
+ return false;
+}
+
+template<>
+inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- return m_outermostFloat ? m_renderer->logicalBottomForFloat(m_outermostFloat) - m_lineTop : LayoutUnit(1);
+ 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 += shapeDeltas.leftMarginBoxDelta();
+ }
+ if (logicalLeft < m_offset) {
+ m_offset = logicalLeft;
+ return true;
+ }
+
+ return false;
}
#ifndef NDEBUG
#endif
-} // namespace WebCore
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff