Remove most of FloatingObject.

sky/engine/core/rendering/line/BreakingContextInlineHeaders.h

 /*
  * 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.
  * Copyright (C) 2013 Adobe Systems Incorporated.
  *
  * 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 39 matching lines @@
         : m_resolver(resolver)
         , m_current(resolver.position())
         , m_lineBreak(resolver.position())
         , m_block(block)
         , m_lastObject(m_current.object())
         , m_nextObject(0)
         , m_currentStyle(0)
         , m_blockStyle(block->style())
         , m_lineInfo(inLineInfo)
         , m_renderTextInfo(inRenderTextInfo)
-        , m_lastFloatFromPreviousLine(inLastFloatFromPreviousLine)
         , m_width(lineWidth)
         , m_currWS(NORMAL)
         , m_lastWS(NORMAL)
         , m_preservesNewline(false)
         , m_atStart(true)
         , m_ignoringSpaces(false)
         , m_currentCharacterIsSpace(false)
         , m_currentCharacterShouldCollapseIfPreWap(false)
         , m_appliedStartWidth(appliedStartWidth)
         , m_includeEndWidth(true)
         , m_autoWrap(false)
         , m_autoWrapWasEverTrueOnLine(false)
-        , m_floatsFitOnLine(true)
         , m_collapseWhiteSpace(false)
         , m_startingNewParagraph(m_lineInfo.previousLineBrokeCleanly())
         , m_atEnd(false)
         , m_lineMidpointState(resolver.midpointState())
     {
         m_lineInfo.setPreviousLineBrokeCleanly(false);
     }
 
     RenderObject* currentObject() { return m_current.object(); }
     InlineIterator lineBreak() { return m_lineBreak; }
     bool atEnd() { return m_atEnd; }
 
     void initializeForCurrentObject();
 
     void increment();
 
     void handleBR(EClear&);
     void handleOutOfFlowPositioned(Vector<RenderBox*>& positionedObjects);
-    void handleFloat();
     void handleEmptyInline();
     void handleReplaced();
     bool handleText(WordMeasurements&, bool& hyphenated);
     void commitAndUpdateLineBreakIfNeeded();
     InlineIterator handleEndOfLine();
 
     void clearLineBreakIfFitsOnLine()
     {
         if (m_width.fitsOnLine() || m_lastWS == NOWRAP)
             m_lineBreak.clear();
@@ skipping 12 matching lines @@
     RenderObject* m_lastObject;
     RenderObject* m_nextObject;
 
     RenderStyle* m_currentStyle;
     RenderStyle* m_blockStyle;
 
     LineInfo& m_lineInfo;
 
     RenderTextInfo& m_renderTextInfo;
 
-    FloatingObject* m_lastFloatFromPreviousLine;
-
     LineWidth m_width;
 
     EWhiteSpace m_currWS;
     EWhiteSpace m_lastWS;
 
     bool m_preservesNewline;
     bool m_atStart;
     bool m_ignoringSpaces;
     bool m_currentCharacterIsSpace;
     bool m_currentCharacterShouldCollapseIfPreWap;
     bool m_appliedStartWidth;
     bool m_includeEndWidth;
     bool m_autoWrap;
     bool m_autoWrapWasEverTrueOnLine;
-    bool m_floatsFitOnLine;
     bool m_collapseWhiteSpace;
     bool m_startingNewParagraph;
     bool m_atEnd;
 
     LineMidpointState& m_lineMidpointState;
 
     TrailingObjects m_trailingObjects;
 };
 
 inline bool shouldCollapseWhiteSpace(const RenderStyle* style, const LineInfo& lineInfo, WhitespacePosition whitespacePosition)
@@ skipping 67 matching lines @@
 // elements quite right. In other words, we need to build this function's work into the normal line
 // object iteration process.
 // NB. this function will insert any floating elements that would otherwise
 // be skipped but it will not position them.
 inline void BreakingContext::skipTrailingWhitespace(InlineIterator& iterator, const LineInfo& lineInfo)
 {
     while (!iterator.atEnd() && !requiresLineBox(iterator, lineInfo, TrailingWhitespace)) {
         RenderObject* object = iterator.object();
         if (object->isOutOfFlowPositioned())
             setStaticPositions(m_block, toRenderBox(object));
-        else if (object->isFloating())
-            m_block->insertFloatingObject(toRenderBox(object));
         iterator.increment();
     }
 }
 
 inline void BreakingContext::initializeForCurrentObject()
 {
     m_currentStyle = m_current.object()->style();
     m_nextObject = bidiNextSkippingEmptyInlines(m_block, m_current.object());
     if (m_nextObject && m_nextObject->parent() && !m_nextObject->parent()->isDescendantOf(m_current.object()->parent()))
         m_includeEndWidth = true;
@@ skipping 108 matching lines @@
             m_lineMidpointState.ensureLineBoxInsideIgnoredSpaces(box);
         m_trailingObjects.appendObjectIfNeeded(box);
     } else {
         positionedObjects.append(box);
     }
     m_width.addUncommittedWidth(inlineLogicalWidth(box).toFloat());
     // Reset prior line break context characters.
     m_renderTextInfo.m_lineBreakIterator.resetPriorContext();
 }
 
-inline void BreakingContext::handleFloat()
-{
-    RenderBox* floatBox = toRenderBox(m_current.object());
-    FloatingObject* floatingObject = m_block->insertFloatingObject(floatBox);
-    // check if it fits in the current line.
-    // If it does, position it now, otherwise, position
-    // it after moving to next line (in newLine() func)
-    // FIXME: Bug 110372: Properly position multiple stacked floats with non-rectangular shape outside.
-    if (m_floatsFitOnLine && m_width.fitsOnLine(m_block->logicalWidthForFloat(floatingObject).toFloat(), ExcludeWhitespace)) {
-        m_block->positionNewFloatOnLine(floatingObject, m_lastFloatFromPreviousLine, m_lineInfo, m_width);
-        if (m_lineBreak.object() == m_current.object()) {
-            ASSERT(!m_lineBreak.offset());
-            m_lineBreak.increment();
-        }
-    } else {
-        m_floatsFitOnLine = false;
-    }
-    // Update prior line break context characters, using U+FFFD (OBJECT REPLACEMENT CHARACTER) for floating element.
-    m_renderTextInfo.m_lineBreakIterator.updatePriorContext(replacementCharacter);
-}
-
 // This is currently just used for list markers and inline flows that have line boxes. Neither should
 // have an effect on whitespace at the start of the line.
 inline bool shouldSkipWhitespaceAfterStartObject(RenderBlockFlow* block, RenderObject* o, LineMidpointState& lineMidpointState)
 {
     RenderObject* next = bidiNextSkippingEmptyInlines(block, o);
     while (next && next->isFloatingOrOutOfFlowPositioned())
         next = bidiNextSkippingEmptyInlines(block, next);
 
     if (next && next->isText() && toRenderText(next)->textLength() > 0) {
         RenderText* nextText = toRenderText(next);
@@ skipping 476 matching lines @@
 
     if (style->textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h