Remove more float machinery.

sky/engine/core/rendering/RenderBlockLineLayout.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 847 matching lines @@
 
     RenderObject* next();
 };
 
 RenderObject* InlineMinMaxIterator::next()
 {
     RenderObject* result = 0;
     bool oldEndOfInline = endOfInline;
     endOfInline = false;
     while (current || current == parent) {
-        if (!oldEndOfInline && (current == parent || (!current->isFloating() && !current->isReplaced() && !current->isOutOfFlowPositioned())))
+        if (!oldEndOfInline && (current == parent || (!current->isReplaced() && !current->isOutOfFlowPositioned())))
             result = current->slowFirstChild();
 
         if (!result) {
             // We hit the end of our inline. (It was empty, e.g., <span></span>.)
             if (!oldEndOfInline && current->isRenderInline()) {
                 result = current;
                 endOfInline = true;
                 break;
             }
 
             while (current && current != parent) {
                 result = current->nextSibling();
                 if (result)
                     break;
                 current = current->parent();
                 if (current && current != parent && current->isRenderInline()) {
                     result = current;
                     endOfInline = true;
                     break;
                 }
             }
         }
 
         if (!result)
             break;
 
-        if (!result->isOutOfFlowPositioned() && (result->isText() || result->isFloating() || result->isReplaced() || result->isRenderInline()))
+        if (!result->isOutOfFlowPositioned() && (result->isText() || result->isReplaced() || result->isRenderInline()))
             break;
 
         current = result;
         result = 0;
     }
 
     // Update our position.
     current = result;
     return current;
 }
@@ skipping 67 matching lines @@
     autoWrap = oldAutoWrap = styleToUse->autoWrap();
 
     InlineMinMaxIterator childIterator(this);
 
     // Only gets added to the max preffered width once.
     bool addedTextIndent = false;
     // Signals the text indent was more negative than the min preferred width
     bool hasRemainingNegativeTextIndent = false;
 
     LayoutUnit textIndent = minimumValueForLength(styleToUse->textIndent(), cw);
-    RenderObject* prevFloat = 0;
     bool isPrevChildInlineFlow = false;
     bool shouldBreakLineAfterText = false;
     while (RenderObject* child = childIterator.next()) {
         autoWrap = child->isReplaced() ? child->parent()->style()->autoWrap() :
             child->style()->autoWrap();
 
         // Step One: determine whether or not we need to go ahead and
         // terminate our current line. Each discrete chunk can become
         // the new min-width, if it is the widest chunk seen so far, and
         // it can also become the max-width.
@@ skipping 61 matching lines @@
 
         if (!child->isRenderInline() && !child->isText()) {
             // Case (2). Inline replaced elements and floats.
             // Go ahead and terminate the current line as far as
             // minwidth is concerned.
             LayoutUnit childMinPreferredLogicalWidth = child->minPreferredLogicalWidth();
             LayoutUnit childMaxPreferredLogicalWidth = child->maxPreferredLogicalWidth();
             childMin += childMinPreferredLogicalWidth.ceilToFloat();
             childMax += childMaxPreferredLogicalWidth.ceilToFloat();
 
-            bool clearPreviousFloat;
-            if (child->isFloating()) {
-                clearPreviousFloat = (prevFloat
-                    && ((prevFloat->style()->floating() == LeftFloat && (childStyle->clear() & CLEFT))
-                        || (prevFloat->style()->floating() == RightFloat && (childStyle->clear() & CRIGHT))));
-                prevFloat = child;
-            } else {
-                clearPreviousFloat = false;
-            }
-
             bool canBreakReplacedElement = true;
-            if ((canBreakReplacedElement && (autoWrap || oldAutoWrap) && (!isPrevChildInlineFlow || shouldBreakLineAfterText)) || clearPreviousFloat) {
+            if ((canBreakReplacedElement && (autoWrap || oldAutoWrap) && (!isPrevChildInlineFlow || shouldBreakLineAfterText))) {
                 updatePreferredWidth(minLogicalWidth, inlineMin);
                 inlineMin = 0;
             }
 
-            // If we're supposed to clear the previous float, then terminate maxwidth as well.
-            if (clearPreviousFloat) {
-                updatePreferredWidth(maxLogicalWidth, inlineMax);
-                inlineMax = 0;
-            }
-
             // Add in text-indent. This is added in only once.
-            if (!addedTextIndent && !child->isFloating()) {
+            if (!addedTextIndent) {
                 float ceiledTextIndent = textIndent.ceilToFloat();
                 childMin += ceiledTextIndent;
                 childMax += ceiledTextIndent;
 
                 if (childMin < 0)
                     textIndent = adjustFloatForSubPixelLayout(childMin);
                 else
                     addedTextIndent = true;
             }
 
             // Add our width to the max.
             inlineMax += std::max<float>(0, childMax);
 
             if (!autoWrap || !canBreakReplacedElement || (isPrevChildInlineFlow && !shouldBreakLineAfterText)) {
-                if (child->isFloating())
-                    updatePreferredWidth(minLogicalWidth, childMin);
-                else
-                    inlineMin += childMin;
+                inlineMin += childMin;
             } else {
                 // Now check our line.
                 updatePreferredWidth(minLogicalWidth, childMin);
 
                 // Now start a new line.
                 inlineMin = 0;
             }
 
             if (autoWrap && canBreakReplacedElement && isPrevChildInlineFlow) {
                 updatePreferredWidth(minLogicalWidth, inlineMin);
                 inlineMin = 0;
             }
 
             // We are no longer stripping whitespace at the start of
             // a line.
-            if (!child->isFloating()) {
-                stripFrontSpaces = false;
-                trailingSpaceChild = 0;
-            }
+            stripFrontSpaces = false;
+            trailingSpaceChild = 0;
         } else if (child->isText()) {
             // Case (3). Text.
             RenderText* t = toRenderText(child);
 
             // Determine if we have a breakable character. Pass in
             // whether or not we should ignore any spaces at the front
             // of the string. If those are going to be stripped out,
             // then they shouldn't be considered in the breakable char
             // check.
             bool hasBreakableChar, hasBreak;
@@ skipping 130 matching lines @@
         // the replaced elements later. In partial layout mode, line boxes are not
         // deleted and only dirtied. In that case, we can layout the replaced
         // elements at the same time.
         Vector<RenderBox*> replacedChildren;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
             RenderObject* o = walker.current();
 
             if (!layoutState.hasInlineChild() && o->isInline())
                 layoutState.setHasInlineChild(true);
 
-            if (o->isReplaced() || o->isFloating() || o->isOutOfFlowPositioned()) {
+            if (o->isReplaced() || o->isOutOfFlowPositioned()) {
                 RenderBox* box = toRenderBox(o);
 
                 updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, box);
 
-                if (o->isOutOfFlowPositioned())
+                if (o->isOutOfFlowPositioned()) {
                     o->containingBlock()->insertPositionedObject(box);
-                else if (o->isFloating())
-                    layoutState.floats().append(FloatWithRect(box));
-                else if (isFullLayout || o->needsLayout()) {
+                } else if (isFullLayout || o->needsLayout()) {
                     // Replaced element.
                     box->dirtyLineBoxes(isFullLayout);
                     if (isFullLayout)
                         replacedChildren.append(box);
                     else
                         o->layoutIfNeeded();
                 }
             } else if (o->isText() || (o->isRenderInline() && !walker.atEndOfInline())) {
                 if (!o->isText())
                     toRenderInline(o)->updateAlwaysCreateLineBoxes(layoutState.isFullLayout());
@@ skipping 332 matching lines @@
     float logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false).toFloat();
     float availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }