Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef BreakingContextInlineHeaders_h
 #define BreakingContextInlineHeaders_h
 
 #include "core/layout/Layer.h"
+#include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutRubyRun.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/line/LayoutTextInfo.h"
 #include "core/layout/line/LineBreaker.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/LineWidth.h"
 #include "core/layout/line/TrailingObjects.h"
 #include "core/layout/line/WordMeasurement.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderCombineText.h"
 #include "core/rendering/RenderInline.h"
 #include "core/rendering/RenderListMarker.h"
-#include "core/rendering/RenderObjectInlines.h"
 #include "core/rendering/TextRunConstructor.h"
 #include "core/rendering/svg/RenderSVGInlineText.h"
 #include "platform/text/TextBreakIterator.h"
 
 namespace blink {
 
 // We don't let our line box tree for a single line get any deeper than this.
 const unsigned cMaxLineDepth = 200;
 
 class BreakingContext {
@@ skipping 25 matching lines @@
         , m_floatsFitOnLine(true)
         , m_collapseWhiteSpace(false)
         , m_startingNewParagraph(m_lineInfo.previousLineBrokeCleanly())
         , m_allowImagesToBreak(!block->document().inQuirksMode() || !block->isTableCell() || !m_blockStyle->logicalWidth().isIntrinsicOrAuto())
         , m_atEnd(false)
         , m_lineMidpointState(resolver.midpointState())
     {
         m_lineInfo.setPreviousLineBrokeCleanly(false);
     }
 
-    RenderObject* currentObject() { return m_current.object(); }
+    LayoutObject* 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();
@@ skipping 12 matching lines @@
 private:
     void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
 
     InlineBidiResolver& m_resolver;
 
     InlineIterator m_current;
     InlineIterator m_lineBreak;
     InlineIterator m_startOfIgnoredSpaces;
 
     RenderBlockFlow* m_block;
-    RenderObject* m_lastObject;
-    RenderObject* m_nextObject;
+    LayoutObject* m_lastObject;
+    LayoutObject* m_nextObject;
 
     RenderStyle* m_currentStyle;
     RenderStyle* m_blockStyle;
 
     LineInfo& m_lineInfo;
 
     LayoutTextInfo& m_renderTextInfo;
 
     FloatingObject* m_lastFloatFromPreviousLine;
 
@@ skipping 27 matching lines @@
     // CSS2 16.6.1
     // If a space (U+0020) at the beginning of a line has 'white-space' set to 'normal', 'nowrap', or 'pre-line', it is removed.
     // If a space (U+0020) at the end of a line has 'white-space' set to 'normal', 'nowrap', or 'pre-line', it is also removed.
     // If spaces (U+0020) or tabs (U+0009) at the end of a line have 'white-space' set to 'pre-wrap', UAs may visually collapse them.
     return style->collapseWhiteSpace()
         || (whitespacePosition == TrailingWhitespace && style->whiteSpace() == PRE_WRAP && (!lineInfo.isEmpty() || !lineInfo.previousLineBrokeCleanly()));
 }
 
 inline bool requiresLineBoxForContent(RenderInline* flow, const LineInfo& lineInfo)
 {
-    RenderObject* parent = flow->parent();
+    LayoutObject* parent = flow->parent();
     if (flow->document().inNoQuirksMode()
         && (flow->style(lineInfo.isFirstLine())->lineHeight() != parent->style(lineInfo.isFirstLine())->lineHeight()
         || flow->style()->verticalAlign() != parent->style()->verticalAlign()
         || !parent->style()->font().fontMetrics().hasIdenticalAscentDescentAndLineGap(flow->style()->font().fontMetrics())))
         return true;
     return false;
 }
 
-inline bool alwaysRequiresLineBox(RenderObject* flow)
+inline bool alwaysRequiresLineBox(LayoutObject* flow)
 {
     // FIXME: Right now, we only allow line boxes for inlines that are truly empty.
     // We need to fix this, though, because at the very least, inlines containing only
     // ignorable whitespace should should also have line boxes.
     return isEmptyInline(flow) && toRenderInline(flow)->hasInlineDirectionBordersPaddingOrMargin();
 }
 
 inline bool requiresLineBox(const InlineIterator& it, const LineInfo& lineInfo = LineInfo(), WhitespacePosition whitespacePosition = LeadingWhitespace)
 {
     if (it.object()->isFloatingOrOutOfFlowPositioned())
         return false;
 
     if (it.object()->isRenderInline() && !alwaysRequiresLineBox(it.object()) && !requiresLineBoxForContent(toRenderInline(it.object()), lineInfo))
         return false;
 
     if (!shouldCollapseWhiteSpace(it.object()->style(), lineInfo, whitespacePosition) || it.object()->isBR())
         return true;
 
     UChar current = it.current();
     bool notJustWhitespace = current != ' ' && current != '\t' && current != softHyphen && (current != '\n' || it.object()->preservesNewline());
     return notJustWhitespace || isEmptyInline(it.object());
 }
 
 inline void setStaticPositions(RenderBlockFlow* block, RenderBox* child)
 {
     ASSERT(child->isOutOfFlowPositioned());
     // FIXME: The math here is actually not really right. It's a best-guess approximation that
     // will work for the common cases
-    RenderObject* containerBlock = child->container();
+    LayoutObject* containerBlock = child->container();
     LayoutUnit blockHeight = block->logicalHeight();
     if (containerBlock->isRenderInline()) {
         // A relative positioned inline encloses us. In this case, we also have to determine our
         // position as though we were an inline. Set |staticInlinePosition| and |staticBlockPosition| on the relative positioned
         // inline so that we can obtain the value later.
         toRenderInline(containerBlock)->layer()->setStaticInlinePosition(block->startAlignedOffsetForLine(blockHeight, false));
         toRenderInline(containerBlock)->layer()->setStaticBlockPosition(blockHeight);
 
         // If |child| is a leading or trailing positioned object this is its only opportunity to ensure it moves with an inline
         // container changing width.
         child->moveWithEdgeOfInlineContainerIfNecessary(child->isHorizontalWritingMode());
     }
     block->updateStaticInlinePositionForChild(*child, blockHeight);
     child->layer()->setStaticBlockPosition(blockHeight);
 }
 
 // FIXME: The entire concept of the skipTrailingWhitespace function is flawed, since we really need to be building
 // line boxes even for containers that may ultimately collapse away. Otherwise we'll never get positioned
 // 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();
+        LayoutObject* 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()
 {
@@ skipping 20 matching lines @@
     if (!m_collapseWhiteSpace)
         m_currentCharacterIsSpace = false;
 
     m_current.moveToStartOf(m_nextObject);
     m_atStart = false;
 }
 
 inline void BreakingContext::handleBR(EClear& clear)
 {
     if (m_width.fitsOnLine()) {
-        RenderObject* br = m_current.object();
+        LayoutObject* br = m_current.object();
         m_lineBreak.moveToStartOf(br);
         m_lineBreak.increment();
 
         // A <br> always breaks a line, so don't let the line be collapsed
         // away. Also, the space at the end of a line with a <br> does not
         // get collapsed away. It only does this if the previous line broke
         // cleanly. Otherwise the <br> has no effect on whether the line is
         // empty or not.
         if (m_startingNewParagraph)
             m_lineInfo.setEmpty(false, m_block, &m_width);
@@ skipping 15 matching lines @@
 inline LayoutUnit borderPaddingMarginStart(RenderInline* child)
 {
     return child->marginStart() + child->paddingStart() + child->borderStart();
 }
 
 inline LayoutUnit borderPaddingMarginEnd(RenderInline* child)
 {
     return child->marginEnd() + child->paddingEnd() + child->borderEnd();
 }
 
-inline bool shouldAddBorderPaddingMargin(RenderObject* child, bool &checkSide)
+inline bool shouldAddBorderPaddingMargin(LayoutObject* child, bool &checkSide)
 {
     if (!child || (child->isText() && !toRenderText(child)->textLength()))
         return true;
     checkSide = false;
     return checkSide;
 }
 
-inline LayoutUnit inlineLogicalWidth(RenderObject* child, bool start = true, bool end = true)
+inline LayoutUnit inlineLogicalWidth(LayoutObject* child, bool start = true, bool end = true)
 {
     unsigned lineDepth = 1;
     LayoutUnit extraWidth = 0;
-    RenderObject* parent = child->parent();
+    LayoutObject* parent = child->parent();
     while (parent->isRenderInline() && lineDepth++ < cMaxLineDepth) {
         RenderInline* parentAsRenderInline = toRenderInline(parent);
         if (!isEmptyInline(parentAsRenderInline)) {
             if (start && shouldAddBorderPaddingMargin(child->previousSibling(), start))
                 extraWidth += borderPaddingMarginStart(parentAsRenderInline);
             if (end && shouldAddBorderPaddingMargin(child->nextSibling(), end))
                 extraWidth += borderPaddingMarginEnd(parentAsRenderInline);
             if (!start && !end)
                 return extraWidth;
         }
@@ skipping 47 matching lines @@
         }
     } 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)
+inline bool shouldSkipWhitespaceAfterStartObject(RenderBlockFlow* block, LayoutObject* o, LineMidpointState& lineMidpointState)
 {
-    RenderObject* next = bidiNextSkippingEmptyInlines(block, o);
+    LayoutObject* next = bidiNextSkippingEmptyInlines(block, o);
     while (next && next->isFloatingOrOutOfFlowPositioned())
         next = bidiNextSkippingEmptyInlines(block, next);
 
     if (next && !next->isBR() && next->isText() && toRenderText(next)->textLength() > 0) {
         RenderText* nextText = toRenderText(next);
         UChar nextChar = nextText->characterAt(0);
         if (nextText->style()->isCollapsibleWhiteSpace(nextChar)) {
             lineMidpointState.startIgnoringSpaces(InlineIterator(0, o, 0));
             return true;
         }
@@ skipping 489 matching lines @@
 
     if (style->textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h