Remove more support for floats from RenderBlockFlow.

sky/engine/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 76 matching lines @@
     RenderBoxModelObject::willBeDestroyed();
 }
 
 void RenderBox::removeFloatingOrPositionedChildFromBlockLists()
 {
     ASSERT(isFloatingOrOutOfFlowPositioned());
 
     if (documentBeingDestroyed())
         return;
 
-    if (isFloating()) {
-        RenderBlockFlow* parentBlockFlow = 0;
-        for (RenderObject* curr = parent(); curr && !curr->isRenderView(); curr = curr->parent()) {
-            if (curr->isRenderBlockFlow()) {
-                RenderBlockFlow* currBlockFlow = toRenderBlockFlow(curr);
-                if (!parentBlockFlow || currBlockFlow->containsFloat(this))
-                    parentBlockFlow = currBlockFlow;
-            }
-        }
-
-        if (parentBlockFlow) {
-            parentBlockFlow->markSiblingsWithFloatsForLayout(this);
-            parentBlockFlow->markAllDescendantsWithFloatsForLayout(this, false);
-        }
-    }
-
     if (isOutOfFlowPositioned())
         RenderBlock::removePositionedObject(this);
 }
 
 void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
 {
     RenderStyle* oldStyle = style();
     if (oldStyle) {
         // When a layout hint happens and an object's position style changes, we have to do a layout
         // to dirty the render tree using the old position value now.
         if (diff.needsFullLayout() && parent() && oldStyle->position() != newStyle.position()) {
             markContainingBlocksForLayout();
             if (oldStyle->position() == StaticPosition)
                 setShouldDoFullPaintInvalidation(true);
             else if (newStyle.hasOutOfFlowPosition())
                 parent()->setChildNeedsLayout();
-            if (isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
-                removeFloatingOrPositionedChildFromBlockLists();
         }
     }
 
     RenderBoxModelObject::styleWillChange(diff, newStyle);
 }
 
 void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderBoxModelObject::styleDidChange(diff, oldStyle);
 
@@ skipping 1574 matching lines @@
     else
         o->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 }
 
 void RenderBox::inflatePaintInvalidationRectForReflectionAndFilter(LayoutRect& paintInvalidationRect) const
 {
     if (style()->hasFilter())
         style()->filterOutsets().expandRect(paintInvalidationRect);
 }
 
-void RenderBox::invalidatePaintForOverhangingFloats(bool)
-{
-}
-
 void RenderBox::updateLogicalWidth()
 {
     LogicalExtentComputedValues computedValues;
     computeLogicalWidth(computedValues);
 
     setLogicalWidth(computedValues.m_extent);
     setLogicalLeft(computedValues.m_position);
     setMarginStart(computedValues.m_margins.m_start);
     setMarginEnd(computedValues.m_margins.m_end);
 }
