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

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 386 matching lines @@
 
     const InlineTextBox* previousBox = leafBoxes.previousTextBox(&startBox->root(), textBox);
     if (previousBox)
         return previousBox;
 
     previousBox = leafBoxes.previousTextBox(startBox->root().prevRootBox(), 0);
     if (previousBox)
         return previousBox;
 
     while (1) {
-        Node* startNode = startBox->lineLayoutItem().nonPseudoNode();
+        Node* startNode = startBox->getLineLayoutItem().nonPseudoNode();
         if (!startNode)
             break;
 
         Position position = previousRootInlineBoxCandidatePosition(startNode, visiblePosition, ContentIsEditable);
         if (position.isNull())
             break;
 
         RenderedPosition renderedPosition(position, TextAffinity::Downstream);
         RootInlineBox* previousRoot = renderedPosition.rootBox();
         if (!previousRoot)
@@ skipping 20 matching lines @@
 
     const InlineTextBox* nextBox = leafBoxes.nextTextBox(&startBox->root(), textBox);
     if (nextBox)
         return nextBox;
 
     nextBox = leafBoxes.nextTextBox(startBox->root().nextRootBox(), 0);
     if (nextBox)
         return nextBox;
 
     while (1) {
-        Node* startNode =startBox->lineLayoutItem().nonPseudoNode();
+        Node* startNode =startBox->getLineLayoutItem().nonPseudoNode();
         if (!startNode)
             break;
 
         Position position = nextRootInlineBoxCandidatePosition(startNode, visiblePosition, ContentIsEditable);
         if (position.isNull())
             break;
 
         RenderedPosition renderedPosition(position, TextAffinity::Downstream);
         RootInlineBox* nextRoot = renderedPosition.rootBox();
         if (!nextRoot)
@@ skipping 17 matching lines @@
 {
     previousBoxInDifferentBlock = false;
 
     // FIXME: Handle the case when we don't have an inline text box.
     const InlineTextBox* previousBox = logicallyPreviousBox(visiblePosition, textBox, previousBoxInDifferentBlock, leafBoxes);
 
     int len = 0;
     string.clear();
     if (previousBox) {
         previousBoxLength = previousBox->len();
-        previousBox->lineLayoutItem().text().appendTo(string, previousBox->start(), previousBoxLength);
+        previousBox->getLineLayoutItem().text().appendTo(string, previousBox->start(), previousBoxLength);
         len += previousBoxLength;
     }
-    textBox->lineLayoutItem().text().appendTo(string, textBox->start(), textBox->len());
+    textBox->getLineLayoutItem().text().appendTo(string, textBox->start(), textBox->len());
     len += textBox->len();
 
     return wordBreakIterator(string.data(), len);
 }
 
 static TextBreakIterator* wordBreakIteratorForMaxOffsetBoundary(const VisiblePosition& visiblePosition, const InlineTextBox* textBox,
     bool& nextBoxInDifferentBlock, Vector<UChar, 1024>& string, CachedLogicallyOrderedLeafBoxes& leafBoxes)
 {
     nextBoxInDifferentBlock = false;
 
     // FIXME: Handle the case when we don't have an inline text box.
     const InlineTextBox* nextBox = logicallyNextBox(visiblePosition, textBox, nextBoxInDifferentBlock, leafBoxes);
 
     int len = 0;
     string.clear();
-    textBox->lineLayoutItem().text().appendTo(string, textBox->start(), textBox->len());
+    textBox->getLineLayoutItem().text().appendTo(string, textBox->start(), textBox->len());
     len += textBox->len();
     if (nextBox) {
-        nextBox->lineLayoutItem().text().appendTo(string, nextBox->start(), nextBox->len());
+        nextBox->getLineLayoutItem().text().appendTo(string, nextBox->start(), nextBox->len());
         len += nextBox->len();
     }
 
     return wordBreakIterator(string.data(), len);
 }
 
 static bool isLogicalStartOfWord(TextBreakIterator* iter, int position, bool hardLineBreak)
 {
     bool boundary = hardLineBreak ? true : iter->isBoundary(position);
     if (!boundary)
@@ skipping 46 matching lines @@
         int previousBoxLength = 0;
         bool previousBoxInDifferentBlock = false;
         bool nextBoxInDifferentBlock = false;
         bool movingIntoNewBox = previouslyVisitedBox != box;
 
         if (offsetInBox == box->caretMinOffset()) {
             iter = wordBreakIteratorForMinOffsetBoundary(visiblePosition, textBox, previousBoxLength, previousBoxInDifferentBlock, string, leafBoxes);
         } else if (offsetInBox == box->caretMaxOffset()) {
             iter = wordBreakIteratorForMaxOffsetBoundary(visiblePosition, textBox, nextBoxInDifferentBlock, string, leafBoxes);
         } else if (movingIntoNewBox) {
-            iter = wordBreakIterator(textBox->lineLayoutItem().text(), textBox->start(), textBox->len());
+            iter = wordBreakIterator(textBox->getLineLayoutItem().text(), textBox->start(), textBox->len());
             previouslyVisitedBox = box;
         }
 
         if (!iter)
             break;
 
         iter->first();
         int offsetInIterator = offsetInBox - textBox->start() + previousBoxLength;
 
         bool isWordBreak;
@@ skipping 403 matching lines @@
         if (!startNode)
             return PositionWithAffinityTemplate<Strategy>();
     } else {
         // Generated content (e.g. list markers and CSS :before and :after pseudoelements) have no corresponding DOM element,
         // and so cannot be represented by a VisiblePosition. Use whatever follows instead.
         startBox = rootBox->firstLeafChild();
         while (true) {
             if (!startBox)
                 return PositionWithAffinityTemplate<Strategy>();
 
-            startNode = startBox->lineLayoutItem().nonPseudoNode();
+            startNode = startBox->getLineLayoutItem().nonPseudoNode();
             if (startNode)
                 break;
 
             startBox = startBox->nextLeafChild();
         }
     }
 
     return PositionWithAffinityTemplate<Strategy>(startNode->isTextNode() ? PositionTemplate<Strategy>(toText(startNode), toInlineTextBox(startBox)->start()) : PositionTemplate<Strategy>::beforeNode(startNode));
 }
 
@@ skipping 76 matching lines @@
             return VisiblePositionTemplate<Strategy>();
     } else {
         // Generated content (e.g. list markers and CSS :before and :after
         // pseudo elements) have no corresponding DOM element, and so cannot be
         // represented by a VisiblePosition. Use whatever precedes instead.
         endBox = rootBox->lastLeafChild();
         while (true) {
             if (!endBox)
                 return VisiblePositionTemplate<Strategy>();
 
-            endNode = endBox->lineLayoutItem().nonPseudoNode();
+            endNode = endBox->getLineLayoutItem().nonPseudoNode();
             if (endNode)
                 break;
 
             endBox = endBox->prevLeafChild();
         }
     }
 
     PositionTemplate<Strategy> pos;
     if (isHTMLBRElement(*endNode)) {
         pos = PositionTemplate<Strategy>::beforeNode(endNode);
@@ skipping 216 matching lines @@
             RenderedPosition renderedPosition((createVisiblePosition(position)));
             root = renderedPosition.rootBox();
             if (!root)
                 return createVisiblePosition(position);
         }
     }
 
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         LayoutPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
-        LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->lineLayoutItem();
+        LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->getLineLayoutItem();
         Node* node = lineLayoutItem.node();
         if (node && editingIgnoresContent(node))
             return createVisiblePosition(positionInParentBeforeNode(*node));
         return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
     }
 
     // Could not find a previous line. This means we must already be on the first line.
     // Move to the start of the content in this block, which effectively moves us
     // to the start of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
@@ skipping 35 matching lines @@
             RenderedPosition renderedPosition((createVisiblePosition(position)));
             root = renderedPosition.rootBox();
             if (!root)
                 return createVisiblePosition(position);
         }
     }
 
     if (root) {
         // FIXME: Can be wrong for multi-column layout and with transforms.
         LayoutPoint pointInLine = absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
-        LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->lineLayoutItem();
+        LineLayoutItem lineLayoutItem = root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))->getLineLayoutItem();
         Node* node = lineLayoutItem.node();
         if (node && editingIgnoresContent(node))
             return createVisiblePosition(positionInParentBeforeNode(*node));
         return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
     }
 
     // Could not find a next line. This means we must already be on the last line.
     // Move to the end of the content in this block, which effectively moves us
     // to the end of the line we're on.
     Element* rootElement = node->hasEditableStyle(editableType) ? node->rootEditableElement(editableType) : node->document().documentElement();
@@ skipping 731 matching lines @@
     }
     Node* node = position.position().anchorNode();
 
     layoutObject = node->layoutObject();
     if (!layoutObject)
         return LayoutRect();
 
     InlineBoxPosition boxPosition = computeInlineBoxPosition(position.position(), position.affinity());
 
     if (boxPosition.inlineBox)
-        layoutObject = LineLayoutAPIShim::layoutObjectFrom(boxPosition.inlineBox->lineLayoutItem());
+        layoutObject = LineLayoutAPIShim::layoutObjectFrom(boxPosition.inlineBox->getLineLayoutItem());
 
     return layoutObject->localCaretRect(boxPosition.inlineBox, boxPosition.offsetInBox);
 }
 
 LayoutRect localCaretRectOfPosition(const PositionWithAffinity& position, LayoutObject*& layoutObject)
 {
     return localCaretRectOfPositionTemplate<EditingStrategy>(position, layoutObject);
 }
 
 LayoutRect localCaretRectOfPosition(const PositionInFlatTreeWithAffinity& position, LayoutObject*& layoutObject)
@@ skipping 414 matching lines @@
 
                 // The text continues on the next line only if the last text box is not on this line and
                 // none of the boxes on this line have a larger start offset.
 
                 bool continuesOnNextLine = true;
                 InlineBox* otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->nextLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->getLineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
                         continuesOnNextLine = false;
                 }
 
                 otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->prevLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->getLineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() > textOffset))
                         continuesOnNextLine = false;
                 }
 
                 if (continuesOnNextLine)
                     return currentPos.computePosition();
             }
         }
     }
     return lastVisible.deprecatedComputePosition();
 }
@@ skipping 101 matching lines @@
 
                 // The text continues on the next line only if the last text box is not on this line and
                 // none of the boxes on this line have a larger start offset.
 
                 bool continuesOnNextLine = true;
                 InlineBox* otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->nextLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->getLineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
                         continuesOnNextLine = false;
                 }
 
                 otherBox = box;
                 while (continuesOnNextLine) {
                     otherBox = otherBox->prevLeafChild();
                     if (!otherBox)
                         break;
-                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->lineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
+                    if (otherBox == lastTextBox || (LineLayoutAPIShim::layoutObjectFrom(otherBox->getLineLayoutItem()) == textLayoutObject && toInlineTextBox(otherBox)->start() >= textOffset))
                         continuesOnNextLine = false;
                 }
 
                 if (continuesOnNextLine)
                     return currentPos.computePosition();
             }
         }
     }
 
     return lastVisible.deprecatedComputePosition();
