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

third_party/WebKit/Source/core/layout/line/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 94 matching lines @@
         LayoutRect logicalOverflowRect = this->logicalOverflowRect();
         logicalOverflowRect.move(isHorizontal() ? delta : delta.transposedSize());
         setLogicalOverflowRect(logicalOverflowRect);
     }
 }
 
 int InlineTextBox::baselinePosition(FontBaseline baselineType) const
 {
     if (!isText() || !parent())
         return 0;
-    if (parent()->lineLayoutItem() == lineLayoutItem().parent())
+    if (parent()->getLineLayoutItem() == getLineLayoutItem().parent())
         return parent()->baselinePosition(baselineType);
-    return LineLayoutBoxModel(lineLayoutItem().parent()).baselinePosition(baselineType, isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
+    return LineLayoutBoxModel(getLineLayoutItem().parent()).baselinePosition(baselineType, isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 }
 
 LayoutUnit InlineTextBox::lineHeight() const
 {
-    if (!isText() || !lineLayoutItem().parent())
+    if (!isText() || !getLineLayoutItem().parent())
         return LayoutUnit();
-    if (lineLayoutItem().isBR())
-        return LayoutUnit(toLayoutBR(lineLayoutItem())->lineHeight(isFirstLineStyle()));
-    if (parent()->lineLayoutItem() == lineLayoutItem().parent())
+    if (getLineLayoutItem().isBR())
+        return LayoutUnit(toLayoutBR(getLineLayoutItem())->lineHeight(isFirstLineStyle()));
+    if (parent()->getLineLayoutItem() == getLineLayoutItem().parent())
         return parent()->lineHeight();
-    return LineLayoutBoxModel(lineLayoutItem().parent()).lineHeight(isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
+    return LineLayoutBoxModel(getLineLayoutItem().parent()).lineHeight(isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 }
 
 bool InlineTextBox::isSelected(int startPos, int endPos) const
 {
     int sPos = std::max(startPos - m_start, 0);
     // The position after a hard line break is considered to be past its end.
-    // See the corresponding code in InlineTextBox::selectionState.
+    // See the corresponding code in InlineTextBox::getSelectionState.
     int ePos = std::min(endPos - m_start, int(m_len) + (isLineBreak() ? 0 : 1));
     return (sPos < ePos);
 }
 
-SelectionState InlineTextBox::selectionState() const
+SelectionState InlineTextBox::getSelectionState() const
 {
-    SelectionState state = lineLayoutItem().selectionState();
+    SelectionState state = getLineLayoutItem().getSelectionState();
     if (state == SelectionStart || state == SelectionEnd || state == SelectionBoth) {
         int startPos, endPos;
-        lineLayoutItem().selectionStartEnd(startPos, endPos);
+        getLineLayoutItem().selectionStartEnd(startPos, endPos);
         // The position after a hard line break is considered to be past its end.
         // See the corresponding code in InlineTextBox::isSelected.
         int lastSelectable = start() + len() - (isLineBreak() ? 1 : 0);
 
         // FIXME: Remove -webkit-line-break: LineBreakAfterWhiteSpace.
-        int endOfLineAdjustmentForCSSLineBreak = lineLayoutItem().style()->lineBreak() == LineBreakAfterWhiteSpace ? -1 : 0;
+        int endOfLineAdjustmentForCSSLineBreak = getLineLayoutItem().style()->lineBreak() == LineBreakAfterWhiteSpace ? -1 : 0;
         bool start = (state != SelectionEnd && startPos >= m_start && startPos <= m_start + m_len + endOfLineAdjustmentForCSSLineBreak);
         bool end = (state != SelectionStart && endPos > m_start && endPos <= lastSelectable);
         if (start && end)
             state = SelectionBoth;
         else if (start)
             state = SelectionStart;
         else if (end)
             state = SelectionEnd;
         else if ((state == SelectionEnd || startPos < m_start)
             && (state == SelectionStart || endPos > lastSelectable))
@@ skipping 22 matching lines @@
     return state;
 }
 
 bool InlineTextBox::hasWrappedSelectionNewline() const
 {
     // TODO(wkorman): We shouldn't need layout at this point and it should
     // be enforced by DocumentLifecycle. http://crbug.com/537821
     // Bail out as currently looking up selection state can cause the editing
     // code can force a re-layout while scrutinizing the editing position, and
     // InlineTextBox instances are not guaranteed to survive a re-layout.
-    if (lineLayoutItem().needsLayout())
+    if (getLineLayoutItem().needsLayout())
         return false;
 
-    SelectionState state = selectionState();
+    SelectionState state = getSelectionState();
     return (state == SelectionStart || state == SelectionInside)
         // Checking last leaf child can be slow, so we make sure to do this only
         // after the other simple conditionals.
         && (root().lastLeafChild() == this)
         // It's possible to have mixed LTR/RTL on a single line, and we only
         // want to paint a newline when we're the last leaf child and we make
         // sure there isn't a differently-directioned box following us.
         && ((!isLeftToRightDirection() && root().firstSelectedBox() == this)
             || (isLeftToRightDirection() && root().lastSelectedBox() == this));
 }
 
 float InlineTextBox::newlineSpaceWidth() const
 {
-    const ComputedStyle& styleToUse = lineLayoutItem().styleRef(isFirstLineStyle());
+    const ComputedStyle& styleToUse = getLineLayoutItem().styleRef(isFirstLineStyle());
     return styleToUse.font().spaceWidth();
 }
 
 LayoutRect InlineTextBox::localSelectionRect(int startPos, int endPos) const
 {
     int sPos = std::max(startPos - m_start, 0);
     int ePos = std::min(endPos - m_start, (int)m_len);
 
     if (sPos > ePos)
         return LayoutRect();
 
     FontCachePurgePreventer fontCachePurgePreventer;
 
     LayoutUnit selTop = root().selectionTop();
     LayoutUnit selHeight = root().selectionHeight();
-    const ComputedStyle& styleToUse = lineLayoutItem().styleRef(isFirstLineStyle());
+    const ComputedStyle& styleToUse = getLineLayoutItem().styleRef(isFirstLineStyle());
     const Font& font = styleToUse.font();
 
     StringBuilder charactersWithHyphen;
     bool respectHyphen = ePos == m_len && hasHyphen();
     TextRun textRun = constructTextRun(styleToUse, font, respectHyphen ? &charactersWithHyphen : 0);
 
     LayoutPoint startingPoint = LayoutPoint(logicalLeft(), selTop);
     LayoutRect r;
     if (sPos || ePos != static_cast<int>(m_len)) {
         r = LayoutRect(enclosingIntRect(font.selectionRectForText(textRun, FloatPoint(startingPoint), selHeight, sPos, ePos)));
@@ skipping 29 matching lines @@
         // bottom-to-top situations. Add tests and ensure we handle correctly.
         if (hasWrappedSelectionNewline())
             height += newlineSpaceWidth();
     }
 
     return LayoutRect(topPoint, LayoutSize(width, height));
 }
 
 void InlineTextBox::deleteLine()
 {
-    lineLayoutItem().removeTextBox(this);
+    getLineLayoutItem().removeTextBox(this);
     destroy();
 }
 
 void InlineTextBox::extractLine()
 {
     if (extracted())
         return;
 
-    lineLayoutItem().extractTextBox(this);
+    getLineLayoutItem().extractTextBox(this);
 }
 
 void InlineTextBox::attachLine()
 {
     if (!extracted())
         return;
 
-    lineLayoutItem().attachTextBox(this);
+    getLineLayoutItem().attachTextBox(this);
 }
 
 void InlineTextBox::setTruncation(unsigned truncation)
 {
     if (truncation == m_truncation)
         return;
 
     m_truncation = truncation;
     InlineTextBoxPainter::removeFromTextBlobCache(*this);
 }
@@ skipping 47 matching lines @@
             setTruncation(cFullTruncation);
             truncatedWidth += ellipsisWidth;
             return std::min(ellipsisX, logicalLeft());
         }
 
         // Set the truncation index on the text run.
         setTruncation(offset);
 
         // If we got here that means that we were only partially truncated and we need to return the pixel offset at which
         // to place the ellipsis.
-        LayoutUnit widthOfVisibleText(lineLayoutItem().width(m_start, offset, textPos(), flowIsLTR ? LTR : RTL, isFirstLineStyle()));
+        LayoutUnit widthOfVisibleText(getLineLayoutItem().width(m_start, offset, textPos(), flowIsLTR ? LTR : RTL, isFirstLineStyle()));
 
         // The ellipsis needs to be placed just after the last visible character.
         // Where "after" is defined by the flow directionality, not the inline
         // box directionality.
         // e.g. In the case of an LTR inline box truncated in an RTL flow then we can
         // have a situation such as |Hello| -> |...He|
         truncatedWidth += widthOfVisibleText + ellipsisWidth;
         if (flowIsLTR)
             return logicalLeft() + widthOfVisibleText;
         return logicalRight() - widthOfVisibleText - ellipsisWidth;
     }
     truncatedWidth += logicalWidth();
     return LayoutUnit(-1);
 }
 
 bool InlineTextBox::isLineBreak() const
 {
-    return lineLayoutItem().isBR() || (lineLayoutItem().style()->preserveNewline() && len() == 1 && (*lineLayoutItem().text().impl())[start()] == '\n');
+    return getLineLayoutItem().isBR() || (getLineLayoutItem().style()->preserveNewline() && len() == 1 && (*getLineLayoutItem().text().impl())[start()] == '\n');
 }
 
 bool InlineTextBox::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
 {
     if (isLineBreak() || m_truncation == cFullTruncation)
         return false;
 
     LayoutPoint boxOrigin = locationIncludingFlipping();
     boxOrigin.moveBy(accumulatedOffset);
     LayoutRect rect(boxOrigin, size());
     if (visibleToHitTestRequest(result.hitTestRequest()) && locationInContainer.intersects(rect)) {
-        lineLayoutItem().updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(accumulatedOffset)));
-        if (result.addNodeToListBasedTestResult(lineLayoutItem().node(), locationInContainer, rect) == StopHitTesting)
+        getLineLayoutItem().updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(accumulatedOffset)));
+        if (result.addNodeToListBasedTestResult(getLineLayoutItem().node(), locationInContainer, rect) == StopHitTesting)
             return true;
     }
     return false;
 }
 
 bool InlineTextBox::getEmphasisMarkPosition(const ComputedStyle& style, TextEmphasisPosition& emphasisPosition) const
 {
     // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
     if (style.textEmphasisMark() == TextEmphasisMarkNone)
         return false;
 
     emphasisPosition = style.textEmphasisPosition();
     if (emphasisPosition == TextEmphasisPositionUnder)
         return true; // Ruby text is always over, so it cannot suppress emphasis marks under.
 
-    LineLayoutBox containingBlock = lineLayoutItem().containingBlock();
+    LineLayoutBox containingBlock = getLineLayoutItem().containingBlock();
     if (!containingBlock.isRubyBase())
         return true; // This text is not inside a ruby base, so it does not have ruby text over it.
 
     if (!containingBlock.parent().isRubyRun())
         return true; // Cannot get the ruby text.
 
     LayoutRubyText* rubyText = LineLayoutRubyRun(containingBlock.parent()).rubyText();
 
     // The emphasis marks over are suppressed only if there is a ruby text box and it not empty.
     return !rubyText || !rubyText->firstLineBox();
 }
 
 void InlineTextBox::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /*lineTop*/, LayoutUnit /*lineBottom*/) const
 {
     InlineTextBoxPainter(*this).paint(paintInfo, paintOffset);
 }
 
 void InlineTextBox::selectionStartEnd(int& sPos, int& ePos) const
 {
     int startPos, endPos;
-    if (lineLayoutItem().selectionState() == SelectionInside) {
+    if (getLineLayoutItem().getSelectionState() == SelectionInside) {
         startPos = 0;
-        endPos = lineLayoutItem().textLength();
+        endPos = getLineLayoutItem().textLength();
     } else {
-        lineLayoutItem().selectionStartEnd(startPos, endPos);
-        if (lineLayoutItem().selectionState() == SelectionStart)
-            endPos = lineLayoutItem().textLength();
-        else if (lineLayoutItem().selectionState() == SelectionEnd)
+        getLineLayoutItem().selectionStartEnd(startPos, endPos);
+        if (getLineLayoutItem().getSelectionState() == SelectionStart)
+            endPos = getLineLayoutItem().textLength();
+        else if (getLineLayoutItem().getSelectionState() == SelectionEnd)
             startPos = 0;
     }
 
     sPos = std::max(startPos - m_start, 0);
     ePos = std::min(endPos - m_start, (int)m_len);
 }
 
 void InlineTextBox::paintDocumentMarker(GraphicsContext& pt, const LayoutPoint& boxOrigin, DocumentMarker* marker, const ComputedStyle& style, const Font& font, bool grammar) const
 {
     InlineTextBoxPainter(*this).paintDocumentMarker(pt, boxOrigin, marker, style, font, grammar);
@@ skipping 31 matching lines @@
 int InlineTextBox::offsetForPosition(LayoutUnit lineOffset, bool includePartialGlyphs) const
 {
     if (isLineBreak())
         return 0;
 
     if (lineOffset - logicalLeft() > logicalWidth())
         return isLeftToRightDirection() ? len() : 0;
     if (lineOffset - logicalLeft() < 0)
         return isLeftToRightDirection() ? 0 : len();
 
-    LineLayoutText text = lineLayoutItem();
+    LineLayoutText text = getLineLayoutItem();
     const ComputedStyle& style = text.styleRef(isFirstLineStyle());
     const Font& font = style.font();
     return font.offsetForPosition(constructTextRun(style, font), (lineOffset - logicalLeft()).toFloat(), includePartialGlyphs);
 }
 
 LayoutUnit InlineTextBox::positionForOffset(int offset) const
 {
     ASSERT(offset >= m_start);
     ASSERT(offset <= m_start + m_len);
 
     if (isLineBreak())
         return logicalLeft();
 
-    LineLayoutText text = lineLayoutItem();
+    LineLayoutText text = getLineLayoutItem();
     const ComputedStyle& styleToUse = text.styleRef(isFirstLineStyle());
     const Font& font = styleToUse.font();
     int from = !isLeftToRightDirection() ? offset - m_start : 0;
     int to = !isLeftToRightDirection() ? m_len : offset - m_start;
     // FIXME: Do we need to add rightBearing here?
     return LayoutUnit(font.selectionRectForText(constructTextRun(styleToUse, font), IntPoint(logicalLeft(), 0), 0, from, to).maxX());
 }
 
 bool InlineTextBox::containsCaretOffset(int offset) const
 {
@@ skipping 18 matching lines @@
     // Offsets at the end are "in" for normal boxes (but the caller has to check affinity).
     return true;
 }
 
 void InlineTextBox::characterWidths(Vector<float>& widths) const
 {
     if (!m_len)
         return;
 
     FontCachePurgePreventer fontCachePurgePreventer;
-    ASSERT(lineLayoutItem().text());
+    ASSERT(getLineLayoutItem().text());
 
-    const ComputedStyle& styleToUse = lineLayoutItem().styleRef(isFirstLineStyle());
+    const ComputedStyle& styleToUse = getLineLayoutItem().styleRef(isFirstLineStyle());
     const Font& font = styleToUse.font();
 
     float lastWidth = 0;
     widths.resize(m_len);
     for (unsigned i = 0; i < m_len; i++) {
-        StringView substringView = lineLayoutItem().text().createView();
+        StringView substringView = getLineLayoutItem().text().createView();
         substringView.narrow(start(), 1 + i);
         TextRun textRun = constructTextRun(styleToUse, font, substringView, m_len);
         widths[i] = font.width(textRun, nullptr, nullptr) - lastWidth;
         lastWidth = font.width(textRun, nullptr, nullptr);
     }
 }
 
 TextRun InlineTextBox::constructTextRun(const ComputedStyle& style, const Font& font, StringBuilder* charactersWithHyphen) const
 {
-    ASSERT(lineLayoutItem().text());
+    ASSERT(getLineLayoutItem().text());
 
-    StringView string = lineLayoutItem().text().createView();
+    StringView string = getLineLayoutItem().text().createView();
     unsigned startPos = start();
     unsigned length = len();
 
     if (string.length() != length || startPos)
         string.narrow(startPos, length);
 
-    return constructTextRun(style, font, string, lineLayoutItem().textLength() - startPos, charactersWithHyphen);
+    return constructTextRun(style, font, string, getLineLayoutItem().textLength() - startPos, charactersWithHyphen);
 }
 
 TextRun InlineTextBox::constructTextRun(const ComputedStyle& style, const Font& font, StringView string, int maximumLength, StringBuilder* charactersWithHyphen) const
 {
     if (charactersWithHyphen) {
         const AtomicString& hyphenString = style.hyphenString();
         charactersWithHyphen->reserveCapacity(string.length() + hyphenString.length());
         charactersWithHyphen->append(string);
         charactersWithHyphen->append(hyphenString);
         string = charactersWithHyphen->toString().createView();
@@ skipping 22 matching lines @@
     return "InlineTextBox";
 }
 
 String InlineTextBox::debugName() const
 {
     return String(boxName()) + " '" + text() + "'";
 }
 
 String InlineTextBox::text() const
 {
-    return lineLayoutItem().text().substring(start(), len());
+    return getLineLayoutItem().text().substring(start(), len());
 }
 
 #ifndef NDEBUG
 
 void InlineTextBox::showBox(int printedCharacters) const
 {
     String value = text();
     value.replaceWithLiteral('\\', "\\\\");
     value.replaceWithLiteral('\n', "\\n");
     printedCharacters += fprintf(stderr, "%s %p", boxName(), this);
     for (; printedCharacters < showTreeCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
-    const LineLayoutText obj = lineLayoutItem();
+    const LineLayoutText obj = getLineLayoutItem();
     printedCharacters = fprintf(stderr, "\t%s %p", obj.name(), obj.debugPointer());
     const int layoutObjectCharacterOffset = 75;
     for (; printedCharacters < layoutObjectCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace blink