@@ skipping 65 matching lines @@
         bool hasInvertedDirection = cb->style()->isLeftToRightDirection() != style()->isLeftToRightDirection();
         if (hasInvertedDirection)
             computedValues.m_margins.m_start = newMargin;
         else
             computedValues.m_margins.m_end = newMargin;
     }
 }
 
 LayoutUnit RenderBox::fillAvailableMeasure(LayoutUnit availableLogicalWidth) const
 {
-    LayoutUnit marginStart = 0;
-    LayoutUnit marginEnd = 0;
-    return fillAvailableMeasure(availableLogicalWidth, marginStart, marginEnd);
-}
-
-LayoutUnit RenderBox::fillAvailableMeasure(LayoutUnit availableLogicalWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const
-{
-    marginStart = minimumValueForLength(style()->marginStart(), availableLogicalWidth);
-    marginEnd = minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
+    LayoutUnit marginStart = minimumValueForLength(style()->marginStart(), availableLogicalWidth);
+    LayoutUnit marginEnd = minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
     return availableLogicalWidth - marginStart - marginEnd;
 }
 
 LayoutUnit RenderBox::computeIntrinsicLogicalWidthUsing(const Length& logicalWidthLength, LayoutUnit availableLogicalWidth, LayoutUnit borderAndPadding) const
 {
     if (logicalWidthLength.type() == FillAvailable)
         return fillAvailableMeasure(availableLogicalWidth);
 
     LayoutUnit minLogicalWidth = 0;
     LayoutUnit maxLogicalWidth = 0;
@@ skipping 18 matching lines @@
 LayoutUnit RenderBox::computeLogicalWidthUsing(SizeType widthType, const Length& logicalWidth, LayoutUnit availableLogicalWidth, const RenderBlock* cb) const
 {
     if (!logicalWidth.isIntrinsicOrAuto()) {
         // FIXME: If the containing block flow is perpendicular to our direction we need to use the available logical height instead.
         return adjustBorderBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, availableLogicalWidth));
     }
 
     if (logicalWidth.isIntrinsic())
         return computeIntrinsicLogicalWidthUsing(logicalWidth, availableLogicalWidth, borderAndPaddingLogicalWidth());
 
-    LayoutUnit marginStart = 0;
-    LayoutUnit marginEnd = 0;
-    LayoutUnit logicalWidthResult = fillAvailableMeasure(availableLogicalWidth, marginStart, marginEnd);
-
-    if (shrinkToAvoidFloats() && cb->isRenderBlockFlow() && toRenderBlockFlow(cb)->containsFloats())
-        logicalWidthResult = std::min(logicalWidthResult, shrinkLogicalWidthToAvoidFloats(marginStart, marginEnd, toRenderBlockFlow(cb)));
+    LayoutUnit logicalWidthResult = fillAvailableMeasure(availableLogicalWidth);
 
     if (widthType == MainOrPreferredSize && sizesLogicalWidthToFitContent(logicalWidth))
         return std::max(minPreferredLogicalWidth(), std::min(maxPreferredLogicalWidth(), logicalWidthResult));
     return logicalWidthResult;
 }
 
 static bool columnFlexItemHasStretchAlignment(const RenderObject* flexitem)
 {
     RenderObject* parent = flexitem->parent();
     // auto margins mean we don't stretch. Note that this function will only be used for
@@ skipping 45 matching lines @@
         // See also http://dev.w3.org/csswg/css-flexbox/#auto-margins
         if (marginStartLength.isAuto())
             marginStartLength.setValue(0);
         if (marginEndLength.isAuto())
             marginEndLength.setValue(0);
     }
 
     LayoutUnit marginStartWidth = minimumValueForLength(marginStartLength, containerWidth);
     LayoutUnit marginEndWidth = minimumValueForLength(marginEndLength, containerWidth);
 
-    LayoutUnit availableWidth = containerWidth;
-    if (avoidsFloats() && containingBlock->isRenderBlockFlow() && toRenderBlockFlow(containingBlock)->containsFloats()) {
-        availableWidth = containingBlockAvailableLineWidth();
-        if (shrinkToAvoidFloats() && availableWidth < containerWidth) {
-            marginStart = std::max<LayoutUnit>(0, marginStartWidth);
-            marginEnd = std::max<LayoutUnit>(0, marginEndWidth);
-        }
-    }
-
     // CSS 2.1 (10.3.3): "If 'width' is not 'auto' and 'border-left-width' + 'padding-left' + 'width' + 'padding-right' + 'border-right-width'
     // (plus any of 'margin-left' or 'margin-right' that are not 'auto') is larger than the width of the containing block, then any 'auto'
     // values for 'margin-left' or 'margin-right' are, for the following rules, treated as zero.
     LayoutUnit marginBoxWidth = childWidth + (!style()->width().isAuto() ? marginStartWidth + marginEndWidth : LayoutUnit());
 
     // CSS 2.1: "If both 'margin-left' and 'margin-right' are 'auto', their used values are equal. This horizontally centers the element
     // with respect to the edges of the containing block."
     const RenderStyle* containingBlockStyle = containingBlock->style();
