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

third_party/WebKit/Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 506 matching lines @@
     case AlwaysDownstream:
         affinity = TextAffinity::Downstream;
         break;
     case AlwaysUpstream:
         affinity = VP_UPSTREAM_IF_POSSIBLE;
         break;
     case UpstreamIfPositionIsNotAtStart:
         affinity = offset > box->caretMinOffset() ? VP_UPSTREAM_IF_POSSIBLE : TextAffinity::Downstream;
         break;
     }
-    int textStartOffset = box->lineLayoutItem().isText() ? LineLayoutText(box->lineLayoutItem()).textStartOffset() : 0;
-    return box->lineLayoutItem().createPositionWithAffinity(offset + textStartOffset, affinity);
+    int textStartOffset = box->getLineLayoutItem().isText() ? LineLayoutText(box->getLineLayoutItem()).textStartOffset() : 0;
+    return box->getLineLayoutItem().createPositionWithAffinity(offset + textStartOffset, affinity);
 }
 
 static PositionWithAffinity createPositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(const InlineTextBox* box, int offset, ShouldAffinityBeDownstream shouldAffinityBeDownstream)
 {
     ASSERT(box);
     ASSERT(offset >= 0);
 
     if (offset && static_cast<unsigned>(offset) < box->len())
         return createPositionWithAffinityForBox(box, box->start() + offset, shouldAffinityBeDownstream);
 
     bool positionIsAtStartOfBox = !offset;
     if (positionIsAtStartOfBox == box->isLeftToRightDirection()) {
         // offset is on the left edge
 
         const InlineBox* prevBox = box->prevLeafChildIgnoringLineBreak();
         if ((prevBox && prevBox->bidiLevel() == box->bidiLevel())
-            || box->lineLayoutItem().containingBlock().style()->direction() == box->direction()) // FIXME: left on 12CBA
+            || box->getLineLayoutItem().containingBlock().style()->direction() == box->direction()) // FIXME: left on 12CBA
             return createPositionWithAffinityForBox(box, box->caretLeftmostOffset(), shouldAffinityBeDownstream);
 
         if (prevBox && prevBox->bidiLevel() > box->bidiLevel()) {
             // e.g. left of B in aDC12BAb
             const InlineBox* leftmostBox;
             do {
                 leftmostBox = prevBox;
                 prevBox = leftmostBox->prevLeafChildIgnoringLineBreak();
             } while (prevBox && prevBox->bidiLevel() > box->bidiLevel());
             return createPositionWithAffinityForBox(leftmostBox, leftmostBox->caretRightmostOffset(), shouldAffinityBeDownstream);
         }
 
         if (!prevBox || prevBox->bidiLevel() < box->bidiLevel()) {
             // e.g. left of D in aDC12BAb
             const InlineBox* rightmostBox;
             const InlineBox* nextBox = box;
             do {
                 rightmostBox = nextBox;
                 nextBox = rightmostBox->nextLeafChildIgnoringLineBreak();
             } while (nextBox && nextBox->bidiLevel() >= box->bidiLevel());
             return createPositionWithAffinityForBox(rightmostBox,
                 box->isLeftToRightDirection() ? rightmostBox->caretMaxOffset() : rightmostBox->caretMinOffset(), shouldAffinityBeDownstream);
         }
 
         return createPositionWithAffinityForBox(box, box->caretRightmostOffset(), shouldAffinityBeDownstream);
     }
 
     const InlineBox* nextBox = box->nextLeafChildIgnoringLineBreak();
     if ((nextBox && nextBox->bidiLevel() == box->bidiLevel())
-        || box->lineLayoutItem().containingBlock().style()->direction() == box->direction())
+        || box->getLineLayoutItem().containingBlock().style()->direction() == box->direction())
         return createPositionWithAffinityForBox(box, box->caretRightmostOffset(), shouldAffinityBeDownstream);
 
     // offset is on the right edge
     if (nextBox && nextBox->bidiLevel() > box->bidiLevel()) {
         // e.g. right of C in aDC12BAb
         const InlineBox* rightmostBox;
         do {
             rightmostBox = nextBox;
             nextBox = rightmostBox->nextLeafChildIgnoringLineBreak();
         } while (nextBox && nextBox->bidiLevel() > box->bidiLevel());
@@ skipping 592 matching lines @@
 }
 
 void LayoutText::setSelectionState(SelectionState state)
 {
     LayoutObject::setSelectionState(state);
 
     if (canUpdateSelectionOnRootLineBoxes()) {
         if (state == SelectionStart || state == SelectionEnd || state == SelectionBoth) {
             int startPos, endPos;
             selectionStartEnd(startPos, endPos);
-            if (selectionState() == SelectionStart) {
+            if (getSelectionState() == SelectionStart) {
                 endPos = textLength();
 
                 // to handle selection from end of text to end of line
                 if (startPos && startPos == endPos)
                     startPos = endPos - 1;
-            } else if (selectionState() == SelectionEnd) {
+            } else if (getSelectionState() == SelectionEnd) {
                 startPos = 0;
             }
 
             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
                 if (box->isSelected(startPos, endPos)) {
                     box->root().setHasSelectedChildren(true);
                 }
             }
         } else {
             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
@@ skipping 375 matching lines @@
 
     LayoutRect paintInvalidationRect(visualOverflowRect());
     mapToVisibleRectInAncestorSpace(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
     return paintInvalidationRect;
 }
 
 LayoutRect LayoutText::selectionRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer) const
 {
     ASSERT(!needsLayout());
 
-    if (selectionState() == SelectionNone)
+    if (getSelectionState() == SelectionNone)
         return LayoutRect();
     LayoutBlock* cb = containingBlock();
     if (!cb)
         return LayoutRect();
 
     // Now calculate startPos and endPos for painting selection.
     // We include a selection while endPos > 0
     int startPos, endPos;
-    if (selectionState() == SelectionInside) {
+    if (getSelectionState() == SelectionInside) {
         // We are fully selected.
         startPos = 0;
         endPos = textLength();
     } else {
         selectionStartEnd(startPos, endPos);
-        if (selectionState() == SelectionStart)
+        if (getSelectionState() == SelectionStart)
             endPos = textLength();
-        else if (selectionState() == SelectionEnd)
+        else if (getSelectionState() == SelectionEnd)
             startPos = 0;
     }
 
     LayoutRect rect;
 
     if (startPos == endPos)
         return rect;
 
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         rect.unite(box->localSelectionRect(startPos, endPos));
@@ skipping 91 matching lines @@
     return Character::characterRangeCodePath(characters16(), length()) == SimplePath;
 }
 
 #if ENABLE(ASSERT)
 
 void LayoutText::checkConsistency() const
 {
 #ifdef CHECK_CONSISTENCY
     const InlineTextBox* prev = nullptr;
     for (const InlineTextBox* child = m_firstTextBox; child; child = child->nextTextBox()) {
-        ASSERT(child->lineLayoutItem().isEqual(this));
+        ASSERT(child->getLineLayoutItem().isEqual(this));
         ASSERT(child->prevTextBox() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastTextBox);
 #endif
 }
 
 #endif
 
 void LayoutText::momentarilyRevealLastTypedCharacter(unsigned lastTypedCharacterOffset)
@@ skipping 21 matching lines @@
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box, invalidationReason);
         if (box->truncation() != cNoTruncation) {
             if (EllipsisBox* ellipsisBox = box->root().ellipsisBox())
                 paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*ellipsisBox, invalidationReason);
         }
     }
 }
 
 } // namespace blink