Create LineLayout api

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.
@@ skipping 12 matching lines @@
 
 #ifndef BreakingContextInlineHeaders_h
 #define BreakingContextInlineHeaders_h
 
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutListMarker.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutRubyRun.h"
 #include "core/layout/LayoutTextCombine.h"
 #include "core/layout/TextRunConstructor.h"
+#include "core/layout/api/LineLayoutBox.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/line/InlineTextBox.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/layout/svg/LayoutSVGInlineText.h"
 #include "core/paint/DeprecatedPaintLayer.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 {
 public:
-    BreakingContext(InlineBidiResolver& resolver, LineInfo& inLineInfo, LineWidth& lineWidth, LayoutTextInfo& inLayoutTextInfo, FloatingObject* inLastFloatFromPreviousLine, bool appliedStartWidth, LayoutBlockFlow* block)
+    BreakingContext(InlineBidiResolver& resolver, LineInfo& inLineInfo, LineWidth& lineWidth, LayoutTextInfo& inLayoutTextInfo, FloatingObject* inLastFloatFromPreviousLine, bool appliedStartWidth, LineLayoutBlockFlow block)
         : 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_layoutTextInfo(inLayoutTextInfo)
@@ skipping 45 matching lines @@
 
 private:
     void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
 
     InlineBidiResolver& m_resolver;
 
     InlineIterator m_current;
     InlineIterator m_lineBreak;
     InlineIterator m_startOfIgnoredSpaces;
 
-    LayoutBlockFlow* m_block;
+    LineLayoutBlockFlow m_block;
     LayoutObject* m_lastObject;
     LayoutObject* m_nextObject;
 
     const ComputedStyle* m_currentStyle;
     const ComputedStyle* m_blockStyle;
 
     LineInfo& m_lineInfo;
 
     LayoutTextInfo& m_layoutTextInfo;
 
@@ skipping 62 matching lines @@
         return false;
 
     if (!shouldCollapseWhiteSpace(it.object()->styleRef(), lineInfo, whitespacePosition) || it.object()->isBR())
         return true;
 
     UChar current = it.current();
     bool notJustWhitespace = current != spaceCharacter && current != tabulationCharacter && current != softHyphenCharacter && (current != newlineCharacter || it.object()->preservesNewline());
     return notJustWhitespace || isEmptyInline(it.object());
 }
 
-inline void setStaticPositions(LayoutBlockFlow* block, LayoutBox* child)
+inline void setStaticPositions(LineLayoutBlockFlow block, LayoutBox* 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
     LayoutObject* containerBlock = child->container();
-    LayoutUnit blockHeight = block->logicalHeight();
+    LayoutUnit blockHeight = block.logicalHeight();
     if (containerBlock->isLayoutInline()) {
         // 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.
-        toLayoutInline(containerBlock)->layer()->setStaticInlinePosition(block->startAlignedOffsetForLine(blockHeight, false));
+        toLayoutInline(containerBlock)->layer()->setStaticInlinePosition(block.startAlignedOffsetForLine(blockHeight, false));
         toLayoutInline(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);
+    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)) {
         LayoutObject* object = iterator.object();
         if (object->isOutOfFlowPositioned())
             setStaticPositions(m_block, toLayoutBox(object));
         else if (object->isFloating())
-            m_block->insertFloatingObject(*toLayoutBox(object));
+            m_block.insertFloatingObject(*toLayoutBox(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 89 matching lines @@
     return extraWidth;
 }
 
 inline void BreakingContext::handleOutOfFlowPositioned(Vector<LayoutBox*>& positionedObjects)
 {
     // If our original display wasn't an inline type, then we can
     // go ahead and determine our static inline position now.
     LayoutBox* box = toLayoutBox(m_current.object());
     bool isInlineType = box->style()->isOriginalDisplayInlineType();
     if (!isInlineType) {
-        m_block->setStaticInlinePositionForChild(*box, m_block->startOffsetForContent());
+        m_block.setStaticInlinePositionForChild(*box, m_block.startOffsetForContent());
     } else {
         // If our original display was an INLINE type, then we can go ahead
         // and determine our static y position now.
-        box->layer()->setStaticBlockPosition(m_block->logicalHeight());
+        box->layer()->setStaticBlockPosition(m_block.logicalHeight());
     }
 
     // If we're ignoring spaces, we have to stop and include this object and
     // then start ignoring spaces again.
     if (isInlineType || box->container()->isLayoutInline()) {
         if (m_ignoringSpaces)
             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_layoutTextInfo.m_lineBreakIterator.resetPriorContext();
 }
 
 inline void BreakingContext::handleFloat()
 {
     LayoutBox* floatBox = toLayoutBox(m_current.object());
-    FloatingObject* floatingObject = m_block->insertFloatingObject(*floatBox);
+    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_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_layoutTextInfo.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(LayoutBlockFlow* block, LayoutObject* o, LineMidpointState& lineMidpointState)
+inline bool shouldSkipWhitespaceAfterStartObject(LineLayoutBlockFlow block, LayoutObject* o, LineMidpointState& lineMidpointState)
 {
     LayoutObject* next = bidiNextSkippingEmptyInlines(block, o);
     while (next && next->isFloatingOrOutOfFlowPositioned())
         next = bidiNextSkippingEmptyInlines(block, next);
 
     if (next && !next->isBR() && next->isText() && toLayoutText(next)->textLength() > 0) {
         LayoutText* nextText = toLayoutText(next);
         UChar nextChar = nextText->characterAt(0);
         if (nextText->style()->isCollapsibleWhiteSpace(nextChar)) {
             lineMidpointState.startIgnoringSpaces(InlineIterator(0, o, 0));
@@ skipping 54 matching lines @@
     if (m_ignoringSpaces)
         m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.object(), 0));
 
     m_lineInfo.setEmpty(false, m_block, &m_width);
     m_ignoringSpaces = false;
     m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = false;
     m_trailingObjects.clear();
 
     // Optimize for a common case. If we can't find whitespace after the list
     // item, then this is all moot.
-    LayoutUnit replacedLogicalWidth = m_block->logicalWidthForChild(*replacedBox) + m_block->marginStartForChild(*replacedBox) + m_block->marginEndForChild(*replacedBox) + inlineLogicalWidth(m_current.object());
+    LayoutUnit replacedLogicalWidth = m_block.logicalWidthForChild(*replacedBox) + m_block.marginStartForChild(*replacedBox) + m_block.marginEndForChild(*replacedBox) + inlineLogicalWidth(m_current.object());
     if (m_current.object()->isListMarker()) {
         if (m_blockStyle->collapseWhiteSpace() && shouldSkipWhitespaceAfterStartObject(m_block, m_current.object(), m_lineMidpointState)) {
             // Like with inline flows, we start ignoring spaces to make sure that any
             // additional spaces we see will be discarded.
             m_currentCharacterShouldCollapseIfPreWap = m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         }
         if (toLayoutListMarker(m_current.object())->isInside())
             m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     } else {
@@ skipping 423 matching lines @@
 
     if (style.textIndentType() == TextIndentHanging)
         shouldIndentText = shouldIndentText == IndentText ? DoNotIndentText : IndentText;
 
     return shouldIndentText;
 }
 
 }
 
 #endif // BreakingContextInlineHeaders_h