#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;
};
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));
}
}
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->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);
}
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();
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