Rename enums/functions that collide in chromium style in core/layout/.

third_party/WebKit/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 40 matching lines @@
 const unsigned cMaxLineDepth = 200;
 
 class BreakingContext {
     STACK_ALLOCATED();
 public:
     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.lineLayoutItem())
+        , m_lastObject(m_current.getLineLayoutItem())
         , m_nextObject(nullptr)
         , m_currentStyle(nullptr)
         , m_blockStyle(block.style())
         , m_lineInfo(inLineInfo)
         , m_layoutTextInfo(inLayoutTextInfo)
         , 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_appliedStartWidth(appliedStartWidth)
         , m_includeEndWidth(true)
         , m_autoWrap(false)
         , m_autoWrapWasEverTrueOnLine(false)
         , 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);
     }
 
-    LineLayoutItem currentItem() { return m_current.lineLayoutItem(); }
+    LineLayoutItem currentItem() { return m_current.getLineLayoutItem(); }
     InlineIterator lineBreak() { return m_lineBreak; }
     bool atEnd() { return m_atEnd; }
 
     void initializeForCurrentObject();
 
     void increment();
 
     void handleBR(EClear&);
     void handleOutOfFlowPositioned(Vector<LineLayoutBox>& positionedObjects);
     void handleFloat();
@@ skipping 93 matching lines @@
 inline bool alwaysRequiresLineBox(LineLayoutItem 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) && LineLayoutInline(flow).hasInlineDirectionBordersPaddingOrMargin();
 }
 
 inline bool requiresLineBox(const InlineIterator& it, const LineInfo& lineInfo = LineInfo(), WhitespacePosition whitespacePosition = LeadingWhitespace)
 {
-    if (it.lineLayoutItem().isFloatingOrOutOfFlowPositioned())
+    if (it.getLineLayoutItem().isFloatingOrOutOfFlowPositioned())
         return false;
 
-    if (it.lineLayoutItem().isLayoutInline() && !alwaysRequiresLineBox(it.lineLayoutItem()) && !requiresLineBoxForContent(LineLayoutInline(it.lineLayoutItem()), lineInfo))
+    if (it.getLineLayoutItem().isLayoutInline() && !alwaysRequiresLineBox(it.getLineLayoutItem()) && !requiresLineBoxForContent(LineLayoutInline(it.getLineLayoutItem()), lineInfo))
         return false;
 
-    if (!shouldCollapseWhiteSpace(it.lineLayoutItem().styleRef(), lineInfo, whitespacePosition) || it.lineLayoutItem().isBR())
+    if (!shouldCollapseWhiteSpace(it.getLineLayoutItem().styleRef(), lineInfo, whitespacePosition) || it.getLineLayoutItem().isBR())
         return true;
 
     UChar current = it.current();
-    bool notJustWhitespace = current != spaceCharacter && current != tabulationCharacter && current != softHyphenCharacter && (current != newlineCharacter || it.lineLayoutItem().preservesNewline());
-    return notJustWhitespace || isEmptyInline(it.lineLayoutItem());
+    bool notJustWhitespace = current != spaceCharacter && current != tabulationCharacter && current != softHyphenCharacter && (current != newlineCharacter || it.getLineLayoutItem().preservesNewline());
+    return notJustWhitespace || isEmptyInline(it.getLineLayoutItem());
 }
 
 inline void setStaticPositions(LineLayoutBlockFlow block, LineLayoutBox child, IndentTextOrNot indentText)
 {
     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
     LineLayoutItem containerBlock = child.container();
     LayoutUnit blockHeight = block.logicalHeight();
     if (containerBlock.isLayoutInline()) {
@@ skipping 13 matching lines @@
 
 // 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)) {
-        LineLayoutItem item = iterator.lineLayoutItem();
+        LineLayoutItem item = iterator.getLineLayoutItem();
         if (item.isOutOfFlowPositioned())
             setStaticPositions(m_block, LineLayoutBox(item), DoNotIndentText);
         else if (item.isFloating())
             m_block.insertFloatingObject(LineLayoutBox(item));
         iterator.increment();
     }
 }
 
 inline void BreakingContext::initializeForCurrentObject()
 {
-    m_currentStyle = m_current.lineLayoutItem().style();
-    m_nextObject = bidiNextSkippingEmptyInlines(m_block, m_current.lineLayoutItem());
-    if (m_nextObject && m_nextObject.parent() && !m_nextObject.parent().isDescendantOf(m_current.lineLayoutItem().parent()))
+    m_currentStyle = m_current.getLineLayoutItem().style();
+    m_nextObject = bidiNextSkippingEmptyInlines(m_block, m_current.getLineLayoutItem());
+    if (m_nextObject && m_nextObject.parent() && !m_nextObject.parent().isDescendantOf(m_current.getLineLayoutItem().parent()))
         m_includeEndWidth = true;
 
-    m_currWS = m_current.lineLayoutItem().isLayoutInline() ? m_currentStyle->whiteSpace() : m_current.lineLayoutItem().parent().style()->whiteSpace();
+    m_currWS = m_current.getLineLayoutItem().isLayoutInline() ? m_currentStyle->whiteSpace() : m_current.getLineLayoutItem().parent().style()->whiteSpace();
     m_lastWS = m_lastObject.isLayoutInline() ? m_lastObject.style()->whiteSpace() : m_lastObject.parent().style()->whiteSpace();
 
-    bool isSVGText = m_current.lineLayoutItem().isSVGInlineText();
+    bool isSVGText = m_current.getLineLayoutItem().isSVGInlineText();
     m_autoWrap = !isSVGText && ComputedStyle::autoWrap(m_currWS);
     m_autoWrapWasEverTrueOnLine = m_autoWrapWasEverTrueOnLine || m_autoWrap;
 
     m_preservesNewline = !isSVGText && ComputedStyle::preserveNewline(m_currWS);
 
     m_collapseWhiteSpace = ComputedStyle::collapseWhiteSpace(m_currWS);
 
     // Ensure the whitespace in constructions like '<span style="white-space: pre-wrap">text <span><span> text</span>'
     // does not collapse.
     if (m_collapseWhiteSpace && !ComputedStyle::collapseWhiteSpace(m_lastWS))
         m_currentCharacterIsSpace = false;
 }
 
 inline void BreakingContext::increment()
 {
     m_current.moveToStartOf(m_nextObject);
 
     // When the line box tree is created, this position in the line will be snapped to
     // LayoutUnit's, and those measurements will be used by the paint code.  Do the
     // equivalent snapping here, to get consistent line measurements.
     m_width.snapUncommittedWidth();
 
     m_atStart = false;
 }
 
 inline void BreakingContext::handleBR(EClear& clear)
 {
     if (m_width.fitsOnLine()) {
-        LineLayoutItem br = m_current.lineLayoutItem();
+        LineLayoutItem br = m_current.getLineLayoutItem();
         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 48 matching lines @@
         child = parent;
         parent = child.parent();
     }
     return extraWidth;
 }
 
 inline void BreakingContext::handleOutOfFlowPositioned(Vector<LineLayoutBox>& positionedObjects)
 {
     // If our original display wasn't an inline type, then we can
     // go ahead and determine our static inline position now.
-    LineLayoutBox box(m_current.lineLayoutItem());
+    LineLayoutBox box(m_current.getLineLayoutItem());
     bool isInlineType = box.style()->isOriginalDisplayInlineType();
     if (!isInlineType) {
         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());
     }
 
     // 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)
             ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, box);
         m_trailingObjects.appendObjectIfNeeded(box);
     } else {
         positionedObjects.append(box);
     }
     m_width.addUncommittedWidth(inlineLogicalWidthFromAncestorsIfNeeded(box).toFloat());
     // Reset prior line break context characters.
     m_layoutTextInfo.m_lineBreakIterator.resetPriorContext();
 }
 
 inline void BreakingContext::handleFloat()
 {
-    LineLayoutBox floatBox(m_current.lineLayoutItem());
+    LineLayoutBox floatBox(m_current.getLineLayoutItem());
     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.lineLayoutItem() == m_current.lineLayoutItem()) {
+        if (m_lineBreak.getLineLayoutItem() == m_current.getLineLayoutItem()) {
             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);
 }
 
@@ skipping 16 matching lines @@
             return true;
         }
     }
 
     return false;
 }
 
 inline void BreakingContext::handleEmptyInline()
 {
     // This should only end up being called on empty inlines
-    ASSERT(m_current.lineLayoutItem());
+    ASSERT(m_current.getLineLayoutItem());
 
-    LineLayoutInline flowBox(m_current.lineLayoutItem());
+    LineLayoutInline flowBox(m_current.getLineLayoutItem());
 
-    bool requiresLineBox = alwaysRequiresLineBox(m_current.lineLayoutItem());
+    bool requiresLineBox = alwaysRequiresLineBox(m_current.getLineLayoutItem());
     if (requiresLineBox || requiresLineBoxForContent(flowBox, m_lineInfo)) {
         // An empty inline that only has line-height, vertical-align or font-metrics will
         // not force linebox creation (and thus affect the height of the line) if the rest of the line is empty.
         if (requiresLineBox)
             m_lineInfo.setEmpty(false, m_block, &m_width);
         if (m_ignoringSpaces) {
             // If we are in a run of ignored spaces then ensure we get a linebox if lineboxes are eventually
             // created for the line...
             m_trailingObjects.clear();
-            ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, m_current.lineLayoutItem());
-        } else if (m_blockStyle->collapseWhiteSpace() && m_resolver.position().lineLayoutItem() == m_current.lineLayoutItem()
-            && shouldSkipWhitespaceAfterStartObject(m_block, m_current.lineLayoutItem(), m_lineMidpointState)) {
+            ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, m_current.getLineLayoutItem());
+        } else if (m_blockStyle->collapseWhiteSpace() && m_resolver.position().getLineLayoutItem() == m_current.getLineLayoutItem()
+            && shouldSkipWhitespaceAfterStartObject(m_block, m_current.getLineLayoutItem(), m_lineMidpointState)) {
             // If this object is at the start of the line, we need to behave like list markers and
             // start ignoring spaces.
             m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         } else {
             // If we are after a trailing space but aren't ignoring spaces yet then ensure we get a linebox
             // if we encounter collapsible whitepace.
-            m_trailingObjects.appendObjectIfNeeded(m_current.lineLayoutItem());
+            m_trailingObjects.appendObjectIfNeeded(m_current.getLineLayoutItem());
         }
     }
 
-    m_width.addUncommittedWidth((inlineLogicalWidthFromAncestorsIfNeeded(m_current.lineLayoutItem()) + borderPaddingMarginStart(flowBox) + borderPaddingMarginEnd(flowBox)).toFloat());
+    m_width.addUncommittedWidth((inlineLogicalWidthFromAncestorsIfNeeded(m_current.getLineLayoutItem()) + borderPaddingMarginStart(flowBox) + borderPaddingMarginEnd(flowBox)).toFloat());
 }
 
 inline void BreakingContext::handleReplaced()
 {
-    LineLayoutBox replacedBox(m_current.lineLayoutItem());
+    LineLayoutBox replacedBox(m_current.getLineLayoutItem());
 
     if (m_atStart)
         m_width.updateAvailableWidth(replacedBox.logicalHeight());
 
     // Break on replaced elements if either has normal white-space,
     // or if the replaced element is ruby that can break before.
-    if ((m_autoWrap || ComputedStyle::autoWrap(m_lastWS)) && (!m_current.lineLayoutItem().isImage() || m_allowImagesToBreak)
-        && (!m_current.lineLayoutItem().isRubyRun() || LineLayoutRubyRun(m_current.lineLayoutItem()).canBreakBefore(m_layoutTextInfo.m_lineBreakIterator))) {
+    if ((m_autoWrap || ComputedStyle::autoWrap(m_lastWS)) && (!m_current.getLineLayoutItem().isImage() || m_allowImagesToBreak)
+        && (!m_current.getLineLayoutItem().isRubyRun() || LineLayoutRubyRun(m_current.getLineLayoutItem()).canBreakBefore(m_layoutTextInfo.m_lineBreakIterator))) {
         m_width.commit();
-        m_lineBreak.moveToStartOf(m_current.lineLayoutItem());
+        m_lineBreak.moveToStartOf(m_current.getLineLayoutItem());
     }
 
     if (m_ignoringSpaces)
-        m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.lineLayoutItem(), 0));
+        m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.getLineLayoutItem(), 0));
 
     m_lineInfo.setEmpty(false, m_block, &m_width);
     m_ignoringSpaces = false;
     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) + inlineLogicalWidthFromAncestorsIfNeeded(m_current.lineLayoutItem());
-    if (m_current.lineLayoutItem().isListMarker()) {
-        if (m_blockStyle->collapseWhiteSpace() && shouldSkipWhitespaceAfterStartObject(m_block, m_current.lineLayoutItem(), m_lineMidpointState)) {
+    LayoutUnit replacedLogicalWidth = m_block.logicalWidthForChild(replacedBox) + m_block.marginStartForChild(replacedBox) + m_block.marginEndForChild(replacedBox) + inlineLogicalWidthFromAncestorsIfNeeded(m_current.getLineLayoutItem());
+    if (m_current.getLineLayoutItem().isListMarker()) {
+        if (m_blockStyle->collapseWhiteSpace() && shouldSkipWhitespaceAfterStartObject(m_block, m_current.getLineLayoutItem(), m_lineMidpointState)) {
             // Like with inline flows, we start ignoring spaces to make sure that any
             // additional spaces we see will be discarded.
             m_currentCharacterIsSpace = true;
             m_ignoringSpaces = true;
         }
-        if (LineLayoutListMarker(m_current.lineLayoutItem()).isInside())
+        if (LineLayoutListMarker(m_current.getLineLayoutItem()).isInside())
             m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     } else {
         m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
     }
-    if (m_current.lineLayoutItem().isRubyRun())
-        m_width.applyOverhang(LineLayoutRubyRun(m_current.lineLayoutItem()), m_lastObject, m_nextObject);
+    if (m_current.getLineLayoutItem().isRubyRun())
+        m_width.applyOverhang(LineLayoutRubyRun(m_current.getLineLayoutItem()), m_lastObject, m_nextObject);
     // Update prior line break context characters, using U+FFFD (OBJECT REPLACEMENT CHARACTER) for replaced element.
     m_layoutTextInfo.m_lineBreakIterator.updatePriorContext(replacementCharacter);
 }
 
 inline void nextCharacter(UChar& currentCharacter, UChar& lastCharacter, UChar& secondToLastCharacter)
 {
     secondToLastCharacter = lastCharacter;
     lastCharacter = currentCharacter;
 }
 
@@ skipping 21 matching lines @@
     run.setTabSize(!collapseWhiteSpace, text.style()->tabSize());
     run.setXPos(xPos);
     return font.width(run, fallbackFonts, glyphBounds);
 }
 
 inline bool BreakingContext::handleText(WordMeasurements& wordMeasurements, bool& hyphenated)
 {
     if (!m_current.offset())
         m_appliedStartWidth = false;
 
-    LineLayoutText layoutText(m_current.lineLayoutItem());
+    LineLayoutText layoutText(m_current.getLineLayoutItem());
 
     // If we have left a no-wrap inline and entered an autowrap inline while ignoring spaces
     // then we need to mark the start of the autowrap inline as a potential linebreak now.
     if (m_autoWrap && !ComputedStyle::autoWrap(m_lastWS) && m_ignoringSpaces) {
         m_width.commit();
-        m_lineBreak.moveToStartOf(m_current.lineLayoutItem());
+        m_lineBreak.moveToStartOf(m_current.getLineLayoutItem());
     }
 
     const ComputedStyle& style = layoutText.styleRef(m_lineInfo.isFirstLine());
     const Font& font = style.font();
 
     unsigned lastSpace = m_current.offset();
     float wordSpacing = m_currentStyle->wordSpacing();
     float lastSpaceWordSpacing = 0;
     float wordSpacingForWordMeasurement = 0;
 
@@ skipping 16 matching lines @@
     float hyphenWidth = 0;
 
     if (layoutText.isSVGInlineText()) {
         breakWords = false;
         breakAll = false;
         keepAll = false;
     }
 
     if (layoutText.isWordBreak()) {
         m_width.commit();
-        m_lineBreak.moveToStartOf(m_current.lineLayoutItem());
+        m_lineBreak.moveToStartOf(m_current.getLineLayoutItem());
         ASSERT(m_current.offset() == layoutText.textLength());
     }
 
     if (m_layoutTextInfo.m_text != layoutText) {
         m_layoutTextInfo.m_text = layoutText;
         m_layoutTextInfo.m_font = &font;
         m_layoutTextInfo.m_lineBreakIterator.resetStringAndReleaseIterator(layoutText.text(), style.locale());
     } else if (m_layoutTextInfo.m_font != &font) {
         m_layoutTextInfo.m_font = &font;
     }
@@ skipping 77 matching lines @@
 
         // We keep track of the total width contributed by trailing space as we often want to exclude it when determining
         // if a run fits on a line.
         if (m_collapseWhiteSpace && previousCharacterIsSpace && m_currentCharacterIsSpace && lastWidthMeasurement)
             m_width.setTrailingWhitespaceWidth(lastWidthMeasurement);
 
         // If this is the end of the first word in run of text then make sure we apply the width from any leading inlines.
         // For example: '<span style="margin-left: 5px;"><span style="margin-left: 10px;">FirstWord</span></span>' would
         // apply a width of 15px from the two span ancestors.
         if (!m_appliedStartWidth) {
-            m_width.addUncommittedWidth(inlineLogicalWidthFromAncestorsIfNeeded(m_current.lineLayoutItem(), true, false).toFloat());
+            m_width.addUncommittedWidth(inlineLogicalWidthFromAncestorsIfNeeded(m_current.getLineLayoutItem(), true, false).toFloat());
             m_appliedStartWidth = true;
         }
 
         applyWordSpacing = wordSpacing && m_currentCharacterIsSpace;
 
         // If we haven't hit a breakable position yet and already don't fit on the line try to move below any floats.
         if (!m_width.committedWidth() && m_autoWrap && !m_width.fitsOnLine() && !widthMeasurementAtLastBreakOpportunity)
             m_width.fitBelowFloats(m_lineInfo.isFirstLine());
 
         // If there is a soft-break available at this whitespace position then take it.
         applyWordSpacing = wordSpacing && m_currentCharacterIsSpace;
         if (canBreakAtWhitespace(breakWords, wordMeasurement, stoppedIgnoringSpaces, hyphenated, charWidth, hyphenWidth, betweenWords, midWordBreak, breakAll, previousCharacterIsSpace, lastWidthMeasurement, layoutText, font, applyWordSpacing, wordSpacing))
             return false;
 
         // If there is a hard-break available at this whitespace position then take it.
         if (c == newlineCharacter && m_preservesNewline) {
             if (!stoppedIgnoringSpaces && m_current.offset())
                 m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
-            m_lineBreak.moveTo(m_current.lineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
+            m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
             m_lineBreak.increment();
             m_lineInfo.setPreviousLineBrokeCleanly(true);
             return true;
         }
 
         // Auto-wrapping text should not wrap in the middle of a word once it has had an
         // opportunity to break after a word.
         if (m_autoWrap && betweenWords) {
             m_width.commit();
             widthFromLastBreakingOpportunity = 0;
-            m_lineBreak.moveTo(m_current.lineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
+            m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
             breakWords = false;
             widthMeasurementAtLastBreakOpportunity = lastWidthMeasurement;
         }
 
         // Remember this as a breakable position in case adding the end width forces a break.
         if (midWordBreak && !U16_IS_TRAIL(c) && !(WTF::Unicode::category(c) & (WTF::Unicode::Mark_NonSpacing | WTF::Unicode::Mark_Enclosing | WTF::Unicode::Mark_SpacingCombining))) {
-            m_lineBreak.moveTo(m_current.lineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
+            m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
             midWordBreak &= (breakWords || breakAll);
         }
 
         if (betweenWords) {
             lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
             wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurement.width) ? wordSpacing : 0;
             lastSpace = !breakAll || m_currentCharacterIsSpace ? m_current.offset() : lastSpace;
         }
 
         // If we encounter a newline, or if we encounter a second space, we need to go ahead and break up
@@ skipping 24 matching lines @@
     float lastWidthMeasurement = 0;
     wordMeasurement.startOffset = lastSpace;
     wordMeasurement.endOffset = m_current.offset();
     if (!m_ignoringSpaces) {
         lastWidthMeasurement = textWidth(layoutText, lastSpace, m_current.offset() - lastSpace, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds);
         wordMeasurement.width = lastWidthMeasurement + wordSpacingForWordMeasurement;
         wordMeasurement.glyphBounds.move(wordSpacingForWordMeasurement, 0);
     }
     lastWidthMeasurement += lastSpaceWordSpacing;
 
-    LayoutUnit additionalWidthFromAncestors = inlineLogicalWidthFromAncestorsIfNeeded(m_current.lineLayoutItem(), !m_appliedStartWidth, m_includeEndWidth);
+    LayoutUnit additionalWidthFromAncestors = inlineLogicalWidthFromAncestorsIfNeeded(m_current.getLineLayoutItem(), !m_appliedStartWidth, m_includeEndWidth);
     m_width.addUncommittedWidth(lastWidthMeasurement + additionalWidthFromAncestors);
 
     if (m_collapseWhiteSpace && m_currentCharacterIsSpace && lastWidthMeasurement)
         m_width.setTrailingWhitespaceWidth(lastWidthMeasurement + additionalWidthFromAncestors);
 
     m_includeEndWidth = false;
 
     if (!m_width.fitsOnLine()) {
         if (breakAll && widthMeasurementAtLastBreakOpportunity) {
             m_width.addUncommittedWidth(widthMeasurementAtLastBreakOpportunity);
@@ skipping 13 matching lines @@
     if (layoutText.isSVGInlineText() && m_current.offset()) {
         // Force creation of new InlineBoxes for each absolute positioned character (those that start new text chunks).
         if (LineLayoutSVGInlineText(layoutText).characterStartsNewTextChunk(m_current.offset()))
             m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
     }
     if (prohibitBreakInside) {
         m_current.setNextBreakablePosition(layoutText.textLength());
         prohibitBreakInside = false;
     }
     if (m_currentCharacterIsSpace && !previousCharacterIsSpace) {
-        m_startOfIgnoredSpaces.setLineLayoutItem(m_current.lineLayoutItem());
+        m_startOfIgnoredSpaces.setLineLayoutItem(m_current.getLineLayoutItem());
         m_startOfIgnoredSpaces.setOffset(m_current.offset());
     }
     if (!m_currentCharacterIsSpace && previousCharacterIsSpace) {
         if (m_autoWrap && m_currentStyle->breakOnlyAfterWhiteSpace())
-            m_lineBreak.moveTo(m_current.lineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
+            m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
     }
     if (m_collapseWhiteSpace && m_currentCharacterIsSpace && !m_ignoringSpaces)
-        m_trailingObjects.setTrailingWhitespace(LineLayoutText(m_current.lineLayoutItem()));
+        m_trailingObjects.setTrailingWhitespace(LineLayoutText(m_current.getLineLayoutItem()));
     else if (!m_currentStyle->collapseWhiteSpace() || !m_currentCharacterIsSpace)
         m_trailingObjects.clear();
 }
 
 
 inline void BreakingContext::stopIgnoringSpaces(unsigned& lastSpace)
 {
     m_ignoringSpaces = false;
     lastSpace = m_current.offset(); // e.g., "Foo    goo", don't add in any of the ignored spaces.
-    m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.lineLayoutItem(), m_current.offset()));
+    m_lineMidpointState.stopIgnoringSpaces(InlineIterator(0, m_current.getLineLayoutItem(), m_current.offset()));
 }
 
 inline WordMeasurement& BreakingContext::calculateWordWidth(WordMeasurements& wordMeasurements, LineLayoutText& layoutText, unsigned lastSpace, float& lastWidthMeasurement, float wordSpacingForWordMeasurement, const Font& font, float wordTrailingSpaceWidth, UChar c)
 {
     wordMeasurements.grow(wordMeasurements.size() + 1);
     WordMeasurement& wordMeasurement = wordMeasurements.last();
     wordMeasurement.layoutText = layoutText;
     wordMeasurement.endOffset = m_current.offset();
     wordMeasurement.startOffset = lastSpace;
 
@@ skipping 12 matching lines @@
     // If we break only after white-space, consider the current character
     // as candidate width for this line.
     if (m_width.fitsOnLine() && m_currentCharacterIsSpace && m_currentStyle->breakOnlyAfterWhiteSpace() && !midWordBreak) {
         float charWidth = textWidth(layoutText, m_current.offset(), 1, font, m_width.currentWidth(), m_collapseWhiteSpace, &wordMeasurement.fallbackFonts, &wordMeasurement.glyphBounds) + (applyWordSpacing ? wordSpacing : 0);
         // Check if line is too big even without the extra space
         // at the end of the line. If it is not, do nothing.
         // If the line needs the extra whitespace to be too long,
         // then move the line break to the space and skip all
         // additional whitespace.
         if (!m_width.fitsOnLine(charWidth)) {
-            m_lineBreak.moveTo(m_current.lineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
+            m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(), m_current.nextBreakablePosition());
             skipTrailingWhitespace(m_lineBreak, m_lineInfo);
             return true;
         }
     }
     return false;
 }
 
 inline bool BreakingContext::canBreakAtWhitespace(bool breakWords, WordMeasurement& wordMeasurement, bool stoppedIgnoringSpaces, bool& hyphenated, float charWidth, float& hyphenWidth, bool betweenWords, bool midWordBreak, bool breakAll, bool previousCharacterIsSpace, float lastWidthMeasurement, const LineLayoutText& layoutText, const Font& font, bool applyWordSpacing, float wordSpacing)
 {
     if (!m_autoWrap && !breakWords)
         return false;
 
     // If we break only after white-space, consider the current character
     // as candidate width for this line.
     if (trailingSpaceExceedsAvailableWidth(midWordBreak, layoutText, wordMeasurement, applyWordSpacing, wordSpacing, font) || !m_width.fitsOnLine()) {
         if (m_lineBreak.atTextParagraphSeparator()) {
             if (!stoppedIgnoringSpaces && m_current.offset() > 0)
                 m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
             m_lineBreak.increment();
             m_lineInfo.setPreviousLineBrokeCleanly(true);
             wordMeasurement.endOffset = m_lineBreak.offset();
         }
-        if (m_lineBreak.lineLayoutItem() && m_lineBreak.offset() && m_lineBreak.lineLayoutItem().isText() && LineLayoutText(m_lineBreak.lineLayoutItem()).textLength() && LineLayoutText(m_lineBreak.lineLayoutItem()).characterAt(m_lineBreak.offset() - 1) == softHyphenCharacter)
+        if (m_lineBreak.getLineLayoutItem() && m_lineBreak.offset() && m_lineBreak.getLineLayoutItem().isText() && LineLayoutText(m_lineBreak.getLineLayoutItem()).textLength() && LineLayoutText(m_lineBreak.getLineLayoutItem()).characterAt(m_lineBreak.offset() - 1) == softHyphenCharacter)
             hyphenated = true;
         if (m_lineBreak.offset() && m_lineBreak.offset() != (unsigned)wordMeasurement.endOffset && !wordMeasurement.width) {
             if (charWidth) {
                 wordMeasurement.endOffset = m_lineBreak.offset();
                 wordMeasurement.width = charWidth;
             }
         }
         // Didn't fit. Jump to the end unless there's still an opportunity to collapse whitespace.
         if (m_ignoringSpaces || !m_collapseWhiteSpace || !m_currentCharacterIsSpace || !previousCharacterIsSpace) {
             m_atEnd = true;
             return true;
         }
     } else {
         if (!betweenWords || (midWordBreak && !m_autoWrap) || (breakAll && !m_currentCharacterIsSpace))
             m_width.addUncommittedWidth(-lastWidthMeasurement);
         if (hyphenWidth) {
             // Subtract the width of the soft hyphen out since we fit on a line.
             m_width.addUncommittedWidth(-hyphenWidth);
             hyphenWidth = 0;
         }
     }
     return false;
 }
 
 inline void BreakingContext::commitAndUpdateLineBreakIfNeeded()
 {
     bool checkForBreak = m_autoWrap;
-    if (m_width.committedWidth() && !m_width.fitsOnLine() && m_lineBreak.lineLayoutItem() && m_currWS == NOWRAP) {
+    if (m_width.committedWidth() && !m_width.fitsOnLine() && m_lineBreak.getLineLayoutItem() && m_currWS == NOWRAP) {
         if (m_width.fitsOnLine(0, ExcludeWhitespace)) {
             m_width.commit();
             m_lineBreak.moveToStartOf(m_nextObject);
         }
         checkForBreak = true;
-    } else if (m_nextObject && m_current.lineLayoutItem().isText() && m_nextObject.isText() && !m_nextObject.isBR() && (m_autoWrap || m_nextObject.style()->autoWrap())) {
+    } else if (m_nextObject && m_current.getLineLayoutItem().isText() && m_nextObject.isText() && !m_nextObject.isBR() && (m_autoWrap || m_nextObject.style()->autoWrap())) {
         if (m_autoWrap && m_currentCharacterIsSpace) {
             checkForBreak = true;
         } else {
             LineLayoutText nextText(m_nextObject);
             if (nextText.textLength()) {
                 UChar c = nextText.characterAt(0);
                 // If the next item on the line is text, and if we did not end with
                 // a space, then the next text run continues our word (and so it needs to
                 // keep adding to the uncommitted width. Just update and continue.
                 checkForBreak = !m_currentCharacterIsSpace && (c == spaceCharacter || c == tabulationCharacter || (c == newlineCharacter && !m_nextObject.preservesNewline()));
@@ skipping 31 matching lines @@
         if (!m_width.fitsOnLine()) {
             m_atEnd = true;
             return;
         }
     } else if (m_blockStyle->autoWrap() && !m_width.fitsOnLine() && !m_width.committedWidth()) {
         // If the container autowraps but the current child does not then we still need to ensure that it
         // wraps and moves below any floats.
         m_width.fitBelowFloats(m_lineInfo.isFirstLine());
     }
 
-    if (!m_current.lineLayoutItem().isFloatingOrOutOfFlowPositioned()) {
-        m_lastObject = m_current.lineLayoutItem();
+    if (!m_current.getLineLayoutItem().isFloatingOrOutOfFlowPositioned()) {
+        m_lastObject = m_current.getLineLayoutItem();
         if (m_lastObject.isAtomicInlineLevel() && m_autoWrap && (!m_lastObject.isImage() || m_allowImagesToBreak) && (!m_lastObject.isListMarker() || LineLayoutListMarker(m_lastObject).isInside())
             && !m_lastObject.isRubyRun()) {
             m_width.commit();
             m_lineBreak.moveToStartOf(m_nextObject);
         }
     }
 }
 
 inline IndentTextOrNot requiresIndent(bool isFirstLine, bool isAfterHardLineBreak, const ComputedStyle& style)
 {
     IndentTextOrNot indentText = DoNotIndentText;
     if (isFirstLine || (isAfterHardLineBreak && style.textIndentLine()) == TextIndentEachLine)
         indentText = IndentText;
 
     if (style.textIndentType() == TextIndentHanging)
         indentText = indentText == IndentText ? DoNotIndentText : IndentText;
 
     return indentText;
 }
 
 } // namespace blink
 
 #endif // BreakingContextInlineHeaders_h