Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(211)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: Source/core/layout/LayoutBlockFlow.cpp

Issue 763173003: Convert RenderBlockFlow code to use FloatingObject references (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Rebase Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « Source/core/layout/LayoutBlockFlow.h ('k') | Source/core/layout/LayoutBlockFlowLine.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/core/layout/LayoutBlockFlow.cpp
diff --git a/Source/core/layout/LayoutBlockFlow.cpp b/Source/core/layout/LayoutBlockFlow.cpp
index 3360bd50a169fe2bc85ba98fcef76f0ae1a2371f..b3ad2835b640d6c601ca232ca6b6dc2226c49e9a 100644
--- a/Source/core/layout/LayoutBlockFlow.cpp
+++ b/Source/core/layout/LayoutBlockFlow.cpp
@@ -841,9 +841,9 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding()
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator end = floatingObjectSet.end();
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- if (!floatingObject->isDescendant())
- oldIntrudingFloatSet.add(floatingObject->layoutObject());
+ const FloatingObject& floatingObject = *it->get();
+ if (!floatingObject.isDescendant())
+ oldIntrudingFloatSet.add(floatingObject.layoutObject());
}
}
@@ -906,12 +906,12 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding()
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator end = floatingObjectSet.end();
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- FloatingObject* oldFloatingObject = floatMap.get(floatingObject->layoutObject());
+ const FloatingObject& floatingObject = *it->get();
+ FloatingObject* oldFloatingObject = floatMap.get(floatingObject.layoutObject());
LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
if (oldFloatingObject) {
- LayoutUnit oldLogicalBottom = logicalBottomForFloat(oldFloatingObject);
- if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(oldFloatingObject) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(oldFloatingObject)) {
+ LayoutUnit oldLogicalBottom = logicalBottomForFloat(*oldFloatingObject);
+ if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(*oldFloatingObject) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(*oldFloatingObject)) {
changeLogicalTop = 0;
changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
} else {
@@ -920,7 +920,7 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding()
changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
}
LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
- LayoutUnit oldLogicalTop = logicalTopForFloat(oldFloatingObject);
+ LayoutUnit oldLogicalTop = logicalTopForFloat(*oldFloatingObject);
if (logicalTop != oldLogicalTop) {
changeLogicalTop = std::min(changeLogicalTop, std::min(logicalTop, oldLogicalTop));
changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalTop, oldLogicalTop));
@@ -932,7 +932,7 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding()
oldFloatingObject->originatingLine()->markDirty();
}
- floatMap.remove(floatingObject->layoutObject());
+ floatMap.remove(floatingObject.layoutObject());
} else {
changeLogicalTop = 0;
changeLogicalBottom = std::max(changeLogicalBottom, logicalBottom);
@@ -945,7 +945,7 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding()
OwnPtr<FloatingObject>& floatingObject = it->value;
if (!floatingObject->isDescendant()) {
changeLogicalTop = 0;
- changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(floatingObject.get()));
+ changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(*floatingObject));
}
}
@@ -1722,9 +1722,9 @@ void LayoutBlockFlow::addOverflowFromFloats()
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator end = floatingObjectSet.end();
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- if (floatingObject->isDescendant())
- addOverflowFromChild(floatingObject->layoutObject(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
+ const FloatingObject& floatingObject = *it->get();
+ if (floatingObject.isDescendant())
+ addOverflowFromChild(floatingObject.layoutObject(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
}
}
@@ -1990,13 +1990,13 @@ void LayoutBlockFlow::moveAllChildrenIncludingFloatsTo(LayoutBlock* toBlock, boo
FloatingObjectSetIterator end = fromFloatingObjectSet.end();
for (FloatingObjectSetIterator it = fromFloatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ const FloatingObject& floatingObject = *it->get();
// Don't insert the object again if it's already in the list
- if (toBlockFlow->containsFloat(floatingObject->layoutObject()))
+ if (toBlockFlow->containsFloat(floatingObject.layoutObject()))
continue;
- toBlockFlow->m_floatingObjects->add(floatingObject->unsafeClone());
+ toBlockFlow->m_floatingObjects->add(floatingObject.unsafeClone());
}
}
@@ -2012,15 +2012,15 @@ void LayoutBlockFlow::invalidatePaintForOverhangingFloats(bool paintAllDescendan
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator end = floatingObjectSet.end();
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ const FloatingObject& floatingObject = *it->get();
// Only issue paint invaldiations for 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.
if (logicalBottomForFloat(floatingObject) > logicalHeight()
- && !floatingObject->layoutObject()->hasSelfPaintingLayer()
- && (floatingObject->shouldPaint() || (paintAllDescendants && floatingObject->layoutObject()->isDescendantOf(this)))) {
+ && !floatingObject.layoutObject()->hasSelfPaintingLayer()
+ && (floatingObject.shouldPaint() || (paintAllDescendants && floatingObject.layoutObject()->isDescendantOf(this)))) {
- LayoutBox* floatingLayoutBox = floatingObject->layoutObject();
+ LayoutBox* floatingLayoutBox = floatingObject.layoutObject();
floatingLayoutBox->setShouldDoFullPaintInvalidation();
floatingLayoutBox->invalidatePaintForOverhangingFloats(false);
}
@@ -2088,8 +2088,8 @@ void LayoutBlockFlow::clipOutFloatingObjects(const LayoutBlock* rootBlock, ClipS
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator end = floatingObjectSet.end();
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
- LayoutRect floatBox(LayoutPoint(offsetFromRootBlock), floatingObject->layoutObject()->size());
+ const FloatingObject& floatingObject = *it->get();
+ LayoutRect floatBox(LayoutPoint(offsetFromRootBlock), floatingObject.layoutObject()->size());
floatBox.move(positionForFloatIncludingMargin(floatingObject));
rootBlock->flipForWritingMode(floatBox);
floatBox.move(rootBlockPhysicalPosition.x(), rootBlockPhysicalPosition.y());
@@ -2134,7 +2134,7 @@ void LayoutBlockFlow::removeFloatingObjects()
m_floatingObjects->clear();
}
-LayoutPoint LayoutBlockFlow::flipFloatForWritingModeForChild(const FloatingObject* child, const LayoutPoint& point) const
+LayoutPoint LayoutBlockFlow::flipFloatForWritingModeForChild(const FloatingObject& child, const LayoutPoint& point) const
{
if (!style()->isFlippedBlocksWritingMode())
return point;
@@ -2143,8 +2143,8 @@ LayoutPoint LayoutBlockFlow::flipFloatForWritingModeForChild(const FloatingObjec
// it's going to get added back in. We hide this complication here so that the calling code looks normal for the unflipped
// case.
if (isHorizontalWritingMode())
- return LayoutPoint(point.x(), point.y() + size().height() - child->layoutObject()->size().height() - 2 * yPositionForFloatIncludingMargin(child));
- return LayoutPoint(point.x() + size().width() - child->layoutObject()->size().width() - 2 * xPositionForFloatIncludingMargin(child), point.y());
+ return LayoutPoint(point.x(), point.y() + size().height() - child.layoutObject()->size().height() - 2 * yPositionForFloatIncludingMargin(child));
+ return LayoutPoint(point.x() + size().width() - child.layoutObject()->size().width() - 2 * xPositionForFloatIncludingMargin(child), point.y());
}
LayoutUnit LayoutBlockFlow::logicalLeftOffsetForPositioningFloat(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
@@ -2183,9 +2183,9 @@ LayoutUnit LayoutBlockFlow::adjustLogicalRightOffsetForLine(LayoutUnit offsetFro
return right;
}
-LayoutPoint LayoutBlockFlow::computeLogicalLocationForFloat(const FloatingObject* floatingObject, LayoutUnit logicalTopOffset) const
+LayoutPoint LayoutBlockFlow::computeLogicalLocationForFloat(const FloatingObject& floatingObject, LayoutUnit logicalTopOffset) const
{
- LayoutBox* childBox = floatingObject->layoutObject();
+ LayoutBox* childBox = floatingObject.layoutObject();
LayoutUnit logicalLeftOffset = logicalLeftOffsetForContent(); // Constant part of left offset.
LayoutUnit logicalRightOffset; // Constant part of right offset.
logicalRightOffset = logicalRightOffsetForContent();
@@ -2267,7 +2267,7 @@ FloatingObject* LayoutBlockFlow::insertFloatingObject(LayoutBox& floatBox)
floatBox.computeAndSetBlockDirectionMargins(this);
}
- setLogicalWidthForFloat(newObj.get(), logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
+ setLogicalWidthForFloat(*newObj, logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
return m_floatingObjects->add(newObj.release());
}
@@ -2278,7 +2278,7 @@ void LayoutBlockFlow::removeFloatingObject(LayoutBox* floatBox)
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator it = floatingObjectSet.find<FloatingObjectHashTranslator>(floatBox);
if (it != floatingObjectSet.end()) {
- FloatingObject* floatingObject = it->get();
+ FloatingObject& floatingObject = *it->get();
if (childrenInline()) {
LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
@@ -2292,18 +2292,18 @@ void LayoutBlockFlow::removeFloatingObject(LayoutBox* floatBox)
// accomplished by pretending they have a height of 1.
logicalBottom = std::max(logicalBottom, logicalTop + 1);
}
- if (floatingObject->originatingLine()) {
+ if (floatingObject.originatingLine()) {
if (!selfNeedsLayout()) {
- ASSERT(floatingObject->originatingLine()->layoutObject() == this);
- floatingObject->originatingLine()->markDirty();
+ ASSERT(floatingObject.originatingLine()->layoutObject() == this);
+ floatingObject.originatingLine()->markDirty();
}
#if ENABLE(ASSERT)
- floatingObject->setOriginatingLine(nullptr);
+ floatingObject.setOriginatingLine(nullptr);
#endif
}
markLinesDirtyInBlockRange(0, logicalBottom);
}
- m_floatingObjects->remove(floatingObject);
+ m_floatingObjects->remove(&floatingObject);
}
}
}
@@ -2315,7 +2315,7 @@ void LayoutBlockFlow::removeFloatingObjectsBelow(FloatingObject* lastFloat, int
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;
@@ -2356,18 +2356,18 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width)
// 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);
FloatingObjectSetIterator end = floatingObjectSet.end();
// Now walk through the set of unpositioned floats and place them.
for (; it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ FloatingObject& 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->layoutObject()->containingBlock() != this)
+ if (floatingObject.layoutObject()->containingBlock() != this)
continue;
- LayoutBox* childBox = floatingObject->layoutObject();
+ LayoutBox* childBox = floatingObject.layoutObject();
// FIXME Investigate if this can be removed. crbug.com/370006
childBox->setMayNeedPaintInvalidation();
@@ -2408,7 +2408,7 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width)
}
if (newLogicalTop != floatLogicalLocation.y()) {
- floatingObject->setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
+ floatingObject.setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, newLogicalTop);
setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
@@ -2447,7 +2447,7 @@ bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* layoutBox)
if (it == floatingObjectSet.end())
return false;
- return logicalBottomForFloat(it->get()) > logicalHeight();
+ return logicalBottomForFloat(*it->get()) > logicalHeight();
}
void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
@@ -2467,9 +2467,9 @@ void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logic
const FloatingObjectSet& prevSet = prev->m_floatingObjects->set();
FloatingObjectSetIterator prevEnd = prevSet.end();
for (FloatingObjectSetIterator prevIt = prevSet.begin(); prevIt != prevEnd; ++prevIt) {
- FloatingObject* floatingObject = prevIt->get();
+ FloatingObject& floatingObject = *prevIt->get();
if (logicalBottomForFloat(floatingObject) > logicalTopOffset) {
- if (!m_floatingObjects || !m_floatingObjects->set().contains(floatingObject)) {
+ if (!m_floatingObjects || !m_floatingObjects->set().contains(&floatingObject)) {
// We create the floating object list lazily.
if (!m_floatingObjects)
createFloatingObjects();
@@ -2483,7 +2483,7 @@ void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logic
? LayoutSize(logicalLeftOffset - (prev != parent() ? prev->marginLeft() : LayoutUnit()), logicalTopOffset)
: LayoutSize(logicalTopOffset, logicalLeftOffset - (prev != parent() ? prev->marginTop() : LayoutUnit()));
- m_floatingObjects->add(floatingObject->copyToNewContainer(offset));
+ m_floatingObjects->add(floatingObject.copyToNewContainer(offset));
}
}
}
@@ -2502,13 +2502,13 @@ void LayoutBlockFlow::addOverhangingFloats(LayoutBlockFlow* child, bool makeChil
// overflow.
FloatingObjectSetIterator childEnd = child->m_floatingObjects->set().end();
for (FloatingObjectSetIterator childIt = child->m_floatingObjects->set().begin(); childIt != childEnd; ++childIt) {
- FloatingObject* floatingObject = childIt->get();
+ FloatingObject& floatingObject = *childIt->get();
LayoutUnit logicalBottomForFloat = std::min(this->logicalBottomForFloat(floatingObject), LayoutUnit::max() - childLogicalTop);
LayoutUnit logicalBottom = childLogicalTop + logicalBottomForFloat;
if (logicalBottom > logicalHeight()) {
// If the object is not in the list, we add it now.
- if (!containsFloat(floatingObject->layoutObject())) {
+ if (!containsFloat(floatingObject.layoutObject())) {
LayoutSize offset = isHorizontalWritingMode() ? LayoutSize(-childLogicalLeft, -childLogicalTop) : LayoutSize(-childLogicalTop, -childLogicalLeft);
bool shouldPaint = false;
@@ -2516,31 +2516,31 @@ void LayoutBlockFlow::addOverhangingFloats(LayoutBlockFlow* child, bool makeChil
// 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->layoutObject()->enclosingFloatPaintingLayer() == enclosingFloatPaintingLayer() && !floatingObject->isLowestNonOverhangingFloatInChild()) {
- floatingObject->setShouldPaint(false);
+ if (floatingObject.layoutObject()->enclosingFloatPaintingLayer() == enclosingFloatPaintingLayer() && !floatingObject.isLowestNonOverhangingFloatInChild()) {
+ 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->layoutObject()->hasSelfPaintingLayer() && !floatingObject->isLowestNonOverhangingFloatInChild()
- && floatingObject->layoutObject()->isDescendantOf(child) && floatingObject->layoutObject()->enclosingFloatPaintingLayer() == child->enclosingFloatPaintingLayer()) {
+ if (makeChildPaintOtherFloats && !floatingObject.shouldPaint() && !floatingObject.layoutObject()->hasSelfPaintingLayer() && !floatingObject.isLowestNonOverhangingFloatInChild()
+ && floatingObject.layoutObject()->isDescendantOf(child) && floatingObject.layoutObject()->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 go ahead and add its overflow in to the
// child now.
- if (floatingObject->isDescendant())
- child->addOverflowFromChild(floatingObject->layoutObject(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
+ if (floatingObject.isDescendant())
+ child->addOverflowFromChild(floatingObject.layoutObject(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
}
}
}
@@ -2562,11 +2562,11 @@ LayoutUnit LayoutBlockFlow::nextFloatLogicalBottomBelow(LayoutUnit logicalHeight
const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
FloatingObjectSetIterator end = floatingObjectSet.end();
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
- FloatingObject* floatingObject = it->get();
+ const FloatingObject& floatingObject = *it->get();
LayoutUnit floatLogicalBottom = logicalBottomForFloat(floatingObject);
- ShapeOutsideInfo* shapeOutside = floatingObject->layoutObject()->shapeOutsideInfo();
+ ShapeOutsideInfo* shapeOutside = floatingObject.layoutObject()->shapeOutsideInfo();
if (shapeOutside && (offsetMode == ShapeOutsideFloatShapeOffset)) {
- LayoutUnit shapeLogicalBottom = logicalTopForFloat(floatingObject) + marginBeforeForChild(*(floatingObject->layoutObject())) + shapeOutside->shapeLogicalBottom();
+ LayoutUnit shapeLogicalBottom = logicalTopForFloat(floatingObject) + marginBeforeForChild(*floatingObject.layoutObject()) + shapeOutside->shapeLogicalBottom();
// Use the shapeLogicalBottom unless it extends outside of the margin box, in which case it is clipped.
if (shapeLogicalBottom < floatLogicalBottom)
floatLogicalBottom = shapeLogicalBottom;
@@ -2593,12 +2593,12 @@ bool LayoutBlockFlow::hitTestFloats(HitTestResult& result, const HitTestLocation
FloatingObjectSetIterator begin = floatingObjectSet.begin();
for (FloatingObjectSetIterator it = floatingObjectSet.end(); it != begin;) {
--it;
- FloatingObject* floatingObject = it->get();
- if (floatingObject->shouldPaint() && !floatingObject->layoutObject()->hasSelfPaintingLayer()) {
- LayoutUnit xOffset = xPositionForFloatIncludingMargin(floatingObject) - floatingObject->layoutObject()->location().x();
- LayoutUnit yOffset = yPositionForFloatIncludingMargin(floatingObject) - floatingObject->layoutObject()->location().y();
+ const FloatingObject& floatingObject = *it->get();
+ if (floatingObject.shouldPaint() && !floatingObject.layoutObject()->hasSelfPaintingLayer()) {
+ LayoutUnit xOffset = xPositionForFloatIncludingMargin(floatingObject) - floatingObject.layoutObject()->location().x();
+ LayoutUnit yOffset = yPositionForFloatIncludingMargin(floatingObject) - floatingObject.layoutObject()->location().y();
LayoutPoint childPoint = flipFloatForWritingModeForChild(floatingObject, adjustedLocation + LayoutSize(xOffset, yOffset));
- if (floatingObject->layoutObject()->hitTest(result, locationInContainer, childPoint)) {
+ if (floatingObject.layoutObject()->hitTest(result, locationInContainer, childPoint)) {
updateHitTestResult(result, locationInContainer.point() - toLayoutSize(childPoint));
return true;
}
« no previous file with comments | « Source/core/layout/LayoutBlockFlow.h ('k') | Source/core/layout/LayoutBlockFlowLine.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698