@@ skipping 212 matching lines @@
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
 
     while (true) {
         InlineBoxPosition boxPosition = computeInlineBoxPosition(p, affinity, primaryDirection);
         InlineBox* box = boxPosition.inlineBox;
         int offset = boxPosition.offsetInBox;
         if (!box)
             return primaryDirection == LTR ? previousVisuallyDistinctCandidate(deepPosition) : nextVisuallyDistinctCandidate(deepPosition);
 
-        LineLayoutItem lineLayoutItem = box->lineLayoutItem();
+        LineLayoutItem lineLayoutItem = box->getLineLayoutItem();
 
         while (true) {
             if ((lineLayoutItem.isAtomicInlineLevel() || lineLayoutItem.isBR()) && offset == box->caretRightmostOffset())
                 return box->isLeftToRightDirection() ? previousVisuallyDistinctCandidate(deepPosition) : nextVisuallyDistinctCandidate(deepPosition);
 
             if (!lineLayoutItem.node()) {
                 box = box->prevLeafChild();
                 if (!box)
                     return primaryDirection == LTR ? previousVisuallyDistinctCandidate(deepPosition) : nextVisuallyDistinctCandidate(deepPosition);
-                lineLayoutItem = box->lineLayoutItem();
+                lineLayoutItem = box->getLineLayoutItem();
                 offset = box->caretRightmostOffset();
                 continue;
             }
 
             offset = box->isLeftToRightDirection() ? lineLayoutItem.previousOffset(offset) : lineLayoutItem.nextOffset(offset);
 
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (offset > caretMinOffset && offset < caretMaxOffset)
                 break;
 
             if (box->isLeftToRightDirection() ? offset < caretMinOffset : offset > caretMaxOffset) {
                 // Overshot to the left.
                 InlineBox* prevBox = box->prevLeafChildIgnoringLineBreak();
                 if (!prevBox) {
                     PositionTemplate<Strategy> positionOnLeft = primaryDirection == LTR ? previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent()) : nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
                     if (positionOnLeft.isNull())
                         return PositionTemplate<Strategy>();
 
                     InlineBox* boxOnLeft = computeInlineBoxPosition(positionOnLeft, affinity, primaryDirection).inlineBox;
                     if (boxOnLeft && boxOnLeft->root() == box->root())
                         return PositionTemplate<Strategy>();
                     return positionOnLeft;
                 }
 
                 // Reposition at the other logical position corresponding to our
                 // edge's visual position and go for another round.
                 box = prevBox;
-                lineLayoutItem = box->lineLayoutItem();
+                lineLayoutItem = box->getLineLayoutItem();
                 offset = prevBox->caretRightmostOffset();
                 continue;
             }
 
             ASSERT(offset == box->caretLeftmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* prevBox = box->prevLeafChild();
 
             if (box->direction() == primaryDirection) {
                 if (!prevBox) {
                     InlineBox* logicalStart = 0;
                     if (primaryDirection == LTR ? box->root().getLogicalStartBoxWithNode(logicalStart) : box->root().getLogicalEndBoxWithNode(logicalStart)) {
                         box = logicalStart;
-                        lineLayoutItem = box->lineLayoutItem();
+                        lineLayoutItem = box->getLineLayoutItem();
                         offset = primaryDirection == LTR ? box->caretMinOffset() : box->caretMaxOffset();
                     }
                     break;
                 }
                 if (prevBox->bidiLevel() >= level)
                     break;
 
                 level = prevBox->bidiLevel();
 
                 InlineBox* nextBox = box;
                 do {
                     nextBox = nextBox->nextLeafChild();
                 } while (nextBox && nextBox->bidiLevel() > level);
 
                 if (nextBox && nextBox->bidiLevel() == level)
                     break;
 
                 box = prevBox;
-                lineLayoutItem = box->lineLayoutItem();
+                lineLayoutItem = box->getLineLayoutItem();
                 offset = box->caretRightmostOffset();
                 if (box->direction() == primaryDirection)
                     break;
                 continue;
             }
 
-            while (prevBox && !prevBox->lineLayoutItem().node())
+            while (prevBox && !prevBox->getLineLayoutItem().node())
                 prevBox = prevBox->prevLeafChild();
 
             if (prevBox) {
                 box = prevBox;
-                lineLayoutItem = box->lineLayoutItem();
+                lineLayoutItem = box->getLineLayoutItem();
                 offset = box->caretRightmostOffset();
                 if (box->bidiLevel() > level) {
                     do {
                         prevBox = prevBox->prevLeafChild();
                     } while (prevBox && prevBox->bidiLevel() > level);
 
                     if (!prevBox || prevBox->bidiLevel() < level)
                         continue;
                 }
             } else {
@@ skipping 10 matching lines @@
                     level = box->bidiLevel();
                     while (InlineBox* prevBox = box->prevLeafChild()) {
                         if (prevBox->bidiLevel() < level)
                             break;
                         box = prevBox;
                     }
                     if (box->bidiLevel() == level)
                         break;
                     level = box->bidiLevel();
                 }
-                lineLayoutItem = box->lineLayoutItem();
+                lineLayoutItem = box->getLineLayoutItem();
                 offset = primaryDirection == LTR ? box->caretMinOffset() : box->caretMaxOffset();
             }
             break;
         }
 
         p = PositionTemplate<Strategy>::editingPositionOf(lineLayoutItem.node(), offset);
 
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
@@ skipping 37 matching lines @@
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
 
     while (true) {
         InlineBoxPosition boxPosition = computeInlineBoxPosition(p, affinity, primaryDirection);
         InlineBox* box = boxPosition.inlineBox;
         int offset = boxPosition.offsetInBox;
         if (!box)
             return primaryDirection == LTR ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
 
-        LayoutObject* layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+        LayoutObject* layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
 
         while (true) {
             if ((layoutObject->isAtomicInlineLevel() || layoutObject->isBR()) && offset == box->caretLeftmostOffset())
                 return box->isLeftToRightDirection() ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
 
             if (!layoutObject->node()) {
                 box = box->nextLeafChild();
                 if (!box)
                     return primaryDirection == LTR ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
-                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                 offset = box->caretLeftmostOffset();
                 continue;
             }
 
             offset = box->isLeftToRightDirection() ? layoutObject->nextOffset(offset) : layoutObject->previousOffset(offset);
 
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (offset > caretMinOffset && offset < caretMaxOffset)
                 break;
 
             if (box->isLeftToRightDirection() ? offset > caretMaxOffset : offset < caretMinOffset) {
                 // Overshot to the right.
                 InlineBox* nextBox = box->nextLeafChildIgnoringLineBreak();
                 if (!nextBox) {
                     PositionTemplate<Strategy> positionOnRight = primaryDirection == LTR ? nextVisuallyDistinctCandidate(deepPosition) : previousVisuallyDistinctCandidate(deepPosition);
                     if (positionOnRight.isNull())
                         return PositionTemplate<Strategy>();
 
                     InlineBox* boxOnRight = computeInlineBoxPosition(positionOnRight, affinity, primaryDirection).inlineBox;
                     if (boxOnRight && boxOnRight->root() == box->root())
                         return PositionTemplate<Strategy>();
                     return positionOnRight;
                 }
 
                 // Reposition at the other logical position corresponding to our
                 // edge's visual position and go for another round.
                 box = nextBox;
-                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                 offset = nextBox->caretLeftmostOffset();
                 continue;
             }
 
             ASSERT(offset == box->caretRightmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* nextBox = box->nextLeafChild();
 
             if (box->direction() == primaryDirection) {
                 if (!nextBox) {
                     InlineBox* logicalEnd = 0;
                     if (primaryDirection == LTR ? box->root().getLogicalEndBoxWithNode(logicalEnd) : box->root().getLogicalStartBoxWithNode(logicalEnd)) {
                         box = logicalEnd;
-                        layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+                        layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                         offset = primaryDirection == LTR ? box->caretMaxOffset() : box->caretMinOffset();
                     }
                     break;
                 }
 
                 if (nextBox->bidiLevel() >= level)
                     break;
 
                 level = nextBox->bidiLevel();
 
                 InlineBox* prevBox = box;
                 do {
                     prevBox = prevBox->prevLeafChild();
                 } while (prevBox && prevBox->bidiLevel() > level);
 
                 // For example, abc FED 123 ^ CBA
                 if (prevBox && prevBox->bidiLevel() == level)
                     break;
 
                 // For example, abc 123 ^ CBA or 123 ^ CBA abc
                 box = nextBox;
-                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                 offset = box->caretLeftmostOffset();
                 if (box->direction() == primaryDirection)
                     break;
                 continue;
             }
 
-            while (nextBox && !nextBox->lineLayoutItem().node())
+            while (nextBox && !nextBox->getLineLayoutItem().node())
                 nextBox = nextBox->nextLeafChild();
 
             if (nextBox) {
                 box = nextBox;
-                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                 offset = box->caretLeftmostOffset();
 
                 if (box->bidiLevel() > level) {
                     do {
                         nextBox = nextBox->nextLeafChild();
                     } while (nextBox && nextBox->bidiLevel() > level);
 
                     if (!nextBox || nextBox->bidiLevel() < level)
                         continue;
                 }
@@ skipping 10 matching lines @@
                     level = box->bidiLevel();
                     while (InlineBox* nextBox = box->nextLeafChild()) {
                         if (nextBox->bidiLevel() < level)
                             break;
                         box = nextBox;
                     }
                     if (box->bidiLevel() == level)
                         break;
                     level = box->bidiLevel();
                 }
-                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->lineLayoutItem());
+                layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                 offset = primaryDirection == LTR ? box->caretMaxOffset() : box->caretMinOffset();
             }
             break;
         }
 
         p = PositionTemplate<Strategy>::editingPositionOf(layoutObject->node(), offset);
 
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
@@ skipping 109 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink