src/third_party/WebKit/Source/core/rendering/FloatingObjects.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2007 David Smith (catfish.man@gmail.com)
   5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
   6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "config.h"
  25 #include "core/rendering/FloatingObjects.h"
  26
  27 #include "core/rendering/RenderBlockFlow.h"
  28 #include "core/rendering/RenderBox.h"
  29 #include "core/rendering/RenderView.h"
  30
  31 using namespace WTF;
  32
  33 namespace blink {
  34
  35 struct SameSizeAsFloatingObject {
  36     void* pointers[2];
  37     LayoutRect rect;
  38     int paginationStrut;
  39     uint32_t bitfields : 8;
  40 };
  41
  42 COMPILE_ASSERT(sizeof(FloatingObject) == sizeof(SameSizeAsFloatingObject), FloatingObject_should_stay_small);
  43
  44 FloatingObject::FloatingObject(RenderBox* renderer)
  45     : m_renderer(renderer)
  46     , m_originatingLine(0)
  47     , m_paginationStrut(0)
  48     , m_shouldPaint(true)
  49     , m_isDescendant(false)
  50     , m_isPlaced(false)
  51 #if ENABLE(ASSERT)
  52     , m_isInPlacedTree(false)
  53 #endif
  54 {
  55     EFloat type = renderer->style()->floating();
  56     ASSERT(type != NoFloat);
  57     if (type == LeftFloat)
  58         m_type = FloatLeft;
  59     else if (type == RightFloat)
  60         m_type = FloatRight;
  61 }
  62
  63 FloatingObject::FloatingObject(RenderBox* renderer, Type type, const LayoutRect& frameRect, bool shouldPaint, bool isDescendant)
  64     : m_renderer(renderer)
  65     , m_originatingLine(0)
  66     , m_frameRect(frameRect)
  67     , m_paginationStrut(0)
  68     , m_type(type)
  69     , m_shouldPaint(shouldPaint)
  70     , m_isDescendant(isDescendant)
  71     , m_isPlaced(true)
  72 #if ENABLE(ASSERT)
  73     , m_isInPlacedTree(false)
  74 #endif
  75 {
  76 }
  77
  78 PassOwnPtr<FloatingObject> FloatingObject::create(RenderBox* renderer)
  79 {
  80     OwnPtr<FloatingObject> newObj = adoptPtr(new FloatingObject(renderer));
  81     newObj->setShouldPaint(!renderer->hasSelfPaintingLayer()); // If a layer exists, the float will paint itself. Otherwise someone else will.
  82     newObj->setIsDescendant(true);
  83
  84     return newObj.release();
  85 }
  86
  87 PassOwnPtr<FloatingObject> FloatingObject::copyToNewContainer(LayoutSize offset, bool shouldPaint, bool isDescendant) const
  88 {
  89     return adoptPtr(new FloatingObject(renderer(), type(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant));
  90 }
  91
  92 PassOwnPtr<FloatingObject> FloatingObject::unsafeClone() const
  93 {
  94     OwnPtr<FloatingObject> cloneObject = adoptPtr(new FloatingObject(renderer(), type(), m_frameRect, m_shouldPaint, m_isDescendant));
  95     cloneObject->m_paginationStrut = m_paginationStrut;
  96     cloneObject->m_isPlaced = m_isPlaced;
  97     return cloneObject.release();
  98 }
  99
 100 template <FloatingObject::Type FloatTypeValue>
 101 class ComputeFloatOffsetAdapter {
 102 public:
 103     typedef FloatingObjectInterval IntervalType;
 104
 105     ComputeFloatOffsetAdapter(const RenderBlockFlow* renderer, int lineTop, int lineBottom, LayoutUnit offset)
 106         : m_renderer(renderer)
 107         , m_lineTop(lineTop)
 108         , m_lineBottom(lineBottom)
 109         , m_offset(offset)
 110         , m_outermostFloat(0)
 111     {
 112     }
 113
 114     virtual ~ComputeFloatOffsetAdapter() { }
 115
 116     int lowValue() const { return m_lineTop; }
 117     int highValue() const { return m_lineBottom; }
 118     void collectIfNeeded(const IntervalType&);
 119
 120     LayoutUnit offset() const { return m_offset; }
 121
 122 protected:
 123     virtual bool updateOffsetIfNeeded(const FloatingObject&) = 0;
 124
 125     const RenderBlockFlow* m_renderer;
 126     int m_lineTop;
 127     int m_lineBottom;
 128     LayoutUnit m_offset;
 129     const FloatingObject* m_outermostFloat;
 130 };
 131
 132 template <FloatingObject::Type FloatTypeValue>
 133 class ComputeFloatOffsetForFloatLayoutAdapter : public ComputeFloatOffsetAdapter<FloatTypeValue> {
 134 public:
 135     ComputeFloatOffsetForFloatLayoutAdapter(const RenderBlockFlow* renderer, LayoutUnit lineTop, LayoutUnit lineBottom, LayoutUnit offset)
 136         : ComputeFloatOffsetAdapter<FloatTypeValue>(renderer, lineTop, lineBottom, offset)
 137     {
 138     }
 139
 140     virtual ~ComputeFloatOffsetForFloatLayoutAdapter() { }
 141
 142     LayoutUnit heightRemaining() const;
 143
 144 protected:
 145     virtual bool updateOffsetIfNeeded(const FloatingObject&) override final;
 146 };
 147
 148 template <FloatingObject::Type FloatTypeValue>
 149 class ComputeFloatOffsetForLineLayoutAdapter : public ComputeFloatOffsetAdapter<FloatTypeValue> {
 150 public:
 151     ComputeFloatOffsetForLineLayoutAdapter(const RenderBlockFlow* renderer, LayoutUnit lineTop, LayoutUnit lineBottom, LayoutUnit offset)
 152         : ComputeFloatOffsetAdapter<FloatTypeValue>(renderer, lineTop, lineBottom, offset)
 153     {
 154     }
 155
 156     virtual ~ComputeFloatOffsetForLineLayoutAdapter() { }
 157
 158 protected:
 159     virtual bool updateOffsetIfNeeded(const FloatingObject&) override final;
 160 };
 161
 162
 163 FloatingObjects::~FloatingObjects()
 164 {
 165 }
 166 void FloatingObjects::clearLineBoxTreePointers()
 167 {
 168     // Clear references to originating lines, since the lines are being deleted
 169     FloatingObjectSetIterator end = m_set.end();
 170     for (FloatingObjectSetIterator it = m_set.begin(); it != end; ++it) {
 171         ASSERT(!((*it)->originatingLine()) || (*it)->originatingLine()->renderer() == m_renderer);
 172         (*it)->setOriginatingLine(0);
 173     }
 174 }
 175
 176 FloatingObjects::FloatingObjects(const RenderBlockFlow* renderer, bool horizontalWritingMode)
 177     : m_placedFloatsTree(UninitializedTree)
 178     , m_leftObjectsCount(0)
 179     , m_rightObjectsCount(0)
 180     , m_horizontalWritingMode(horizontalWritingMode)
 181     , m_renderer(renderer)
 182     , m_cachedHorizontalWritingMode(false)
 183 {
 184 }
 185
 186 void FloatingObjects::clear()
 187 {
 188     m_set.clear();
 189     m_placedFloatsTree.clear();
 190     m_leftObjectsCount = 0;
 191     m_rightObjectsCount = 0;
 192     markLowestFloatLogicalBottomCacheAsDirty();
 193 }
 194
 195 LayoutUnit FloatingObjects::lowestFloatLogicalBottom(FloatingObject::Type floatType)
 196 {
 197     bool isInHorizontalWritingMode = m_horizontalWritingMode;
 198     if (floatType != FloatingObject::FloatLeftRight) {
 199         if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, floatType))
 200             return getCachedlowestFloatLogicalBottom(floatType);
 201     } else {
 202         if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatLeft) && hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatRight)) {
 203             return std::max(getCachedlowestFloatLogicalBottom(FloatingObject::FloatLeft),
 204                 getCachedlowestFloatLogicalBottom(FloatingObject::FloatRight));
 205         }
 206     }
 207
 208     LayoutUnit lowestFloatBottom = 0;
 209     const FloatingObjectSet& floatingObjectSet = set();
 210     FloatingObjectSetIterator end = floatingObjectSet.end();
 211     if (floatType == FloatingObject::FloatLeftRight) {
 212         LayoutUnit lowestFloatBottomLeft = 0;
 213         LayoutUnit lowestFloatBottomRight = 0;
 214         for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
 215             FloatingObject* floatingObject = it->get();
 216             if (floatingObject->isPlaced()) {
 217                 FloatingObject::Type curType = floatingObject->type();
 218                 LayoutUnit curFloatLogicalBottom = m_renderer->logicalBottomForFloat(floatingObject);
 219                 if (curType & FloatingObject::FloatLeft)
 220                     lowestFloatBottomLeft = std::max(lowestFloatBottomLeft, curFloatLogicalBottom);
 221                 if (curType & FloatingObject::FloatRight)
 222                     lowestFloatBottomRight = std::max(lowestFloatBottomRight, curFloatLogicalBottom);
 223             }
 224         }
 225         lowestFloatBottom = std::max(lowestFloatBottomLeft, lowestFloatBottomRight);
 226         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, FloatingObject::FloatLeft, lowestFloatBottomLeft);
 227         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, FloatingObject::FloatRight, lowestFloatBottomRight);
 228     } else {
 229         for (FloatingObjectSetIterator it = floatingObjectSet.begin(); it != end; ++it) {
 230             FloatingObject* floatingObject = it->get();
 231             if (floatingObject->isPlaced() && floatingObject->type() == floatType)
 232                 lowestFloatBottom = std::max(lowestFloatBottom, m_renderer->logicalBottomForFloat(floatingObject));
 233         }
 234         setCachedLowestFloatLogicalBottom(isInHorizontalWritingMode, floatType, lowestFloatBottom);
 235     }
 236
 237     return lowestFloatBottom;
 238 }
 239
 240 bool FloatingObjects::hasLowestFloatLogicalBottomCached(bool isHorizontal, FloatingObject::Type type) const
 241 {
 242     int floatIndex = static_cast<int>(type) - 1;
 243     ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) / sizeof(FloatBottomCachedValue)));
 244     ASSERT(floatIndex >= 0);
 245     return (m_cachedHorizontalWritingMode == isHorizontal && !m_lowestFloatBottomCache[floatIndex].dirty);
 246 }
 247
 248 LayoutUnit FloatingObjects::getCachedlowestFloatLogicalBottom(FloatingObject::Type type) const
 249 {
 250     int floatIndex = static_cast<int>(type) - 1;
 251     ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) / sizeof(FloatBottomCachedValue)));
 252     ASSERT(floatIndex >= 0);
 253     return m_lowestFloatBottomCache[floatIndex].value;
 254 }
 255
 256 void FloatingObjects::setCachedLowestFloatLogicalBottom(bool isHorizontal, FloatingObject::Type type, LayoutUnit value)
 257 {
 258     int floatIndex = static_cast<int>(type) - 1;
 259     ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) / sizeof(FloatBottomCachedValue)));
 260     ASSERT(floatIndex >= 0);
 261     m_cachedHorizontalWritingMode = isHorizontal;
 262     m_lowestFloatBottomCache[floatIndex].value = value;
 263     m_lowestFloatBottomCache[floatIndex].dirty = false;
 264 }
 265
 266 void FloatingObjects::markLowestFloatLogicalBottomCacheAsDirty()
 267 {
 268     for (size_t i = 0; i < sizeof(m_lowestFloatBottomCache) / sizeof(FloatBottomCachedValue); ++i)
 269         m_lowestFloatBottomCache[i].dirty = true;
 270 }
 271
 272 void FloatingObjects::moveAllToFloatInfoMap(RendererToFloatInfoMap& map)
 273 {
 274     while (!m_set.isEmpty()) {
 275         OwnPtr<FloatingObject> floatingObject = m_set.takeFirst();
 276         RenderBox* renderer = floatingObject->renderer();
 277         map.add(renderer, floatingObject.release());
 278     }
 279     clear();
 280 }
 281
 282 inline void FloatingObjects::increaseObjectsCount(FloatingObject::Type type)
 283 {
 284     if (type == FloatingObject::FloatLeft)
 285         m_leftObjectsCount++;
 286     else
 287         m_rightObjectsCount++;
 288 }
 289
 290 inline void FloatingObjects::decreaseObjectsCount(FloatingObject::Type type)
 291 {
 292     if (type == FloatingObject::FloatLeft)
 293         m_leftObjectsCount--;
 294     else
 295         m_rightObjectsCount--;
 296 }
 297
 298 inline FloatingObjectInterval FloatingObjects::intervalForFloatingObject(FloatingObject* floatingObject)
 299 {
 300     if (m_horizontalWritingMode)
 301         return FloatingObjectInterval(floatingObject->frameRect().pixelSnappedY(), floatingObject->frameRect().pixelSnappedMaxY(), floatingObject);
 302     return FloatingObjectInterval(floatingObject->frameRect().pixelSnappedX(), floatingObject->frameRect().pixelSnappedMaxX(), floatingObject);
 303 }
 304
 305 void FloatingObjects::addPlacedObject(FloatingObject* floatingObject)
 306 {
 307     ASSERT(!floatingObject->isInPlacedTree());
 308
 309     floatingObject->setIsPlaced(true);
 310     if (m_placedFloatsTree.isInitialized())
 311         m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
 312
 313 #if ENABLE(ASSERT)
 314     floatingObject->setIsInPlacedTree(true);
 315 #endif
 316     markLowestFloatLogicalBottomCacheAsDirty();
 317 }
 318
 319 void FloatingObjects::removePlacedObject(FloatingObject* floatingObject)
 320 {
 321     ASSERT(floatingObject->isPlaced() && floatingObject->isInPlacedTree());
 322
 323     if (m_placedFloatsTree.isInitialized()) {
 324         bool removed = m_placedFloatsTree.remove(intervalForFloatingObject(floatingObject));
 325         ASSERT_UNUSED(removed, removed);
 326     }
 327
 328     floatingObject->setIsPlaced(false);
 329 #if ENABLE(ASSERT)
 330     floatingObject->setIsInPlacedTree(false);
 331 #endif
 332     markLowestFloatLogicalBottomCacheAsDirty();
 333 }
 334
 335 FloatingObject* FloatingObjects::add(PassOwnPtr<FloatingObject> floatingObject)
 336 {
 337     FloatingObject* newObject = floatingObject.leakPtr();
 338     increaseObjectsCount(newObject->type());
 339     m_set.add(adoptPtr(newObject));
 340     if (newObject->isPlaced())
 341         addPlacedObject(newObject);
 342     markLowestFloatLogicalBottomCacheAsDirty();
 343     return newObject;
 344 }
 345
 346 void FloatingObjects::remove(FloatingObject* toBeRemoved)
 347 {
 348     decreaseObjectsCount(toBeRemoved->type());
 349     OwnPtr<FloatingObject> floatingObject = m_set.take(toBeRemoved);
 350     ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
 351     if (floatingObject->isPlaced())
 352         removePlacedObject(floatingObject.get());
 353     markLowestFloatLogicalBottomCacheAsDirty();
 354     ASSERT(!floatingObject->originatingLine());
 355 }
 356
 357 void FloatingObjects::computePlacedFloatsTree()
 358 {
 359     ASSERT(!m_placedFloatsTree.isInitialized());
 360     if (m_set.isEmpty())
 361         return;
 362     m_placedFloatsTree.initIfNeeded(m_renderer->view()->intervalArena());
 363     FloatingObjectSetIterator it = m_set.begin();
 364     FloatingObjectSetIterator end = m_set.end();
 365     for (; it != end; ++it) {
 366         FloatingObject* floatingObject = it->get();
 367         if (floatingObject->isPlaced())
 368             m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
 369     }
 370 }
 371
 372 LayoutUnit FloatingObjects::logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit *heightRemaining)
 373 {
 374     int logicalTopAsInt = roundToInt(logicalTop);
 375     ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
 376     placedFloatsTree().allOverlapsWithAdapter(adapter);
 377
 378     if (heightRemaining)
 379         *heightRemaining = adapter.heightRemaining();
 380
 381     return adapter.offset();
 382 }
 383
 384 LayoutUnit FloatingObjects::logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit *heightRemaining)
 385 {
 386     int logicalTopAsInt = roundToInt(logicalTop);
 387     ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatRight> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
 388     placedFloatsTree().allOverlapsWithAdapter(adapter);
 389
 390     if (heightRemaining)
 391         *heightRemaining = adapter.heightRemaining();
 392
 393     return std::min(fixedOffset, adapter.offset());
 394 }
 395
 396 LayoutUnit FloatingObjects::logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight)
 397 {
 398     ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
 399     placedFloatsTree().allOverlapsWithAdapter(adapter);
 400
 401     return adapter.offset();
 402 }
 403
 404 LayoutUnit FloatingObjects::logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight)
 405 {
 406     ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
 407     placedFloatsTree().allOverlapsWithAdapter(adapter);
 408
 409     return std::min(fixedOffset, adapter.offset());
 410 }
 411
 412 FloatingObjects::FloatBottomCachedValue::FloatBottomCachedValue()
 413     : value(0)
 414     , dirty(true)
 415 {
 416 }
 417
 418 inline static bool rangesIntersect(int floatTop, int floatBottom, int objectTop, int objectBottom)
 419 {
 420     if (objectTop >= floatBottom || objectBottom < floatTop)
 421         return false;
 422
 423     // The top of the object overlaps the float
 424     if (objectTop >= floatTop)
 425         return true;
 426
 427     // The object encloses the float
 428     if (objectTop < floatTop && objectBottom > floatBottom)
 429         return true;
 430
 431     // The bottom of the object overlaps the float
 432     if (objectBottom > objectTop && objectBottom > floatTop && objectBottom <= floatBottom)
 433         return true;
 434
 435     return false;
 436 }
 437
 438 template<>
 439 inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
 440 {
 441     LayoutUnit logicalRight = m_renderer->logicalRightForFloat(&floatingObject);
 442     if (logicalRight > m_offset) {
 443         m_offset = logicalRight;
 444         return true;
 445     }
 446     return false;
 447 }
 448
 449 template<>
 450 inline bool ComputeFloatOffsetForFloatLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
 451 {
 452     LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(&floatingObject);
 453     if (logicalLeft < m_offset) {
 454         m_offset = logicalLeft;
 455         return true;
 456     }
 457     return false;
 458 }
 459
 460 template <FloatingObject::Type FloatTypeValue>
 461 LayoutUnit ComputeFloatOffsetForFloatLayoutAdapter<FloatTypeValue>::heightRemaining() const
 462 {
 463     return this->m_outermostFloat ? this->m_renderer->logicalBottomForFloat(this->m_outermostFloat) - this->m_lineTop : LayoutUnit(1);
 464 }
 465
 466 template <FloatingObject::Type FloatTypeValue>
 467 inline void ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded(const IntervalType& interval)
 468 {
 469     const FloatingObject* floatingObject = interval.data();
 470     if (floatingObject->type() != FloatTypeValue || !rangesIntersect(interval.low(), interval.high(), m_lineTop, m_lineBottom))
 471         return;
 472
 473     // Make sure the float hasn't changed since it was added to the placed floats tree.
 474     ASSERT(floatingObject->isPlaced());
 475     ASSERT(interval.low() == m_renderer->pixelSnappedLogicalTopForFloat(floatingObject));
 476     ASSERT(interval.high() == m_renderer->pixelSnappedLogicalBottomForFloat(floatingObject));
 477
 478     bool floatIsNewExtreme = updateOffsetIfNeeded(*floatingObject);
 479     if (floatIsNewExtreme)
 480         m_outermostFloat = floatingObject;
 481 }
 482
 483 template<>
 484 inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
 485 {
 486     LayoutUnit logicalRight = m_renderer->logicalRightForFloat(&floatingObject);
 487     if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer()->shapeOutsideInfo()) {
 488         ShapeOutsideDeltas shapeDeltas = shapeOutside->computeDeltasForContainingBlockLine(*m_renderer, floatingObject, m_lineTop, m_lineBottom - m_lineTop);
 489         if (!shapeDeltas.lineOverlapsShape())
 490             return false;
 491
 492         logicalRight += shapeDeltas.rightMarginBoxDelta();
 493     }
 494     if (logicalRight > m_offset) {
 495         m_offset = logicalRight;
 496         return true;
 497     }
 498
 499     return false;
 500 }
 501
 502 template<>
 503 inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject& floatingObject)
 504 {
 505     LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(&floatingObject);
 506     if (ShapeOutsideInfo* shapeOutside = floatingObject.renderer()->shapeOutsideInfo()) {
 507         ShapeOutsideDeltas shapeDeltas = shapeOutside->computeDeltasForContainingBlockLine(*m_renderer, floatingObject, m_lineTop, m_lineBottom - m_lineTop);
 508         if (!shapeDeltas.lineOverlapsShape())
 509             return false;
 510
 511         logicalLeft += shapeDeltas.leftMarginBoxDelta();
 512     }
 513     if (logicalLeft < m_offset) {
 514         m_offset = logicalLeft;
 515         return true;
 516     }
 517
 518     return false;
 519 }
 520
 521 #ifndef NDEBUG
 522 // These helpers are only used by the PODIntervalTree for debugging purposes.
 523 String ValueToString<int>::string(const int value)
 524 {
 525     return String::number(value);
 526 }
 527
 528 String ValueToString<FloatingObject*>::string(const FloatingObject* floatingObject)
 529 {
 530     return String::format("%p (%dx%d %dx%d)", floatingObject, floatingObject->frameRect().pixelSnappedX(), floatingObject->frameRect().pixelSnappedY(), floatingObject->frameRect().pixelSnappedMaxX(), floatingObject->frameRect().pixelSnappedMaxY());
 531 }
 532 #endif
 533
 534
 535 } // namespace blink