-    if ((marginStartLength.isAuto() && marginEndLength.isAuto() && marginBoxWidth < availableWidth)
+    if ((marginStartLength.isAuto() && marginEndLength.isAuto() && marginBoxWidth < containerWidth)
         || (!marginStartLength.isAuto() && !marginEndLength.isAuto() && containingBlockStyle->textAlign() == WEBKIT_CENTER)) {
         // Other browsers center the margin box for align=center elements so we match them here.
-        LayoutUnit centeredMarginBoxStart = std::max<LayoutUnit>(0, (availableWidth - childWidth - marginStartWidth - marginEndWidth) / 2);
+        LayoutUnit centeredMarginBoxStart = std::max<LayoutUnit>(0, (containerWidth - childWidth - marginStartWidth - marginEndWidth) / 2);
         marginStart = centeredMarginBoxStart + marginStartWidth;
-        marginEnd = availableWidth - childWidth - marginStart + marginEndWidth;
+        marginEnd = containerWidth - childWidth - marginStart + marginEndWidth;
         return;
     }
 
     // CSS 2.1: "If there is exactly one value specified as 'auto', its used value follows from the equality."
-    if (marginEndLength.isAuto() && marginBoxWidth < availableWidth) {
+    if (marginEndLength.isAuto() && marginBoxWidth < containerWidth) {
         marginStart = marginStartWidth;
-        marginEnd = availableWidth - childWidth - marginStart;
+        marginEnd = containerWidth - childWidth - marginStart;
         return;
     }
 
     bool pushToEndFromTextAlign = !marginEndLength.isAuto() && ((!containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_LEFT)
         || (containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_RIGHT));
-    if ((marginStartLength.isAuto() && marginBoxWidth < availableWidth) || pushToEndFromTextAlign) {
+    if ((marginStartLength.isAuto() && marginBoxWidth < containerWidth) || pushToEndFromTextAlign) {
         marginEnd = marginEndWidth;
-        marginStart = availableWidth - childWidth - marginEnd;
+        marginStart = containerWidth - childWidth - marginEnd;
         return;
     }
 
     // Either no auto margins, or our margin box width is >= the container width, auto margins will just turn into 0.
     marginStart = marginStartWidth;
     marginEnd = marginEndWidth;
 }
 
 void RenderBox::updateLogicalHeight()
 {
@@ skipping 1436 matching lines @@
             closestRenderer = renderer;
             minDist = dist;
         }
     }
 
     if (closestRenderer)
         return closestRenderer->positionForPoint(adjustedPoint - closestRenderer->locationOffset());
     return createPositionWithAffinity(firstPositionInOrBeforeNode(nonPseudoNode()));
 }
 
-bool RenderBox::shrinkToAvoidFloats() const
-{
-    // Floating objects don't shrink.  Objects that don't avoid floats don't shrink.  Marquees don't shrink.
-    if (isInline() || !avoidsFloats() || isFloating())
-        return false;
-
-    // Only auto width objects can possibly shrink to avoid floats.
-    return style()->width().isAuto();
-}
-
 static bool isReplacedElement(Node* node)
 {
     // FIXME(sky): Remove this.
     return false;
 }
 
 bool RenderBox::avoidsFloats() const
 {
     return isReplaced() || isReplacedElement(node()) || hasOverflowClip() || isFlexItemIncludingDeprecated();
 }
@@ skipping 510 matching lines @@
 
 RenderBox::BoxDecorationData::BoxDecorationData(const RenderStyle& style)
 {
     backgroundColor = style.colorIncludingFallback(CSSPropertyBackgroundColor);
     hasBackground = backgroundColor.alpha() || style.hasBackgroundImage();
     ASSERT(hasBackground == style.hasBackground());
     hasBorder = style.hasBorder();
 }
 
 } // namespace blink