Remove more float machinery.

sky/engine/core/rendering/RenderBlock.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 72 matching lines @@
 static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = 0;
 
 RenderBlock::RenderBlock(ContainerNode* node)
     : RenderBox(node)
     , m_hasMarginBeforeQuirk(false)
     , m_hasMarginAfterQuirk(false)
     , m_beingDestroyed(false)
     , m_hasMarkupTruncation(false)
     , m_hasBorderOrPaddingLogicalWidthChanged(false)
     , m_hasOnlySelfCollapsingChildren(false)
-    , m_descendantsWithFloatsMarkedForLayout(false)
 {
     // RenderBlockFlow calls setChildrenInline(true).
     // By default, subclasses do not have inline children.
 }
 
 void RenderBlock::trace(Visitor* visitor)
 {
     visitor->trace(m_children);
     RenderBox::trace(visitor);
 }
@@ skipping 696 matching lines @@
     }
 
     RenderBox::removeChild(oldChild);
 
     RenderObject* child = prev ? prev : next;
     if (canMergeAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling() && canCollapseAnonymousBlockChild()) {
         // The removal has knocked us down to containing only a single anonymous
         // box.  We can go ahead and pull the content right back up into our
         // box.
         collapseAnonymousBlockChild(this, toRenderBlock(child));
-    } else if (((prev && prev->isAnonymousBlock()) || (next && next->isAnonymousBlock())) && canCollapseAnonymousBlockChild()) {
-        // It's possible that the removal has knocked us down to a single anonymous
-        // block with pseudo-style element siblings (e.g. first-letter). If these
-        // are floating, then we need to pull the content up also.
-        RenderBlock* anonymousBlock = toRenderBlock((prev && prev->isAnonymousBlock()) ? prev : next);
-        if ((anonymousBlock->previousSibling() || anonymousBlock->nextSibling())
-            && (!anonymousBlock->previousSibling() || (anonymousBlock->previousSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->previousSibling()->isFloating() && !anonymousBlock->previousSibling()->previousSibling()))
-            && (!anonymousBlock->nextSibling() || (anonymousBlock->nextSibling()->style()->styleType() != NOPSEUDO && anonymousBlock->nextSibling()->isFloating() && !anonymousBlock->nextSibling()->nextSibling()))) {
-            collapseAnonymousBlockChild(this, anonymousBlock);
-        }
     }
 
     if (!firstChild()) {
         // If this was our last child be sure to clear out our line boxes.
         if (childrenInline())
             deleteLineBoxTree();
 
         // If we are an empty anonymous block in the continuation chain,
         // we need to remove ourself and fix the continuation chain.
         if (!beingDestroyed() && isAnonymousBlockContinuation()) {
@@ skipping 262 matching lines @@
     if (relayoutChildren && child->needsPreferredWidthsRecalculation())
         child->setPreferredLogicalWidthsDirty(MarkOnlyThis);
 }
 
 void RenderBlock::simplifiedNormalFlowLayout()
 {
     if (childrenInline()) {
         ListHashSet<RootInlineBox*> lineBoxes;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
             RenderObject* o = walker.current();
-            if (!o->isOutOfFlowPositioned() && (o->isReplaced() || o->isFloating())) {
+            if (!o->isOutOfFlowPositioned() && o->isReplaced()) {
                 o->layoutIfNeeded();
                 if (toRenderBox(o)->inlineBoxWrapper()) {
                     RootInlineBox& box = toRenderBox(o)->inlineBoxWrapper()->root();
                     lineBoxes.add(&box);
                 }
             } else if (o->isText() || (o->isRenderInline() && !walker.atEndOfInline())) {
                 o->clearNeedsLayout();
             }
         }
 
@@ skipping 182 matching lines @@
 }
 
 void RenderBlock::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox())
         paintChild(child, paintInfo, paintOffset);
 }
 
 void RenderBlock::paintChild(RenderBox* child, PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    if (!child->hasSelfPaintingLayer() && !child->isFloating())
+    if (!child->hasSelfPaintingLayer())
         child->paint(paintInfo, paintOffset);
 }
 
 void RenderBlock::paintChildAsInlineBlock(RenderBox* child, PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    if (!child->hasSelfPaintingLayer() && !child->isFloating())
+    if (!child->hasSelfPaintingLayer())
         paintAsInlineBlock(child, paintInfo, paintOffset);
 }
 
 void RenderBlock::paintAsInlineBlock(RenderObject* renderer, PaintInfo& paintInfo, const LayoutPoint& childPoint)
 {
     if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection)
         return;
 
     // Paint all phases atomically, as though the element established its own
     // stacking context.  (See Appendix E.2, section 7.2.1.4 on
@@ skipping 205 matching lines @@
 bool RenderBlock::shouldPaintSelectionGaps() const
 {
     return selectionState() != SelectionNone && isSelectionRoot();
 }
 
 bool RenderBlock::isSelectionRoot() const
 {
     ASSERT(node() || isAnonymous());
 
     if (isDocumentElement() || hasOverflowClip()
-        || isPositioned() || isFloating()
+        || isPositioned()
         || isInlineBlock()
         || hasTransform() || hasMask()
         || isFlexItemIncludingDeprecated())
         return true;
 
     if (view() && view()->selectionStart()) {
         Node* startElement = view()->selectionStart()->node();
         if (startElement && startElement->rootEditableElement() == node())
             return true;
     }
@@ skipping 634 matching lines @@
     if (childrenInline()) {
         // We have to hit-test our line boxes.
         if (m_lineBoxes.hitTest(this, request, result, locationInContainer, accumulatedOffset, hitTestAction))
             return true;
     } else {
         // Hit test our children.
         HitTestAction childHitTest = hitTestAction;
         if (hitTestAction == HitTestChildBlockBackgrounds)
             childHitTest = HitTestChildBlockBackground;
         for (RenderBox* child = lastChildBox(); child; child = child->previousSiblingBox()) {
-            if (!child->hasSelfPaintingLayer() && !child->isFloating() && child->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, childHitTest))
+            if (!child->hasSelfPaintingLayer() && child->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, childHitTest))
                 return true;
         }
     }
 
     return false;
 }
 
 Position RenderBlock::positionForBox(InlineBox *box, bool start) const
 {
     if (!box)
@@ skipping 234 matching lines @@
 
     clearPreferredLogicalWidthsDirty();
 }
 
 void RenderBlock::computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     RenderStyle* styleToUse = style();
     bool nowrap = styleToUse->whiteSpace() == NOWRAP;
 
     RenderObject* child = firstChild();
-    RenderBlock* containingBlock = this->containingBlock();
-    LayoutUnit floatLeftWidth = 0, floatRightWidth = 0;
     while (child) {
         // Positioned children don't affect the min/max width
         if (child->isOutOfFlowPositioned()) {
             child = child->nextSibling();
             continue;
         }
 
         RefPtr<RenderStyle> childStyle = child->style();
-        if (child->isFloating() || (child->isBox() && toRenderBox(child)->avoidsFloats())) {
-            LayoutUnit floatTotalWidth = floatLeftWidth + floatRightWidth;
-            if (childStyle->clear() & CLEFT) {
-                maxLogicalWidth = std::max(floatTotalWidth, maxLogicalWidth);
-                floatLeftWidth = 0;
-            }
-            if (childStyle->clear() & CRIGHT) {
-                maxLogicalWidth = std::max(floatTotalWidth, maxLogicalWidth);
-                floatRightWidth = 0;
-            }
-        }
 
         // A margin basically has three types: fixed, percentage, and auto (variable).
         // Auto and percentage margins simply become 0 when computing min/max width.
         // Fixed margins can be added in as is.
         Length startMarginLength = childStyle->marginStartUsing(styleToUse);
         Length endMarginLength = childStyle->marginEndUsing(styleToUse);
         LayoutUnit margin = 0;
         LayoutUnit marginStart = 0;
         LayoutUnit marginEnd = 0;
         if (startMarginLength.isFixed())
             marginStart += startMarginLength.value();
         if (endMarginLength.isFixed())
             marginEnd += endMarginLength.value();
         margin = marginStart + marginEnd;
 
         LayoutUnit childMinPreferredLogicalWidth = child->minPreferredLogicalWidth();
         LayoutUnit childMaxPreferredLogicalWidth = child->maxPreferredLogicalWidth();
 
         LayoutUnit w = childMinPreferredLogicalWidth + margin;
         minLogicalWidth = std::max(w, minLogicalWidth);
 
         // IE ignores tables for calculation of nowrap. Makes some sense.
         if (nowrap)
             maxLogicalWidth = std::max(w, maxLogicalWidth);
 
         w = childMaxPreferredLogicalWidth + margin;
 
-        if (!child->isFloating()) {
-            if (child->isBox() && toRenderBox(child)->avoidsFloats()) {
-                // Determine a left and right max value based off whether or not the floats can fit in the
-                // margins of the object.  For negative margins, we will attempt to overlap the float if the negative margin
-                // is smaller than the float width.
-                bool ltr = containingBlock ? containingBlock->style()->isLeftToRightDirection() : styleToUse->isLeftToRightDirection();
-                LayoutUnit marginLogicalLeft = ltr ? marginStart : marginEnd;
-                LayoutUnit marginLogicalRight = ltr ? marginEnd : marginStart;
-                LayoutUnit maxLeft = marginLogicalLeft > 0 ? std::max(floatLeftWidth, marginLogicalLeft) : floatLeftWidth + marginLogicalLeft;
-                LayoutUnit maxRight = marginLogicalRight > 0 ? std::max(floatRightWidth, marginLogicalRight) : floatRightWidth + marginLogicalRight;
-                w = childMaxPreferredLogicalWidth + maxLeft + maxRight;
-                w = std::max(w, floatLeftWidth + floatRightWidth);
-            } else {
-                maxLogicalWidth = std::max(floatLeftWidth + floatRightWidth, maxLogicalWidth);
-            }
-            floatLeftWidth = floatRightWidth = 0;
-        }
-
-        if (child->isFloating()) {
-            if (childStyle->floating() == LeftFloat)
-                floatLeftWidth += w;
-            else
-                floatRightWidth += w;
-        } else {
-            maxLogicalWidth = std::max(w, maxLogicalWidth);
-        }
+        maxLogicalWidth = std::max(w, maxLogicalWidth);
 
         child = child->nextSibling();
     }
 
     // Always make sure these values are non-negative.
     minLogicalWidth = std::max<LayoutUnit>(0, minLogicalWidth);
     maxLogicalWidth = std::max<LayoutUnit>(0, maxLogicalWidth);
-
-    maxLogicalWidth = std::max(floatLeftWidth + floatRightWidth, maxLogicalWidth);
 }
 
 bool RenderBlock::hasLineIfEmpty() const
 {
     return node() && node()->isRootEditableElement();
 }
 
 LayoutUnit RenderBlock::lineHeight(bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     // Inline blocks are replaced elements. Otherwise, just pass off to
@@ skipping 118 matching lines @@
 RenderBlock* RenderBlock::firstLineBlock() const
 {
     RenderBlock* firstLineBlock = const_cast<RenderBlock*>(this);
     bool hasPseudo = false;
     while (true) {
         // FIXME(sky): Remove all this.
         hasPseudo = false;
         if (hasPseudo)
             break;
         RenderObject* parentBlock = firstLineBlock->parent();
-        if (firstLineBlock->isReplaced() || firstLineBlock->isFloating()
+        if (firstLineBlock->isReplaced()
             || !parentBlock
             || !parentBlock->isRenderBlockFlow())
             break;
         ASSERT_WITH_SECURITY_IMPLICATION(parentBlock->isRenderBlock());
         if (toRenderBlock(parentBlock)->firstChild() != firstLineBlock)
             break;
         firstLineBlock = toRenderBlock(parentBlock);
     }
 
     if (!hasPseudo)
@@ skipping 258 matching lines @@
     return child->isRenderBlock() ? toRenderBlock(child)->hasMarginBeforeQuirk() : child->style()->hasMarginBeforeQuirk();
 }
 
 bool RenderBlock::hasMarginAfterQuirk(const RenderBox* child) const
 {
     return child->isRenderBlock() ? toRenderBlock(child)->hasMarginAfterQuirk() : child->style()->hasMarginAfterQuirk();
 }
 
 const char* RenderBlock::renderName() const
 {
-    if (isFloating())
-        return "RenderBlock (floating)";
     if (isOutOfFlowPositioned())
         return "RenderBlock (positioned)";
     if (isAnonymousBlock())
         return "RenderBlock (anonymous)";
     if (isAnonymous())
         return "RenderBlock (generated)";
     if (isRelPositioned())
         return "RenderBlock (relative positioned)";
     return "RenderBlock";
 }
@@ skipping 124 matching lines @@
 void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj) const
 {
     showRenderObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink