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

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

 /*
  * Copyright (C) 2003, 2006, 2008 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 142 matching lines @@
 
 void RootInlineBox::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom) const
 {
     RootInlineBoxPainter(*this).paint(paintInfo, paintOffset, lineTop, lineBottom);
 }
 
 bool RootInlineBox::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
 {
     if (hasEllipsisBox() && visibleToHitTestRequest(result.hitTestRequest())) {
         if (ellipsisBox()->nodeAtPoint(result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {
-            lineLayoutItem().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
+            getLineLayoutItem().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
             return true;
         }
     }
     return InlineFlowBox::nodeAtPoint(result, locationInContainer, accumulatedOffset, lineTop, lineBottom);
 }
 
 void RootInlineBox::move(const LayoutSize& delta)
 {
     InlineFlowBox::move(delta);
     LayoutUnit blockDirectionDelta = isHorizontal() ? delta.height() : delta.width();
     m_lineTop += blockDirectionDelta;
     m_lineBottom += blockDirectionDelta;
     m_lineTopWithLeading += blockDirectionDelta;
     m_lineBottomWithLeading += blockDirectionDelta;
     m_selectionBottom += blockDirectionDelta;
     if (hasEllipsisBox())
         ellipsisBox()->move(delta);
 }
 
 void RootInlineBox::childRemoved(InlineBox* box)
 {
-    if (box->lineLayoutItem() == m_lineBreakObj)
+    if (box->getLineLayoutItem() == m_lineBreakObj)
         setLineBreakInfo(0, 0, BidiStatus());
 
-    for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == box->lineLayoutItem(); prev = prev->prevRootBox()) {
+    for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == box->getLineLayoutItem(); prev = prev->prevRootBox()) {
         prev->setLineBreakInfo(0, 0, BidiStatus());
         prev->markDirty();
     }
 }
 
 static inline void snapHeight(int& maxAscent, int& maxDescent, const ComputedStyle& style)
 {
     // If position is 0, add spaces to over/under equally.
     // https://drafts.csswg.org/css-snap-size/#snap-height
     int unit = style.snapHeightUnit();
@@ skipping 26 matching lines @@
         return LayoutUnit();
 
     LayoutUnit maxPositionTop;
     LayoutUnit maxPositionBottom;
     int maxAscent = 0;
     int maxDescent = 0;
     bool setMaxAscent = false;
     bool setMaxDescent = false;
 
     // Figure out if we're in no-quirks mode.
-    bool noQuirksMode = lineLayoutItem().document().inNoQuirksMode();
+    bool noQuirksMode = getLineLayoutItem().document().inNoQuirksMode();
 
     m_baselineType = dominantBaseline();
 
     computeLogicalBoxHeights(this, maxPositionTop, maxPositionBottom, maxAscent, maxDescent, setMaxAscent, setMaxDescent, noQuirksMode, textBoxDataMap, baselineType(), verticalPositionCache);
 
     if (maxAscent + maxDescent < std::max(maxPositionTop, maxPositionBottom))
         adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
 
-    if (lineLayoutItem().styleRef().snapHeightUnit())
-        snapHeight(maxAscent, maxDescent, lineLayoutItem().styleRef());
+    if (getLineLayoutItem().styleRef().snapHeightUnit())
+        snapHeight(maxAscent, maxDescent, getLineLayoutItem().styleRef());
 
     LayoutUnit maxHeight = LayoutUnit(maxAscent + maxDescent);
     LayoutUnit lineTop = heightOfBlock;
     LayoutUnit lineBottom = heightOfBlock;
     LayoutUnit lineTopIncludingMargins = heightOfBlock;
     LayoutUnit lineBottomIncludingMargins = heightOfBlock;
     LayoutUnit selectionBottom = heightOfBlock;
     bool setLineTop = false;
     bool hasAnnotationsBefore = false;
     bool hasAnnotationsAfter = false;
@@ skipping 20 matching lines @@
 {
     LayoutUnit maxLogicalTop;
     computeMaxLogicalTop(maxLogicalTop);
     return maxLogicalTop;
 }
 
 LayoutUnit RootInlineBox::beforeAnnotationsAdjustment() const
 {
     LayoutUnit result;
 
-    if (!lineLayoutItem().style()->isFlippedLinesWritingMode()) {
+    if (!getLineLayoutItem().style()->isFlippedLinesWritingMode()) {
         // Annotations under the previous line may push us down.
         if (prevRootBox() && prevRootBox()->hasAnnotationsAfter())
             result = prevRootBox()->computeUnderAnnotationAdjustment(lineTop());
 
         if (!hasAnnotationsBefore())
             return result;
 
         // Annotations over this line may push us further down.
         LayoutUnit highestAllowedPosition = prevRootBox() ? std::min(prevRootBox()->lineBottom(), lineTop()) + result : static_cast<LayoutUnit>(block().borderBefore());
         result = computeOverAnnotationAdjustment(highestAllowedPosition);
     } else {
         // Annotations under this line may push us up.
         if (hasAnnotationsBefore())
             result = computeUnderAnnotationAdjustment(prevRootBox() ? prevRootBox()->lineBottom() : static_cast<LayoutUnit>(block().borderBefore()));
 
         if (!prevRootBox() || !prevRootBox()->hasAnnotationsAfter())
             return result;
 
         // We have to compute the expansion for annotations over the previous line to see how much we should move.
         LayoutUnit lowestAllowedPosition = std::max(prevRootBox()->lineBottom(), lineTop()) - result;
         result = prevRootBox()->computeOverAnnotationAdjustment(lowestAllowedPosition);
     }
 
     return result;
 }
 
-SelectionState RootInlineBox::selectionState() const
+SelectionState RootInlineBox::getSelectionState() const
 {
     // Walk over all of the selected boxes.
     SelectionState state = SelectionNone;
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
-        SelectionState boxState = box->selectionState();
+        SelectionState boxState = box->getSelectionState();
         if ((boxState == SelectionStart && state == SelectionEnd)
             || (boxState == SelectionEnd && state == SelectionStart)) {
             state = SelectionBoth;
         } else if (state == SelectionNone || ((boxState == SelectionStart || boxState == SelectionEnd) && (state == SelectionNone || state == SelectionInside))) {
             state = boxState;
         } else if (boxState == SelectionNone && state == SelectionStart) {
             // We are past the end of the selection.
             state = SelectionBoth;
         }
         if (state == SelectionBoth)
             break;
     }
 
     return state;
 }
 
 InlineBox* RootInlineBox::firstSelectedBox() const
 {
     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
-        if (box->selectionState() != SelectionNone)
+        if (box->getSelectionState() != SelectionNone)
             return box;
     }
 
     return nullptr;
 }
 
 InlineBox* RootInlineBox::lastSelectedBox() const
 {
     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
-        if (box->selectionState() != SelectionNone)
+        if (box->getSelectionState() != SelectionNone)
             return box;
     }
 
     return nullptr;
 }
 
 LayoutUnit RootInlineBox::selectionTop() const
 {
     LayoutUnit selectionTop = m_lineTop;
 
     if (m_hasAnnotationsBefore)
-        selectionTop -= !lineLayoutItem().style()->isFlippedLinesWritingMode() ? computeOverAnnotationAdjustment(m_lineTop) : computeUnderAnnotationAdjustment(m_lineTop);
+        selectionTop -= !getLineLayoutItem().style()->isFlippedLinesWritingMode() ? computeOverAnnotationAdjustment(m_lineTop) : computeUnderAnnotationAdjustment(m_lineTop);
 
-    if (lineLayoutItem().style()->isFlippedLinesWritingMode() || !prevRootBox())
+    if (getLineLayoutItem().style()->isFlippedLinesWritingMode() || !prevRootBox())
         return selectionTop;
 
     LayoutUnit prevBottom = prevRootBox()->selectionBottom();
     if (prevBottom < selectionTop && block().containsFloats()) {
         // This line has actually been moved further down, probably from a large line-height, but possibly because the
         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the previous
         // line's bottom if the offsets are greater on both sides.
         LayoutUnit prevLeft = block().logicalLeftOffsetForLine(prevBottom, DoNotIndentText);
         LayoutUnit prevRight = block().logicalRightOffsetForLine(prevBottom, DoNotIndentText);
         LayoutUnit newLeft = block().logicalLeftOffsetForLine(selectionTop, DoNotIndentText);
         LayoutUnit newRight = block().logicalRightOffsetForLine(selectionTop, DoNotIndentText);
         if (prevLeft > newLeft || prevRight < newRight)
             return selectionTop;
     }
 
     return prevBottom;
 }
 
 LayoutUnit RootInlineBox::selectionBottom() const
 {
-    LayoutUnit selectionBottom = lineLayoutItem().document().inNoQuirksMode() ? m_selectionBottom : m_lineBottom;
+    LayoutUnit selectionBottom = getLineLayoutItem().document().inNoQuirksMode() ? m_selectionBottom : m_lineBottom;
 
     if (m_hasAnnotationsAfter)
-        selectionBottom += !lineLayoutItem().style()->isFlippedLinesWritingMode() ? computeUnderAnnotationAdjustment(m_lineBottom) : computeOverAnnotationAdjustment(m_lineBottom);
+        selectionBottom += !getLineLayoutItem().style()->isFlippedLinesWritingMode() ? computeUnderAnnotationAdjustment(m_lineBottom) : computeOverAnnotationAdjustment(m_lineBottom);
 
-    if (!lineLayoutItem().style()->isFlippedLinesWritingMode() || !nextRootBox())
+    if (!getLineLayoutItem().style()->isFlippedLinesWritingMode() || !nextRootBox())
         return selectionBottom;
 
     LayoutUnit nextTop = nextRootBox()->selectionTop();
     if (nextTop > selectionBottom && block().containsFloats()) {
         // The next line has actually been moved further over, probably from a large line-height, but possibly because the
         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the next
         // line's top if the offsets are greater on both sides.
         LayoutUnit nextLeft = block().logicalLeftOffsetForLine(nextTop, DoNotIndentText);
         LayoutUnit nextRight = block().logicalRightOffsetForLine(nextTop, DoNotIndentText);
         LayoutUnit newLeft = block().logicalLeftOffsetForLine(selectionBottom, DoNotIndentText);
         LayoutUnit newRight = block().logicalRightOffsetForLine(selectionBottom, DoNotIndentText);
         if (nextLeft > newLeft || nextRight < newRight)
             return selectionBottom;
     }
 
     return nextTop;
 }
 
 LayoutUnit RootInlineBox::blockDirectionPointInLine() const
 {
     return !block().style()->isFlippedBlocksWritingMode() ? std::max(lineTop(), selectionTop()) : std::min(lineBottom(), selectionBottom());
 }
 
 LineLayoutBlockFlow RootInlineBox::block() const
 {
-    return LineLayoutBlockFlow(lineLayoutItem());
+    return LineLayoutBlockFlow(getLineLayoutItem());
 }
 
 static bool isEditableLeaf(InlineBox* leaf)
 {
-    return leaf && leaf->lineLayoutItem().node() && leaf->lineLayoutItem().node()->hasEditableStyle();
+    return leaf && leaf->getLineLayoutItem().node() && leaf->getLineLayoutItem().node()->hasEditableStyle();
 }
 
 InlineBox* RootInlineBox::closestLeafChildForPoint(const LayoutPoint& pointInContents, bool onlyEditableLeaves)
 {
     return closestLeafChildForLogicalLeftPosition(block().isHorizontalWritingMode() ? pointInContents.x() : pointInContents.y(), onlyEditableLeaves);
 }
 
 InlineBox* RootInlineBox::closestLeafChildForLogicalLeftPosition(LayoutUnit leftPosition, bool onlyEditableLeaves)
 {
     InlineBox* firstLeaf = firstLeafChild();
     InlineBox* lastLeaf = lastLeafChild();
 
     if (firstLeaf != lastLeaf) {
         if (firstLeaf->isLineBreak())
             firstLeaf = firstLeaf->nextLeafChildIgnoringLineBreak();
         else if (lastLeaf->isLineBreak())
             lastLeaf = lastLeaf->prevLeafChildIgnoringLineBreak();
     }
 
     if (firstLeaf == lastLeaf && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
         return firstLeaf;
 
     // Avoid returning a list marker when possible.
-    if (leftPosition <= firstLeaf->logicalLeft() && !firstLeaf->lineLayoutItem().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(firstLeaf))) {
+    if (leftPosition <= firstLeaf->logicalLeft() && !firstLeaf->getLineLayoutItem().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(firstLeaf))) {
         // The leftPosition coordinate is less or equal to left edge of the firstLeaf.
         // Return it.
         return firstLeaf;
     }
 
-    if (leftPosition >= lastLeaf->logicalRight() && !lastLeaf->lineLayoutItem().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf))) {
+    if (leftPosition >= lastLeaf->logicalRight() && !lastLeaf->getLineLayoutItem().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf))) {
         // The leftPosition coordinate is greater or equal to right edge of the lastLeaf.
         // Return it.
         return lastLeaf;
     }
 
     InlineBox* closestLeaf = nullptr;
     for (InlineBox* leaf = firstLeaf; leaf; leaf = leaf->nextLeafChildIgnoringLineBreak()) {
-        if (!leaf->lineLayoutItem().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
+        if (!leaf->getLineLayoutItem().isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
             closestLeaf = leaf;
             if (leftPosition < leaf->logicalRight()) {
                 // The x coordinate is less than the right edge of the box.
                 // Return it.
                 return leaf;
             }
         }
     }
 
     return closestLeaf ? closestLeaf : lastLeaf;
@@ skipping 76 matching lines @@
     } else {
         ascent = std::max(ascent, newAscent);
         descent = std::max(descent, newDescent);
     }
 }
 
 void RootInlineBox::ascentAndDescentForBox(InlineBox* box, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, int& ascent, int& descent, bool& affectsAscent, bool& affectsDescent) const
 {
     bool ascentDescentSet = false;
 
-    if (box->lineLayoutItem().isAtomicInlineLevel()) {
+    if (box->getLineLayoutItem().isAtomicInlineLevel()) {
         ascent = box->baselinePosition(baselineType());
         descent = roundToInt(box->lineHeight() - ascent);
 
         // Replaced elements always affect both the ascent and descent.
         affectsAscent = true;
         affectsDescent = true;
         return;
     }
 
     Vector<const SimpleFontData*>* usedFonts = nullptr;
     if (box->isText()) {
         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(toInlineTextBox(box));
         usedFonts = it == textBoxDataMap.end() ? 0 : &it->value.first;
     }
 
     bool includeLeading = includeLeadingForBox(box);
     bool setUsedFontWithLeading = false;
 
-    if (usedFonts && !usedFonts->isEmpty() && (box->lineLayoutItem().style(isFirstLineStyle())->lineHeight().isNegative() && includeLeading)) {
-        usedFonts->append(box->lineLayoutItem().style(isFirstLineStyle())->font().primaryFont());
+    if (usedFonts && !usedFonts->isEmpty() && (box->getLineLayoutItem().style(isFirstLineStyle())->lineHeight().isNegative() && includeLeading)) {
+        usedFonts->append(box->getLineLayoutItem().style(isFirstLineStyle())->font().primaryFont());
         for (size_t i = 0; i < usedFonts->size(); ++i) {
             const FontMetrics& fontMetrics = usedFonts->at(i)->fontMetrics();
             int usedFontAscent = fontMetrics.ascent(baselineType());
             int usedFontDescent = fontMetrics.descent(baselineType());
             int halfLeading = (fontMetrics.lineSpacing() - fontMetrics.height()) / 2;
             int usedFontAscentAndLeading = usedFontAscent + halfLeading;
             int usedFontDescentAndLeading = fontMetrics.lineSpacing() - usedFontAscentAndLeading;
             if (includeLeading) {
                 setAscentAndDescent(ascent, descent, usedFontAscentAndLeading, usedFontDescentAndLeading, ascentDescentSet);
                 setUsedFontWithLeading = true;
@@ skipping 15 matching lines @@
         // If the top of our font box relative to the root box baseline is above the root box baseline, then
         // we are contributing to the maxAscent value. Descent is similar. If any part of our font box is below
         // the root box's baseline, then we contribute to the maxDescent value.
         affectsAscent = ascentWithLeading - box->logicalTop() > 0;
         affectsDescent = descentWithLeading + box->logicalTop() > 0;
     }
 }
 
 LayoutUnit RootInlineBox::verticalPositionForBox(InlineBox* box, VerticalPositionCache& verticalPositionCache)
 {
-    if (box->lineLayoutItem().isText())
+    if (box->getLineLayoutItem().isText())
         return box->parent()->logicalTop();
 
     LineLayoutBoxModel boxModel = box->boxModelObject();
     ASSERT(boxModel.isInline());
     if (!boxModel.isInline())
         return LayoutUnit();
 
     // This method determines the vertical position for inline elements.
     bool firstLine = isFirstLineStyle();
     if (firstLine && !boxModel.document().styleEngine().usesFirstLineRules())
@@ skipping 53 matching lines @@
 
     // Store the cached value.
     if (isLayoutInline && !firstLine)
         verticalPositionCache.set(boxModel, baselineType(), verticalPosition);
 
     return verticalPosition;
 }
 
 bool RootInlineBox::includeLeadingForBox(InlineBox* box) const
 {
-    return !(box->lineLayoutItem().isAtomicInlineLevel() || (box->lineLayoutItem().isText() && !box->isText()));
+    return !(box->getLineLayoutItem().isAtomicInlineLevel() || (box->getLineLayoutItem().isText() && !box->isText()));
 }
 
 Node* RootInlineBox::getLogicalStartBoxWithNode(InlineBox*& startBox) const
 {
     Vector<InlineBox*> leafBoxesInLogicalOrder;
     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
     for (size_t i = 0; i < leafBoxesInLogicalOrder.size(); ++i) {
-        if (leafBoxesInLogicalOrder[i]->lineLayoutItem().nonPseudoNode()) {
+        if (leafBoxesInLogicalOrder[i]->getLineLayoutItem().nonPseudoNode()) {
             startBox = leafBoxesInLogicalOrder[i];
-            return startBox->lineLayoutItem().nonPseudoNode();
+            return startBox->getLineLayoutItem().nonPseudoNode();
         }
     }
     startBox = nullptr;
     return nullptr;
 }
 
 Node* RootInlineBox::getLogicalEndBoxWithNode(InlineBox*& endBox) const
 {
     Vector<InlineBox*> leafBoxesInLogicalOrder;
     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
     for (size_t i = leafBoxesInLogicalOrder.size(); i > 0; --i) {
-        if (leafBoxesInLogicalOrder[i - 1]->lineLayoutItem().nonPseudoNode()) {
+        if (leafBoxesInLogicalOrder[i - 1]->getLineLayoutItem().nonPseudoNode()) {
             endBox = leafBoxesInLogicalOrder[i - 1];
-            return endBox->lineLayoutItem().nonPseudoNode();
+            return endBox->getLineLayoutItem().nonPseudoNode();
         }
     }
     endBox = nullptr;
     return nullptr;
 }
 
 const char* RootInlineBox::boxName() const
 {
     return "RootInlineBox";
 }
 
 } // namespace blink