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

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: Address Review Comments Created 5 years, 9 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
« Source/core/layout/FloatingObjects.cpp ('K') | « Source/core/layout/LayoutBlockFlow.h ('k') | Source/core/layout/LayoutBlockFlowLine.cpp » ('j') | Source/core/layout/LayoutBlockFlowLine.cpp » ('J')
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 68e73c032349a84b91bead0710179c84cd684fa5..4f73b03aa99afc4a7175fd276ffe495f80d7d6c1 100644
--- a/Source/core/layout/LayoutBlockFlow.cpp
+++ b/Source/core/layout/LayoutBlockFlow.cpp
@@ -956,12 +956,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());
+ FloatingObject& floatingObject = it->getReference();
+ 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 {
@@ -970,7 +970,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));
@@ -982,7 +982,7 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding()
oldFloatingObject->originatingLine()->markDirty();
}
- floatMap.remove(floatingObject->layoutObject());
+ floatMap.remove(floatingObject.layoutObject());
} else {
changeLogicalTop = 0;
changeLogicalBottom = std::max(changeLogicalBottom, logicalBottom);
@@ -995,7 +995,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.get()));
}
}
@@ -1784,7 +1784,7 @@ void LayoutBlockFlow::addOverflowFromFloats()
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
FloatingObject* floatingObject = it->get();
Julien - ping for review 2015/03/16 15:27:54 This should be a const reference.
Sunil Ratnu 2015/03/17 11:31:19 Done.
if (floatingObject->isDescendant())
- addOverflowFromChild(floatingObject->layoutObject(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
+ addOverflowFromChild(floatingObject->layoutObject(), LayoutSize(xPositionForFloatIncludingMargin(*floatingObject), yPositionForFloatIncludingMargin(*floatingObject)));
}
}
@@ -2075,15 +2075,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();
+ FloatingObject& floatingObject = it->getReference();
// 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* floatingRenderer = floatingObject->layoutObject();
+ LayoutBox* floatingRenderer = floatingObject.layoutObject();
floatingRenderer->setShouldDoFullPaintInvalidation();
floatingRenderer->invalidatePaintForOverhangingFloats(false);
}
@@ -2155,7 +2155,7 @@ void LayoutBlockFlow::clipOutFloatingObjects(const LayoutBlock* rootBlock, const
for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
FloatingObject* floatingObject = it->get();
LayoutRect floatBox(LayoutPoint(offsetFromRootBlock), floatingObject->layoutObject()->size());
- floatBox.move(positionForFloatIncludingMargin(floatingObject));
+ floatBox.move(positionForFloatIncludingMargin(*floatingObject));
rootBlock->flipForWritingMode(floatBox);
floatBox.move(rootBlockPhysicalPosition.x(), rootBlockPhysicalPosition.y());
@@ -2201,7 +2201,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;
@@ -2210,8 +2210,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
@@ -2257,7 +2257,7 @@ LayoutPoint LayoutBlockFlow::computeLogicalLocationForFloat(const FloatingObject
LayoutUnit logicalRightOffset; // Constant part of right offset.
logicalRightOffset = logicalRightOffsetForContent();
- LayoutUnit floatLogicalWidth = std::min(logicalWidthForFloat(floatingObject), logicalRightOffset - logicalLeftOffset); // The width we look for.
+ LayoutUnit floatLogicalWidth = std::min(logicalWidthForFloat(*floatingObject), logicalRightOffset - logicalLeftOffset); // The width we look for.
LayoutUnit floatLogicalLeft;
@@ -2274,7 +2274,7 @@ LayoutPoint LayoutBlockFlow::computeLogicalLocationForFloat(const FloatingObject
// Have to re-evaluate all of our offsets, since they may have changed.
logicalRightOffset = logicalRightOffsetForContent(); // Constant part of right offset.
logicalLeftOffset = logicalLeftOffsetForContent(); // Constant part of left offset.
- floatLogicalWidth = std::min(logicalWidthForFloat(floatingObject), logicalRightOffset - logicalLeftOffset);
+ floatLogicalWidth = std::min(logicalWidthForFloat(*floatingObject), logicalRightOffset - logicalLeftOffset);
Julien - ping for review 2015/03/16 15:27:54 |floatingObject| should be a reference here too. I
Sunil Ratnu 2015/03/17 11:31:19 Done.
}
}
floatLogicalLeft = std::max(logicalLeftOffset - borderAndPaddingLogicalLeft(), floatLogicalLeft);
@@ -2289,13 +2289,13 @@ LayoutPoint LayoutBlockFlow::computeLogicalLocationForFloat(const FloatingObject
// Have to re-evaluate all of our offsets, since they may have changed.
logicalRightOffset = logicalRightOffsetForContent(); // Constant part of right offset.
logicalLeftOffset = logicalLeftOffsetForContent(); // Constant part of left offset.
- floatLogicalWidth = std::min(logicalWidthForFloat(floatingObject), logicalRightOffset - logicalLeftOffset);
+ floatLogicalWidth = std::min(logicalWidthForFloat(*floatingObject), logicalRightOffset - logicalLeftOffset);
}
}
// Use the original width of the float here, since the local variable
// |floatLogicalWidth| was capped to the available line width. See
// fast/block/float/clamped-right-float.html.
- floatLogicalLeft -= logicalWidthForFloat(floatingObject);
+ floatLogicalLeft -= logicalWidthForFloat(*floatingObject);
}
return LayoutPoint(floatLogicalLeft, logicalTopOffset);
@@ -2334,7 +2334,7 @@ FloatingObject* LayoutBlockFlow::insertFloatingObject(LayoutBox& floatBox)
floatBox.computeAndSetBlockDirectionMargins(this);
}
- setLogicalWidthForFloat(newObj.get(), logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
+ setLogicalWidthForFloat(*newObj.get(), logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
Julien - ping for review 2015/03/16 15:27:54 *newObj should work and is shorter and safer (ther
Sunil Ratnu 2015/03/17 11:31:19 Done.
return m_floatingObjects->add(newObj.release());
}
@@ -2345,7 +2345,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->getReference();
if (childrenInline()) {
LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
@@ -2359,18 +2359,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(0);
+ floatingObject.setOriginatingLine(0);
#endif
}
markLinesDirtyInBlockRange(0, logicalBottom);
}
- m_floatingObjects->remove(floatingObject);
+ m_floatingObjects->remove(&floatingObject);
}
}
}
@@ -2382,7 +2382,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;
@@ -2423,18 +2423,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->getReference();
// 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();
@@ -2445,7 +2445,7 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width)
if (childBox->style()->clear() & CRIGHT)
logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatRight), logicalTop);
- LayoutPoint floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, logicalTop);
+ LayoutPoint floatLogicalLocation = computeLogicalLocationForFloat(&floatingObject, logicalTop);
setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
@@ -2475,9 +2475,9 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width)
}
if (newLogicalTop != floatLogicalLocation.y()) {
- floatingObject->setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
+ floatingObject.setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
- floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, newLogicalTop);
+ floatLogicalLocation = computeLogicalLocationForFloat(&floatingObject, newLogicalTop);
setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
setLogicalLeftForChild(*childBox, floatLogicalLocation.x() + childLogicalLeftMargin);
@@ -2493,7 +2493,7 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width)
setLogicalHeightForFloat(floatingObject, logicalHeightForChild(*childBox) + marginBeforeForChild(*childBox) + marginAfterForChild(*childBox));
- m_floatingObjects->addPlacedObject(floatingObject);
+ m_floatingObjects->addPlacedObject(&floatingObject);
if (ShapeOutsideInfo* shapeOutside = childBox->shapeOutsideInfo())
shapeOutside->setReferenceBoxLogicalSize(logicalSizeForChild(*childBox));
@@ -2514,7 +2514,7 @@ bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* renderer)
if (it == floatingObjectSet.end())
return false;
- return logicalBottomForFloat(it->get()) > logicalHeight();
+ return logicalBottomForFloat(it->getReference()) > logicalHeight();
}
void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
@@ -2535,7 +2535,7 @@ void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logic
FloatingObjectSetIterator prevEnd = prevSet.end();
for (FloatingObjectSetIterator prevIt = prevSet.begin(); prevIt != prevEnd; ++prevIt) {
FloatingObject* floatingObject = prevIt->get();
- if (logicalBottomForFloat(floatingObject) > logicalTopOffset) {
+ if (logicalBottomForFloat(*floatingObject) > logicalTopOffset) {
if (!m_floatingObjects || !m_floatingObjects->set().contains(floatingObject)) {
// We create the floating object list lazily.
if (!m_floatingObjects)
@@ -2569,13 +2569,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->getReference();
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;
@@ -2583,31 +2583,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->setShouldPaint(false);
+ if (floatingObject.layoutObject()->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->layoutObject()->hasSelfPaintingLayer()
- && floatingObject->layoutObject()->isDescendantOf(child) && floatingObject->layoutObject()->enclosingFloatPaintingLayer() == child->enclosingFloatPaintingLayer()) {
+ if (makeChildPaintOtherFloats && !floatingObject.shouldPaint() && !floatingObject.layoutObject()->hasSelfPaintingLayer()
+ && 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)));
}
}
}
@@ -2629,11 +2629,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();
+ FloatingObject& floatingObject = it->getReference();
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;
@@ -2660,12 +2660,12 @@ bool LayoutBlockFlow::hitTestFloats(const HitTestRequest& request, HitTestResult
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();
+ FloatingObject& floatingObject = it->getReference();
+ 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(request, result, locationInContainer, childPoint)) {
+ if (floatingObject.layoutObject()->hitTest(request, result, locationInContainer, childPoint)) {
updateHitTestResult(result, locationInContainer.point() - toLayoutSize(childPoint));
return true;
}
« Source/core/layout/FloatingObjects.cpp ('K') | « Source/core/layout/LayoutBlockFlow.h ('k') | Source/core/layout/LayoutBlockFlowLine.cpp » ('j') | Source/core/layout/LayoutBlockFlowLine.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698