Track intruding and overhanging floats

Source/core/rendering/FloatingObjects.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 34 matching lines @@
 FloatingObject::FloatingObject(RenderBox* renderer)
     : m_renderer(renderer)
     , m_originatingLine(0)
     , m_paginationStrut(0)
     , m_shouldPaint(true)
     , m_isDescendant(false)
     , m_isPlaced(false)
 #ifndef NDEBUG
     , m_isInPlacedTree(false)
 #endif
+    , m_isOverhangingOrIntruding(false)
 {
     EFloat type = renderer->style()->floating();
     ASSERT(type != NoFloat);
     if (type == LeftFloat)
         m_type = FloatLeft;
     else if (type == RightFloat)
         m_type = FloatRight;
 }
 
 FloatingObject::FloatingObject(RenderBox* renderer, Type type, const LayoutRect& frameRect, bool shouldPaint, bool isDescendant)
     : m_renderer(renderer)
     , m_originatingLine(0)
     , m_frameRect(frameRect)
     , m_paginationStrut(0)
     , m_type(type)
     , m_shouldPaint(shouldPaint)
     , m_isDescendant(isDescendant)
     , m_isPlaced(true)
 #ifndef NDEBUG
     , m_isInPlacedTree(false)
 #endif
+    , m_isOverhangingOrIntruding(false)
 {
 }
 
 PassOwnPtr<FloatingObject> FloatingObject::create(RenderBox* renderer)
 {
     OwnPtr<FloatingObject> newObj = adoptPtr(new FloatingObject(renderer));
     newObj->setShouldPaint(!renderer->hasSelfPaintingLayer()); // If a layer exists, the float will paint itself. Otherwise someone else will.
     newObj->setIsDescendant(true);
 
     return newObj.release();
 }
 
 PassOwnPtr<FloatingObject> FloatingObject::copyToNewContainer(LayoutSize offset, bool shouldPaint, bool isDescendant) const
 {
     return adoptPtr(new FloatingObject(renderer(), type(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant));
 }
 
 PassOwnPtr<FloatingObject> FloatingObject::unsafeClone() const
 {
     OwnPtr<FloatingObject> cloneObject = adoptPtr(new FloatingObject(renderer(), type(), m_frameRect, m_shouldPaint, m_isDescendant));
-    cloneObject->m_originatingLine = m_originatingLine;
     cloneObject->m_paginationStrut = m_paginationStrut;
     cloneObject->m_isPlaced = m_isPlaced;
     return cloneObject.release();
 }
 
 template <FloatingObject::Type FloatTypeValue>
 class ComputeFloatOffsetAdapter {
 public:
     typedef FloatingObjectInterval IntervalType;
 
@@ skipping 58 matching lines @@
     , m_horizontalWritingMode(horizontalWritingMode)
     , m_renderer(renderer)
     , m_cachedHorizontalWritingMode(false)
 {
 }
 
 void FloatingObjects::clear()
 {
     deleteAllValues(m_set);
     m_set.clear();
+    m_overhangingOrIntrudingSet.clear();
     m_placedFloatsTree.clear();
     m_leftObjectsCount = 0;
     m_rightObjectsCount = 0;
     markLowestFloatLogicalBottomCacheAsDirty();
 }
 
+void FloatingObjects::clearOverhangingAndIntrudingFloats()
+{
+    FloatingObjectSetIterator end = m_overhangingOrIntrudingSet.end();
+    for (FloatingObjectSetIterator it = m_overhangingOrIntrudingSet.begin(); it != end; ++it) {
+        FloatingObject* floatingObject = *it;
+        decreaseObjectsCount(floatingObject->type());
+        m_set.remove(floatingObject);
+        removePlacedObject(floatingObject);
+        ASSERT(!floatingObject->originatingLine());
+        delete floatingObject;
+    }
+    m_overhangingOrIntrudingSet.clear();
+    markLowestFloatLogicalBottomCacheAsDirty();
+}
+
 LayoutUnit FloatingObjects::lowestFloatLogicalBottom(FloatingObject::Type floatType)
 {
     bool isInHorizontalWritingMode = m_horizontalWritingMode;
     if (floatType != FloatingObject::FloatLeftRight) {
         if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, floatType))
             return getCachedlowestFloatLogicalBottom(floatType);
     } else {
         if (hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatLeft) && hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode, FloatingObject::FloatRight)) {
             return max(getCachedlowestFloatLogicalBottom(FloatingObject::FloatLeft),
                 getCachedlowestFloatLogicalBottom(FloatingObject::FloatRight));
@@ skipping 133 matching lines @@
 {
     FloatingObject* newObject = floatingObject.leakPtr();
     increaseObjectsCount(newObject->type());
     m_set.add(newObject);
     if (newObject->isPlaced())
         addPlacedObject(newObject);
     markLowestFloatLogicalBottomCacheAsDirty();
     return newObject;
 }
 
+FloatingObject* FloatingObjects::addOverhangingOrIntrudingFloat(PassOwnPtr<FloatingObject> floatingObject)
+{
+    ASSERT(floatingObject->isPlaced());
+
+    floatingObject->setIsOverhangingOrIntruding(true);
+
+    m_overhangingOrIntrudingSet.add(floatingObject.get());
+    return add(floatingObject);
+}
+
 void FloatingObjects::remove(FloatingObject* floatingObject)
 {
     decreaseObjectsCount(floatingObject->type());
     m_set.remove(floatingObject);
+    m_overhangingOrIntrudingSet.remove(floatingObject);
     ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
     if (floatingObject->isPlaced())
         removePlacedObject(floatingObject);
     markLowestFloatLogicalBottomCacheAsDirty();
     ASSERT(!floatingObject->originatingLine());
     delete floatingObject;
 }
 
 void FloatingObjects::computePlacedFloatsTree()
 {
@@ skipping 148 matching lines @@
 }
 
 String ValueToString<FloatingObject*>::string(const FloatingObject* floatingObject)
 {
     return String::format("%p (%dx%d %dx%d)", floatingObject, floatingObject->frameRect().pixelSnappedX(), floatingObject->frameRect().pixelSnappedY(), floatingObject->frameRect().pixelSnappedMaxX(), floatingObject->frameRect().pixelSnappedMaxY());
 }
 #endif
 
 
 } // namespace WebCore