Diff
Modified: trunk/Source/WebCore/ChangeLog (191233 => 191234)
--- trunk/Source/WebCore/ChangeLog 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/ChangeLog 2015-10-17 03:36:56 UTC (rev 191234)
@@ -1,3 +1,61 @@
+2015-10-16 Zalan Bujtas <za...@apple.com>
+
+ RenderBlockFlow::*logical*ForFloat should take FloatingObject reference.
+ https://bugs.webkit.org/show_bug.cgi?id=150266
+
+ Reviewed by Simon Fraser.
+
+ No change in behaviour.
+
+ * rendering/FloatingObjects.cpp:
+ (WebCore::FindNextFloatLogicalBottomAdapter::collectIfNeeded):
+ (WebCore::ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded):
+ (WebCore::ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded):
+ (WebCore::ComputeFloatOffsetForFloatLayoutAdapter<FloatTypeValue>::heightRemaining):
+ (WebCore::ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded):
+ (WebCore::ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded):
+ (WebCore::ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded):
+ * rendering/RenderBlockFlow.cpp:
+ (WebCore::RenderBlockFlow::rebuildFloatingObjectSetFromIntrudingFloats):
+ (WebCore::RenderBlockFlow::repaintOverhangingFloats):
+ (WebCore::RenderBlockFlow::insertFloatingObject):
+ (WebCore::RenderBlockFlow::removeFloatingObject):
+ (WebCore::RenderBlockFlow::removeFloatingObjectsBelow):
+ (WebCore::RenderBlockFlow::computeLogicalLocationForFloat):
+ (WebCore::RenderBlockFlow::positionNewFloats):
+ (WebCore::RenderBlockFlow::lowestFloatLogicalBottom):
+ (WebCore::RenderBlockFlow::lowestInitialLetterLogicalBottom):
+ (WebCore::RenderBlockFlow::addOverhangingFloats):
+ (WebCore::RenderBlockFlow::hasOverhangingFloat):
+ (WebCore::RenderBlockFlow::addIntrudingFloats):
+ * rendering/RenderBlockFlow.h:
+ (WebCore::RenderBlockFlow::logicalTopForFloat):
+ (WebCore::RenderBlockFlow::logicalBottomForFloat):
+ (WebCore::RenderBlockFlow::logicalLeftForFloat):
+ (WebCore::RenderBlockFlow::logicalRightForFloat):
+ (WebCore::RenderBlockFlow::logicalWidthForFloat):
+ (WebCore::RenderBlockFlow::logicalHeightForFloat):
+ (WebCore::RenderBlockFlow::setLogicalTopForFloat):
+ (WebCore::RenderBlockFlow::setLogicalLeftForFloat):
+ (WebCore::RenderBlockFlow::setLogicalHeightForFloat):
+ (WebCore::RenderBlockFlow::setLogicalWidthForFloat):
+ (WebCore::RenderBlockFlow::logicalSizeForFloat): Deleted.
+ * rendering/RenderBlockLineLayout.cpp:
+ (WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
+ (WebCore::RenderBlockFlow::checkPaginationAndFloatsAtEndLine):
+ (WebCore::RenderBlockFlow::positionNewFloatOnLine):
+ * rendering/RenderBox.cpp:
+ (WebCore::RenderBox::addOverflowFromChild):
+ * rendering/RenderBox.h:
+ (WebCore::RenderBox::addOverflowFromChild):
+ * rendering/line/BreakingContext.h:
+ (WebCore::BreakingContext::handleFloat):
+ * rendering/line/LineWidth.cpp:
+ (WebCore::newFloatShrinksLine):
+ (WebCore::LineWidth::shrinkAvailableWidthForNewFloatIfNeeded):
+ * rendering/shapes/ShapeOutsideInfo.cpp:
+ (WebCore::ShapeOutsideInfo::computeDeltasForContainingBlockLine):
+
2015-10-16 Jiewen Tan <jiewen_...@apple.com>
Avoid to insert TAB before HTML element.
Modified: trunk/Source/WebCore/rendering/FloatingObjects.cpp (191233 => 191234)
--- trunk/Source/WebCore/rendering/FloatingObjects.cpp 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/FloatingObjects.cpp 2015-10-17 03:36:56 UTC (rev 191234)
@@ -210,12 +210,12 @@
inline void FindNextFloatLogicalBottomAdapter::collectIfNeeded(const IntervalType& interval)
{
- const FloatingObject* floatingObject = interval.data();
+ const auto& floatingObject = *interval.data();
if (!rangesIntersect(interval.low(), interval.high(), m_belowLogicalHeight, m_aboveLogicalHeight))
return;
// All the objects returned from the tree should be already placed.
- ASSERT(floatingObject->isPlaced());
+ ASSERT(floatingObject.isPlaced());
ASSERT(rangesIntersect(m_renderer.logicalTopForFloat(floatingObject), m_renderer.logicalBottomForFloat(floatingObject), m_belowLogicalHeight, m_aboveLogicalHeight));
LayoutUnit floatBottom = m_renderer.logicalBottomForFloat(floatingObject);
@@ -223,8 +223,8 @@
return;
#if ENABLE(CSS_SHAPES)
- if (ShapeOutsideInfo* shapeOutside = floatingObject->renderer().shapeOutsideInfo()) {
- LayoutUnit shapeBottom = m_renderer.logicalTopForFloat(floatingObject) + m_renderer.marginBeforeForChild(floatingObject->renderer()) + shapeOutside->shapeLogicalBottom();
+ if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer().shapeOutsideInfo()) {
+ LayoutUnit shapeBottom = m_renderer.logicalTopForFloat(floatingObject) + m_renderer.marginBeforeForChild(floatingObject.renderer()) + shapeOutside->shapeLogicalBottom();
// Use the shapeBottom unless it extends outside of the margin box, in which case it is clipped.
m_nextShapeLogicalBottom = std::min(shapeBottom, floatBottom);
} else
@@ -433,7 +433,7 @@
template<>
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;
@@ -444,7 +444,7 @@
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;
@@ -455,29 +455,29 @@
template <FloatingObject::Type FloatTypeValue>
LayoutUnit ComputeFloatOffsetForFloatLayoutAdapter<FloatTypeValue>::heightRemaining() const
{
- return this->m_outermostFloat ? this->m_renderer.logicalBottomForFloat(this->m_outermostFloat) - this->m_lineTop : LayoutUnit::fromPixel(1);
+ return this->m_outermostFloat ? this->m_renderer.logicalBottomForFloat(*this->m_outermostFloat) - this->m_lineTop : LayoutUnit::fromPixel(1);
}
template <FloatingObject::Type FloatTypeValue>
inline void ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded(const IntervalType& interval)
{
- const FloatingObject* floatingObject = interval.data();
- if (floatingObject->type() != FloatTypeValue || !rangesIntersect(interval.low(), interval.high(), m_lineTop, m_lineBottom))
+ const auto& floatingObject = *interval.data();
+ if (floatingObject.type() != FloatTypeValue || !rangesIntersect(interval.low(), interval.high(), m_lineTop, m_lineBottom))
return;
// All the objects returned from the tree should be already placed.
- ASSERT(floatingObject->isPlaced());
+ ASSERT(floatingObject.isPlaced());
ASSERT(rangesIntersect(m_renderer.logicalTopForFloat(floatingObject), m_renderer.logicalBottomForFloat(floatingObject), m_lineTop, m_lineBottom));
- bool floatIsNewExtreme = updateOffsetIfNeeded(*floatingObject);
+ bool floatIsNewExtreme = updateOffsetIfNeeded(floatingObject);
if (floatIsNewExtreme)
- m_outermostFloat = floatingObject;
+ m_outermostFloat = &floatingObject;
}
template<>
inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- LayoutUnit logicalRight = m_renderer.logicalRightForFloat(&floatingObject);
+ LayoutUnit logicalRight = m_renderer.logicalRightForFloat(floatingObject);
#if ENABLE(CSS_SHAPES)
if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer().shapeOutsideInfo()) {
ShapeOutsideDeltas shapeDeltas = shapeOutside->computeDeltasForContainingBlockLine(m_renderer, floatingObject, m_lineTop, m_lineBottom - m_lineTop);
@@ -498,7 +498,7 @@
template<>
inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
{
- LayoutUnit logicalLeft = m_renderer.logicalLeftForFloat(&floatingObject);
+ LayoutUnit logicalLeft = m_renderer.logicalLeftForFloat(floatingObject);
#if ENABLE(CSS_SHAPES)
if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer().shapeOutsideInfo()) {
ShapeOutsideDeltas shapeDeltas = shapeOutside->computeDeltasForContainingBlockLine(m_renderer, floatingObject, m_lineTop, m_lineBottom - m_lineTop);
Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (191233 => 191234)
--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2015-10-17 03:36:56 UTC (rev 191234)
@@ -267,12 +267,12 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
auto end = floatingObjectSet.end();
for (auto it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- std::unique_ptr<FloatingObject> oldFloatingObject = floatMap.take(&floatingObject->renderer());
+ const auto& floatingObject = *it->get();
+ std::unique_ptr<FloatingObject> oldFloatingObject = floatMap.take(&floatingObject.renderer());
LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
if (oldFloatingObject) {
- LayoutUnit oldLogicalBottom = logicalBottomForFloat(oldFloatingObject.get());
- if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(oldFloatingObject.get()) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(oldFloatingObject.get())) {
+ LayoutUnit oldLogicalBottom = logicalBottomForFloat(*oldFloatingObject);
+ if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(*oldFloatingObject) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(*oldFloatingObject)) {
changeLogicalTop = 0;
changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
} else {
@@ -281,7 +281,7 @@
changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
}
LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
- LayoutUnit oldLogicalTop = logicalTopForFloat(oldFloatingObject.get());
+ LayoutUnit oldLogicalTop = logicalTopForFloat(*oldFloatingObject);
if (logicalTop != oldLogicalTop) {
changeLogicalTop = std::min(changeLogicalTop, std::min(logicalTop, oldLogicalTop));
changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalTop, oldLogicalTop));
@@ -301,8 +301,8 @@
auto end = floatMap.end();
for (auto it = floatMap.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->value.get();
- if (!floatingObject->isDescendant()) {
+ const auto& floatingObject = *it->value.get();
+ if (!floatingObject.isDescendant()) {
changeLogicalTop = 0;
changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(floatingObject));
}
@@ -2154,15 +2154,16 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
auto end = floatingObjectSet.end();
for (auto it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ const auto& floatingObject = *it->get();
// Only repaint the object if it is overhanging, is not in its own layer, and
// is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
// condition is replaced with being a descendant of us.
+ auto& renderer = floatingObject.renderer();
if (logicalBottomForFloat(floatingObject) > logicalHeight()
- && !floatingObject->renderer().hasSelfPaintingLayer()
- && (floatingObject->shouldPaint() || (paintAllDescendants && floatingObject->renderer().isDescendantOf(this)))) {
- floatingObject->renderer().repaint();
- floatingObject->renderer().repaintOverhangingFloats(false);
+ && !renderer.hasSelfPaintingLayer()
+ && (floatingObject.shouldPaint() || (paintAllDescendants && renderer.isDescendantOf(this)))) {
+ renderer.repaint();
+ renderer.repaintOverhangingFloats(false);
}
}
}
@@ -2278,7 +2279,7 @@
floatBox.computeAndSetBlockDirectionMargins(this);
}
- setLogicalWidthForFloat(floatingObject.get(), logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
+ setLogicalWidthForFloat(*floatingObject, logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
return m_floatingObjects->add(WTF::move(floatingObject));
}
@@ -2289,7 +2290,7 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(floatBox);
if (it != floatingObjectSet.end()) {
- FloatingObject* floatingObject = it->get();
+ auto& floatingObject = *it->get();
if (childrenInline()) {
LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
@@ -2303,19 +2304,19 @@
// accomplished by pretending they have a height of 1.
logicalBottom = std::max(logicalBottom, logicalTop + 1);
}
- if (floatingObject->originatingLine()) {
- floatingObject->originatingLine()->removeFloat(floatBox);
+ if (floatingObject.originatingLine()) {
+ floatingObject.originatingLine()->removeFloat(floatBox);
if (!selfNeedsLayout()) {
- ASSERT(&floatingObject->originatingLine()->renderer() == this);
- floatingObject->originatingLine()->markDirty();
+ ASSERT(&floatingObject.originatingLine()->renderer() == this);
+ floatingObject.originatingLine()->markDirty();
}
#if !ASSERT_DISABLED
- floatingObject->setOriginatingLine(0);
+ floatingObject.setOriginatingLine(0);
#endif
}
markLinesDirtyInBlockRange(0, logicalBottom);
}
- m_floatingObjects->remove(floatingObject);
+ m_floatingObjects->remove(&floatingObject);
}
}
}
@@ -2327,7 +2328,7 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObject* curr = floatingObjectSet.last().get();
- while (curr != lastFloat && (!curr->isPlaced() || logicalTopForFloat(curr) >= logicalOffset)) {
+ while (curr != lastFloat && (!curr->isPlaced() || logicalTopForFloat(*curr) >= logicalOffset)) {
m_floatingObjects->remove(curr);
if (floatingObjectSet.isEmpty())
break;
@@ -2351,9 +2352,9 @@
return adjustLogicalRightOffsetForLine(offset, applyTextIndent);
}
-LayoutPoint RenderBlockFlow::computeLogicalLocationForFloat(const FloatingObject* floatingObject, LayoutUnit logicalTopOffset)
+LayoutPoint RenderBlockFlow::computeLogicalLocationForFloat(const FloatingObject& floatingObject, LayoutUnit logicalTopOffset)
{
- RenderBox& childBox = floatingObject->renderer();
+ auto& childBox = floatingObject.renderer();
LayoutUnit logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
LayoutUnit logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
@@ -2471,19 +2472,18 @@
// The float cannot start above the top position of the last positioned float.
if (lastPlacedFloatingObject)
- logicalTop = std::max(logicalTopForFloat(lastPlacedFloatingObject), logicalTop);
+ logicalTop = std::max(logicalTopForFloat(*lastPlacedFloatingObject), logicalTop);
auto end = floatingObjectSet.end();
// Now walk through the set of unpositioned floats and place them.
for (; it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ auto& floatingObject = *it->get();
// The containing block is responsible for positioning floats, so if we have floats in our
// list that come from somewhere else, do not attempt to position them.
- if (floatingObject->renderer().containingBlock() != this)
+ auto& childBox = floatingObject.renderer();
+ if (childBox.containingBlock() != this)
continue;
- RenderBox& childBox = floatingObject->renderer();
-
LayoutUnit childLogicalLeftMargin = style().isLeftToRightDirection() ? marginStartForChild(childBox) : marginEndForChild(childBox);
LayoutRect oldRect = childBox.frameRect();
@@ -2522,7 +2522,7 @@
}
if (newLogicalTop != floatLogicalLocation.y()) {
- floatingObject->setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
+ floatingObject.setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, newLogicalTop);
setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
@@ -2545,7 +2545,7 @@
setLogicalHeightForFloat(floatingObject, logicalHeightForChildForFragmentation(childBox) + marginBeforeForChild(childBox) + marginAfterForChild(childBox));
- m_floatingObjects->addPlacedObject(floatingObject);
+ m_floatingObjects->addPlacedObject(&floatingObject);
#if ENABLE(CSS_SHAPES)
if (ShapeOutsideInfo* shapeOutside = childBox.shapeOutsideInfo())
@@ -2620,8 +2620,8 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
auto end = floatingObjectSet.end();
for (auto it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- if (floatingObject->isPlaced() && floatingObject->type() & floatType)
+ const auto& floatingObject = *it->get();
+ if (floatingObject.isPlaced() && floatingObject.type() & floatType)
lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject));
}
return lowestFloatBottom;
@@ -2635,8 +2635,8 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
auto end = floatingObjectSet.end();
for (auto it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- if (floatingObject->isPlaced() && floatingObject->renderer().style().styleType() == FIRST_LETTER && floatingObject->renderer().style().initialLetterDrop() > 0)
+ const auto& floatingObject = *it->get();
+ if (floatingObject.isPlaced() && floatingObject.renderer().style().styleType() == FIRST_LETTER && floatingObject.renderer().style().initialLetterDrop() > 0)
lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject));
}
return lowestFloatBottom;
@@ -2656,14 +2656,14 @@
// overflow.
auto childEnd = child.m_floatingObjects->set().end();
for (auto childIt = child.m_floatingObjects->set().begin(); childIt != childEnd; ++childIt) {
- FloatingObject* floatingObject = childIt->get();
+ auto& floatingObject = *childIt->get();
LayoutUnit floatLogicalBottom = std::min(logicalBottomForFloat(floatingObject), LayoutUnit::max() - childLogicalTop);
LayoutUnit logicalBottom = childLogicalTop + floatLogicalBottom;
lowestFloatLogicalBottom = std::max(lowestFloatLogicalBottom, logicalBottom);
if (logicalBottom > logicalHeight()) {
// If the object is not in the list, we add it now.
- if (!containsFloat(floatingObject->renderer())) {
+ if (!containsFloat(floatingObject.renderer())) {
LayoutSize offset = isHorizontalWritingMode() ? LayoutSize(-childLogicalLeft, -childLogicalTop) : LayoutSize(-childLogicalTop, -childLogicalLeft);
bool shouldPaint = false;
@@ -2671,30 +2671,31 @@
// behaves properly). We always want to propagate the desire to paint the float as
// far out as we can, to the outermost block that overlaps the float, stopping only
// if we hit a self-painting layer boundary.
- if (floatingObject->renderer().enclosingFloatPaintingLayer() == enclosingFloatPaintingLayer()) {
- floatingObject->setShouldPaint(false);
+ if (floatingObject.renderer().enclosingFloatPaintingLayer() == enclosingFloatPaintingLayer()) {
+ floatingObject.setShouldPaint(false);
shouldPaint = true;
}
// We create the floating object list lazily.
if (!m_floatingObjects)
createFloatingObjects();
- m_floatingObjects->add(floatingObject->copyToNewContainer(offset, shouldPaint, true));
+ m_floatingObjects->add(floatingObject.copyToNewContainer(offset, shouldPaint, true));
}
} else {
- if (makeChildPaintOtherFloats && !floatingObject->shouldPaint() && !floatingObject->renderer().hasSelfPaintingLayer()
- && floatingObject->renderer().isDescendantOf(&child) && floatingObject->renderer().enclosingFloatPaintingLayer() == child.enclosingFloatPaintingLayer()) {
+ const auto& renderer = floatingObject.renderer();
+ if (makeChildPaintOtherFloats && !floatingObject.shouldPaint() && !renderer.hasSelfPaintingLayer()
+ && renderer.isDescendantOf(&child) && renderer.enclosingFloatPaintingLayer() == child.enclosingFloatPaintingLayer()) {
// The float is not overhanging from this block, so if it is a descendant of the child, the child should
// paint it (the other case is that it is intruding into the child), unless it has its own layer or enclosing
// layer.
// If makeChildPaintOtherFloats is false, it means that the child must already know about all the floats
// it should paint.
- floatingObject->setShouldPaint(true);
+ floatingObject.setShouldPaint(true);
}
// Since the float doesn't overhang, it didn't get put into our list. We need to add its overflow in to the child now.
- if (floatingObject->isDescendant())
- child.addOverflowFromChild(&floatingObject->renderer(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
+ if (floatingObject.isDescendant())
+ child.addOverflowFromChild(&renderer, LayoutSize(xPositionForFloatIncludingMargin(&floatingObject), yPositionForFloatIncludingMargin(&floatingObject)));
}
}
return lowestFloatLogicalBottom;
@@ -2706,11 +2707,11 @@
return false;
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
- auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(renderer);
+ const auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(renderer);
if (it == floatingObjectSet.end())
return false;
- return logicalBottomForFloat(it->get()) > logicalHeight();
+ return logicalBottomForFloat(*it->get()) > logicalHeight();
}
void RenderBlockFlow::addIntrudingFloats(RenderBlockFlow* prev, RenderBlockFlow* container, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
@@ -2730,9 +2731,9 @@
const FloatingObjectSet& prevSet = prev->m_floatingObjects->set();
auto prevEnd = prevSet.end();
for (auto prevIt = prevSet.begin(); prevIt != prevEnd; ++prevIt) {
- FloatingObject* floatingObject = prevIt->get();
+ auto& floatingObject = *prevIt->get();
if (logicalBottomForFloat(floatingObject) > logicalTopOffset) {
- if (!m_floatingObjects || !m_floatingObjects->set().contains<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject)) {
+ if (!m_floatingObjects || !m_floatingObjects->set().contains<FloatingObject&, FloatingObjectHashTranslator>(floatingObject)) {
// We create the floating object list lazily.
if (!m_floatingObjects)
createFloatingObjects();
@@ -2746,7 +2747,7 @@
? LayoutSize(logicalLeftOffset - (prev != container ? prev->marginLeft() : LayoutUnit()), logicalTopOffset)
: LayoutSize(logicalTopOffset, logicalLeftOffset - (prev != container ? prev->marginTop() : LayoutUnit()));
- m_floatingObjects->add(floatingObject->copyToNewContainer(offset));
+ m_floatingObjects->add(floatingObject.copyToNewContainer(offset));
}
}
}
Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.h (191233 => 191234)
--- trunk/Source/WebCore/rendering/RenderBlockFlow.h 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.h 2015-10-17 03:36:56 UTC (rev 191234)
@@ -297,41 +297,40 @@
const FloatingObjectSet* floatingObjectSet() const { return m_floatingObjects ? &m_floatingObjects->set() : nullptr; }
- LayoutUnit logicalTopForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? floatingObject->y() : floatingObject->x(); }
- LayoutUnit logicalBottomForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? floatingObject->maxY() : floatingObject->maxX(); }
- LayoutUnit logicalLeftForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? floatingObject->x() : floatingObject->y(); }
- LayoutUnit logicalRightForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? floatingObject->maxX() : floatingObject->maxY(); }
- LayoutUnit logicalWidthForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? floatingObject->width() : floatingObject->height(); }
- LayoutUnit logicalHeightForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? floatingObject->height() : floatingObject->width(); }
- LayoutSize logicalSizeForFloat(const FloatingObject* floatingObject) const { return isHorizontalWritingMode() ? LayoutSize(floatingObject->width(), floatingObject->height()) : LayoutSize(floatingObject->height(), floatingObject->width()); }
+ LayoutUnit logicalTopForFloat(const FloatingObject& floatingObject) const { return isHorizontalWritingMode() ? floatingObject.y() : floatingObject.x(); }
+ LayoutUnit logicalBottomForFloat(const FloatingObject& floatingObject) const { return isHorizontalWritingMode() ? floatingObject.maxY() : floatingObject.maxX(); }
+ LayoutUnit logicalLeftForFloat(const FloatingObject& floatingObject) const { return isHorizontalWritingMode() ? floatingObject.x() : floatingObject.y(); }
+ LayoutUnit logicalRightForFloat(const FloatingObject& floatingObject) const { return isHorizontalWritingMode() ? floatingObject.maxX() : floatingObject.maxY(); }
+ LayoutUnit logicalWidthForFloat(const FloatingObject& floatingObject) const { return isHorizontalWritingMode() ? floatingObject.width() : floatingObject.height(); }
+ LayoutUnit logicalHeightForFloat(const FloatingObject& floatingObject) const { return isHorizontalWritingMode() ? floatingObject.height() : floatingObject.width(); }
- void setLogicalTopForFloat(FloatingObject* floatingObject, LayoutUnit logicalTop)
+ void setLogicalTopForFloat(FloatingObject& floatingObject, LayoutUnit logicalTop)
{
if (isHorizontalWritingMode())
- floatingObject->setY(logicalTop);
+ floatingObject.setY(logicalTop);
else
- floatingObject->setX(logicalTop);
+ floatingObject.setX(logicalTop);
}
- void setLogicalLeftForFloat(FloatingObject* floatingObject, LayoutUnit logicalLeft)
+ void setLogicalLeftForFloat(FloatingObject& floatingObject, LayoutUnit logicalLeft)
{
if (isHorizontalWritingMode())
- floatingObject->setX(logicalLeft);
+ floatingObject.setX(logicalLeft);
else
- floatingObject->setY(logicalLeft);
+ floatingObject.setY(logicalLeft);
}
- void setLogicalHeightForFloat(FloatingObject* floatingObject, LayoutUnit logicalHeight)
+ void setLogicalHeightForFloat(FloatingObject& floatingObject, LayoutUnit logicalHeight)
{
if (isHorizontalWritingMode())
- floatingObject->setHeight(logicalHeight);
+ floatingObject.setHeight(logicalHeight);
else
- floatingObject->setWidth(logicalHeight);
+ floatingObject.setWidth(logicalHeight);
}
- void setLogicalWidthForFloat(FloatingObject* floatingObject, LayoutUnit logicalWidth)
+ void setLogicalWidthForFloat(FloatingObject& floatingObject, LayoutUnit logicalWidth)
{
if (isHorizontalWritingMode())
- floatingObject->setWidth(logicalWidth);
+ floatingObject.setWidth(logicalWidth);
else
- floatingObject->setHeight(logicalWidth);
+ floatingObject.setHeight(logicalWidth);
}
LayoutUnit xPositionForFloatIncludingMargin(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->x() + child->renderer().marginLeft() : child->x() + marginBeforeForChild(child->renderer()); }
@@ -490,7 +489,7 @@
FloatingObject* insertFloatingObject(RenderBox&);
void removeFloatingObject(RenderBox&);
void removeFloatingObjectsBelow(FloatingObject*, int logicalOffset);
- LayoutPoint computeLogicalLocationForFloat(const FloatingObject*, LayoutUnit logicalTopOffset);
+ LayoutPoint computeLogicalLocationForFloat(const FloatingObject&, LayoutUnit logicalTopOffset);
// Called from lineWidth, to position the floats added in the last line.
// Returns true if and only if it has positioned any floats.
Modified: trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp (191233 => 191234)
--- trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp 2015-10-17 03:36:56 UTC (rev 191234)
@@ -1255,7 +1255,7 @@
const InlineIterator oldEnd = end;
bool isNewUBAParagraph = layoutState.lineInfo().previousLineBrokeCleanly();
- FloatingObject* lastFloatFromPreviousLine = (containsFloats()) ? m_floatingObjects->set().last().get() : 0;
+ FloatingObject* lastFloatFromPreviousLine = (containsFloats()) ? m_floatingObjects->set().last().get() : nullptr;
WordMeasurements wordMeasurements;
end = lineBreaker.nextLineBreak(resolver, layoutState.lineInfo(), layoutState, renderTextInfo, lastFloatFromPreviousLine, consecutiveHyphenatedLines, wordMeasurements);
@@ -1898,7 +1898,7 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
auto end = floatingObjectSet.end();
for (auto it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ const auto& floatingObject = *it->get();
if (logicalBottomForFloat(floatingObject) >= logicalTop && logicalBottomForFloat(floatingObject) < logicalBottom)
return false;
}
@@ -2075,7 +2075,7 @@
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
ASSERT(floatingObjectSet.last().get() == &newFloat);
- LayoutUnit floatLogicalTop = logicalTopForFloat(&newFloat);
+ LayoutUnit floatLogicalTop = logicalTopForFloat(newFloat);
LayoutUnit paginationStrut = newFloat.paginationStrut();
if (floatLogicalTop - paginationStrut != logicalHeight() + lineInfo.floatPaginationStrut())
@@ -2086,15 +2086,15 @@
auto begin = floatingObjectSet.begin();
while (it != begin) {
--it;
- FloatingObject* floatingObject = it->get();
- if (floatingObject == lastFloatFromPreviousLine)
+ auto& floatingObject = *it->get();
+ if (&floatingObject == lastFloatFromPreviousLine)
break;
if (logicalTopForFloat(floatingObject) == logicalHeight() + lineInfo.floatPaginationStrut()) {
- floatingObject->setPaginationStrut(paginationStrut + floatingObject->paginationStrut());
- RenderBox& floatBox = floatingObject->renderer();
+ floatingObject.setPaginationStrut(paginationStrut + floatingObject.paginationStrut());
+ RenderBox& floatBox = floatingObject.renderer();
setLogicalTopForChild(floatBox, logicalTopForChild(floatBox) + marginBeforeForChild(floatBox) + paginationStrut);
- if (updateRegionRangeForBoxChild(floatingObject->renderer()))
+ if (updateRegionRangeForBoxChild(floatBox))
floatBox.setNeedsLayout(MarkOnlyThis);
else if (is<RenderBlock>(floatBox))
downcast<RenderBlock>(floatBox).setChildNeedsLayout(MarkOnlyThis);
@@ -2103,9 +2103,9 @@
// Save the old logical top before calling removePlacedObject which will set
// isPlaced to false. Otherwise it will trigger an assert in logicalTopForFloat.
LayoutUnit oldLogicalTop = logicalTopForFloat(floatingObject);
- m_floatingObjects->removePlacedObject(floatingObject);
+ m_floatingObjects->removePlacedObject(&floatingObject);
setLogicalTopForFloat(floatingObject, oldLogicalTop + paginationStrut);
- m_floatingObjects->addPlacedObject(floatingObject);
+ m_floatingObjects->addPlacedObject(&floatingObject);
}
}
Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (191233 => 191234)
--- trunk/Source/WebCore/rendering/RenderBox.cpp 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp 2015-10-17 03:36:56 UTC (rev 191234)
@@ -4447,7 +4447,7 @@
return LayoutRect(overflowMinX, overflowMinY, overflowMaxX - overflowMinX, overflowMaxY - overflowMinY);
}
-void RenderBox::addOverflowFromChild(RenderBox* child, const LayoutSize& delta)
+void RenderBox::addOverflowFromChild(const RenderBox* child, const LayoutSize& delta)
{
// Never allow flow threads to propagate overflow up to a parent.
if (child->isRenderFlowThread())
Modified: trunk/Source/WebCore/rendering/RenderBox.h (191233 => 191234)
--- trunk/Source/WebCore/rendering/RenderBox.h 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/RenderBox.h 2015-10-17 03:36:56 UTC (rev 191234)
@@ -204,8 +204,8 @@
void addVisualEffectOverflow();
LayoutRect applyVisualEffectOverflow(const LayoutRect&) const;
- void addOverflowFromChild(RenderBox* child) { addOverflowFromChild(child, child->locationOffset()); }
- void addOverflowFromChild(RenderBox* child, const LayoutSize& delta);
+ void addOverflowFromChild(const RenderBox* child) { addOverflowFromChild(child, child->locationOffset()); }
+ void addOverflowFromChild(const RenderBox* child, const LayoutSize& delta);
void updateLayerTransform();
Modified: trunk/Source/WebCore/rendering/line/BreakingContext.h (191233 => 191234)
--- trunk/Source/WebCore/rendering/line/BreakingContext.h 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/line/BreakingContext.h 2015-10-17 03:36:56 UTC (rev 191234)
@@ -444,12 +444,12 @@
inline void BreakingContext::handleFloat()
{
auto& floatBox = downcast<RenderBox>(*m_current.renderer());
- FloatingObject* floatingObject = m_lineBreaker.insertFloatingObject(floatBox);
+ const auto& floatingObject = *m_lineBreaker.insertFloatingObject(floatBox);
// check if it fits in the current line.
// If it does, position it now, otherwise, position
// it after moving to next line (in clearFloats() func)
if (m_floatsFitOnLine && m_width.fitsOnLineExcludingTrailingWhitespace(m_block.logicalWidthForFloat(floatingObject))) {
- m_lineBreaker.positionNewFloatOnLine(*floatingObject, m_lastFloatFromPreviousLine, m_lineInfo, m_width);
+ m_lineBreaker.positionNewFloatOnLine(floatingObject, m_lastFloatFromPreviousLine, m_lineInfo, m_width);
if (m_lineBreakHistory.renderer() == m_current.renderer()) {
ASSERT(!m_lineBreakHistory.offset());
m_lineBreakHistory.increment();
Modified: trunk/Source/WebCore/rendering/line/LineWidth.cpp (191233 => 191234)
--- trunk/Source/WebCore/rendering/line/LineWidth.cpp 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/line/LineWidth.cpp 2015-10-17 03:36:56 UTC (rev 191234)
@@ -79,7 +79,7 @@
static bool newFloatShrinksLine(const FloatingObject& newFloat, const RenderBlockFlow& block, bool isFirstLine)
{
LayoutUnit blockOffset = block.logicalHeight();
- if (blockOffset >= block.logicalTopForFloat(&newFloat) && blockOffset < block.logicalBottomForFloat(&newFloat))
+ if (blockOffset >= block.logicalTopForFloat(newFloat) && blockOffset < block.logicalBottomForFloat(newFloat))
return true;
// initial-letter float always shrinks the first line.
@@ -102,7 +102,7 @@
#endif
if (newFloat.type() == FloatingObject::FloatLeft) {
- float newLeft = m_block.logicalRightForFloat(&newFloat);
+ float newLeft = m_block.logicalRightForFloat(newFloat);
if (shouldIndentText() && m_block.style().isLeftToRightDirection())
newLeft += floorToInt(m_block.textIndentOffset());
#if ENABLE(CSS_SHAPES)
@@ -115,7 +115,7 @@
#endif
m_left = std::max<float>(m_left, newLeft);
} else {
- float newRight = m_block.logicalLeftForFloat(&newFloat);
+ float newRight = m_block.logicalLeftForFloat(newFloat);
if (shouldIndentText() && !m_block.style().isLeftToRightDirection())
newRight -= floorToInt(m_block.textIndentOffset());
#if ENABLE(CSS_SHAPES)
Modified: trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp (191233 => 191234)
--- trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp 2015-10-17 02:15:20 UTC (rev 191233)
+++ trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp 2015-10-17 03:36:56 UTC (rev 191234)
@@ -307,12 +307,12 @@
ShapeOutsideDeltas ShapeOutsideInfo::computeDeltasForContainingBlockLine(const RenderBlockFlow& containingBlock, const FloatingObject& floatingObject, LayoutUnit lineTop, LayoutUnit lineHeight)
{
ASSERT(lineHeight >= 0);
- LayoutUnit borderBoxTop = containingBlock.logicalTopForFloat(&floatingObject) + containingBlock.marginBeforeForChild(m_renderer);
+ LayoutUnit borderBoxTop = containingBlock.logicalTopForFloat(floatingObject) + containingBlock.marginBeforeForChild(m_renderer);
LayoutUnit borderBoxLineTop = lineTop - borderBoxTop;
if (isShapeDirty() || !m_shapeOutsideDeltas.isForLine(borderBoxLineTop, lineHeight)) {
LayoutUnit referenceBoxLineTop = borderBoxLineTop - logicalTopOffset();
- LayoutUnit floatMarginBoxWidth = std::max<LayoutUnit>(LayoutUnit(), containingBlock.logicalWidthForFloat(&floatingObject));
+ LayoutUnit floatMarginBoxWidth = std::max<LayoutUnit>(LayoutUnit(), containingBlock.logicalWidthForFloat(floatingObject));
if (computedShape().lineOverlapsShapeMarginBounds(referenceBoxLineTop, lineHeight)) {
LineSegment segment = computedShape().getExcludedInterval((borderBoxLineTop - logicalTopOffset()), std::min(lineHeight, shapeLogicalBottom() - borderBoxLineTop));