Add VisiblePosition validity checks to VisibleUnits.cpp

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 183 matching lines @@
         return PositionWithAffinityTemplate<Strategy>();
 
     // Return the last position before |pos| that is in the same editable region
     // as this position
     return lastEditablePositionBeforePositionInRoot(pos.position(), *highestRoot);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> honorEditingBoundaryAtOrBefore(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
-    DCHECK(pos.isValid());
+    DCHECK(pos.isValid()) << pos;
     return createVisiblePosition(honorEditingBoundaryAtOrBefore(pos.toPositionWithAffinity(), anchor));
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> honorEditingBoundaryAtOrAfter(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
+    DCHECK(pos.isValid()) << pos;
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
 
     // Return empty position if |pos| is not somewhere inside the editable
     // region containing this position
     if (highestRoot && !pos.deepEquivalent().anchorNode()->isDescendantOf(highestRoot))
         return VisiblePositionTemplate<Strategy>();
 
@@ skipping 86 matching lines @@
         if (editable == hasEditableStyle(*node, editableType))
             return node;
         node = nextAtomicLeafNode(*node);
     }
     return 0;
 }
 
 // FIXME: consolidate with code in previousLinePosition.
 static Position previousRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Node* previousNode = previousLeafWithSameEditability(node, editableType);
 
     while (previousNode && (!previousNode->layoutObject() || inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(previousNode)), visiblePosition)))
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
 
     while (previousNode && !previousNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(previousNode), editableType) != highestRoot)
             break;
 
         Position pos = isHTMLBRElement(*previousNode) ? Position::beforeNode(previousNode) :
             Position::editingPositionOf(previousNode, caretMaxOffset(previousNode));
 
         if (isVisuallyEquivalentCandidate(pos))
             return pos;
 
         previousNode = previousLeafWithSameEditability(previousNode, editableType);
     }
     return Position();
 }
 
 static Position nextRootInlineBoxCandidatePosition(Node* node, const VisiblePosition& visiblePosition, EditableType editableType)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
     Node* nextNode = nextLeafWithSameEditability(node, editableType);
     while (nextNode && (!nextNode->layoutObject() || inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(nextNode)), visiblePosition)))
         nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
 
     while (nextNode && !nextNode->isShadowRoot()) {
         if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode), editableType) != highestRoot)
             break;
 
         Position pos;
@@ skipping 83 matching lines @@
     for (size_t i = 0; i < m_leafBoxes.size(); ++i) {
         if (box == m_leafBoxes[i])
             return i;
     }
     return 0;
 }
 
 static const InlineTextBox* logicallyPreviousBox(const VisiblePosition& visiblePosition, const InlineTextBox* textBox,
     bool& previousBoxInDifferentBlock, CachedLogicallyOrderedLeafBoxes& leafBoxes)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     const InlineBox* startBox = textBox;
 
     const InlineTextBox* previousBox = leafBoxes.previousTextBox(&startBox->root(), textBox);
     if (previousBox)
         return previousBox;
 
     previousBox = leafBoxes.previousTextBox(startBox->root().prevRootBox(), 0);
     if (previousBox)
         return previousBox;
 
@@ skipping 21 matching lines @@
             break;
         startBox = leafBoxes.firstBox();
     }
     return 0;
 }
 
 
 static const InlineTextBox* logicallyNextBox(const VisiblePosition& visiblePosition, const InlineTextBox* textBox,
     bool& nextBoxInDifferentBlock, CachedLogicallyOrderedLeafBoxes& leafBoxes)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     const InlineBox* startBox = textBox;
 
     const InlineTextBox* nextBox = leafBoxes.nextTextBox(&startBox->root(), textBox);
     if (nextBox)
         return nextBox;
 
     nextBox = leafBoxes.nextTextBox(startBox->root().nextRootBox(), 0);
     if (nextBox)
         return nextBox;
 
@@ skipping 20 matching lines @@
         if (!leafBoxes.size())
             break;
         startBox = leafBoxes.firstBox();
     }
     return 0;
 }
 
 static TextBreakIterator* wordBreakIteratorForMinOffsetBoundary(const VisiblePosition& visiblePosition, const InlineTextBox* textBox,
     int& previousBoxLength, bool& previousBoxInDifferentBlock, Vector<UChar, 1024>& string, CachedLogicallyOrderedLeafBoxes& leafBoxes)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     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->getLineLayoutItem().text().appendTo(string, previousBox->start(), previousBoxLength);
         len += previousBoxLength;
     }
     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)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     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->getLineLayoutItem().text().appendTo(string, textBox->start(), textBox->len());
     len += textBox->len();
     if (nextBox) {
@@ skipping 19 matching lines @@
 {
     bool boundary = iter->isBoundary(position);
     return (hardLineBreak || boundary) && isWordTextBreak(iter);
 }
 
 enum CursorMovementDirection { MoveLeft, MoveRight };
 
 static VisiblePosition visualWordPosition(const VisiblePosition& visiblePosition, CursorMovementDirection direction,
     bool skipsSpaceWhenMovingRight)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     if (visiblePosition.isNull())
         return VisiblePosition();
 
     TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
     InlineBox* previouslyVisitedBox = 0;
     VisiblePosition current = visiblePosition;
     TextBreakIterator* iter = 0;
 
     CachedLogicallyOrderedLeafBoxes leafBoxes;
     Vector<UChar, 1024> string;
@@ skipping 50 matching lines @@
         if (isWordBreak)
             return adjacentCharacterPosition;
 
         current = adjacentCharacterPosition;
     }
     return VisiblePosition();
 }
 
 VisiblePosition leftWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     VisiblePosition leftWordBreak = visualWordPosition(visiblePosition, MoveLeft, skipsSpaceWhenMovingRight);
     leftWordBreak = honorEditingBoundaryAtOrBefore(leftWordBreak, visiblePosition.deepEquivalent());
 
     // FIXME: How should we handle a non-editable position?
     if (leftWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
         TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
         leftWordBreak = blockDirection == LTR ? startOfEditableContent(visiblePosition) : endOfEditableContent(visiblePosition);
     }
     return leftWordBreak;
 }
 
 VisiblePosition rightWordPosition(const VisiblePosition& visiblePosition, bool skipsSpaceWhenMovingRight)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     VisiblePosition rightWordBreak = visualWordPosition(visiblePosition, MoveRight, skipsSpaceWhenMovingRight);
     rightWordBreak = honorEditingBoundaryAtOrBefore(rightWordBreak, visiblePosition.deepEquivalent());
 
     // FIXME: How should we handle a non-editable position?
     if (rightWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
         TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
         rightWordBreak = blockDirection == LTR ? endOfEditableContent(visiblePosition) : startOfEditableContent(visiblePosition);
     }
     return rightWordBreak;
 }
@@ skipping 23 matching lines @@
     return boundary;
 }
 
 enum BoundarySearchContextAvailability { DontHaveMoreContext, MayHaveMoreContext };
 
 typedef unsigned (*BoundarySearchFunction)(const UChar*, unsigned length, unsigned offset, BoundarySearchContextAvailability, bool& needMoreContext);
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> previousBoundary(const VisiblePositionTemplate<Strategy>& c, BoundarySearchFunction searchFunction)
 {
-    DCHECK(c.isValid());
+    DCHECK(c.isValid()) << c;
     const PositionTemplate<Strategy> pos = c.deepEquivalent();
     Node* boundary = parentEditingBoundary(pos);
     if (!boundary)
         return VisiblePositionTemplate<Strategy>();
 
     const PositionTemplate<Strategy> start = PositionTemplate<Strategy>::editingPositionOf(boundary, 0).parentAnchoredEquivalent();
     const PositionTemplate<Strategy> end = pos.parentAnchoredEquivalent();
 
     ForwardsTextBuffer suffixString;
     if (requiresContextForWordBoundary(characterBefore(c))) {
@@ skipping 65 matching lines @@
     // position.
     BackwardsCharacterIteratorAlgorithm<Strategy> charIt(start, end);
     charIt.advance(string.size() - suffixLength - next);
     // TODO(yosin) charIt can get out of shadow host.
     return createVisiblePosition(charIt.endPosition());
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> nextBoundary(const VisiblePositionTemplate<Strategy>& c, BoundarySearchFunction searchFunction)
 {
-    DCHECK(c.isValid());
+    DCHECK(c.isValid()) << c;
     PositionTemplate<Strategy> pos = c.deepEquivalent();
     Node* boundary = parentEditingBoundary(pos);
     if (!boundary)
         return VisiblePositionTemplate<Strategy>();
 
     Document& d = boundary->document();
     const PositionTemplate<Strategy> start(pos.parentAnchoredEquivalent());
 
     BackwardsTextBuffer prefixString;
     if (requiresContextForWordBoundary(characterAfter(c))) {
@@ skipping 94 matching lines @@
     needMoreContext = false;
     int start, end;
     U16_BACK_1(characters, 0, offset);
     findWordBoundary(characters, length, offset, &start, &end);
     return start;
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> startOfWordAlgorithm(const VisiblePositionTemplate<Strategy>& c, EWordSide side)
 {
+    DCHECK(c.isValid()) << c;
     // TODO(yosin) This returns a null VP for c at the start of the document
     // and |side| == |LeftWordIfOnBoundary|
     VisiblePositionTemplate<Strategy> p = c;
     if (side == RightWordIfOnBoundary) {
         // at paragraph end, the startofWord is the current position
         if (isEndOfParagraph(c))
             return c;
 
         p = nextPositionOf(c);
         if (p.isNull())
@@ skipping 19 matching lines @@
         needMoreContext = true;
         return length;
     }
     needMoreContext = false;
     return findWordEndBoundary(characters, length, offset);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfWordAlgorithm(const VisiblePositionTemplate<Strategy>& c, EWordSide side)
 {
+    DCHECK(c.isValid()) << c;
     VisiblePositionTemplate<Strategy> p = c;
     if (side == LeftWordIfOnBoundary) {
         if (isStartOfParagraph(c))
             return c;
 
         p = previousPositionOf(c);
         if (p.isNull())
             return c;
     } else if (isEndOfParagraph(c)) {
         return c;
@@ skipping 17 matching lines @@
     if (mayHaveMoreContext && !startOfLastWordBoundaryContext(characters, offset)) {
         needMoreContext = true;
         return 0;
     }
     needMoreContext = false;
     return findNextWordFromIndex(characters, length, offset, false);
 }
 
 VisiblePosition previousWordPosition(const VisiblePosition& c)
 {
+    DCHECK(c.isValid()) << c;
     VisiblePosition prev = previousBoundary(c, previousWordPositionBoundary);
     return honorEditingBoundaryAtOrBefore(prev, c.deepEquivalent());
 }
 
 static unsigned nextWordPositionBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     if (mayHaveMoreContext && endOfFirstWordBoundaryContext(characters + offset, length - offset) == static_cast<int>(length - offset)) {
         needMoreContext = true;
         return length;
     }
     needMoreContext = false;
     return findNextWordFromIndex(characters, length, offset, true);
 }
 
 VisiblePosition nextWordPosition(const VisiblePosition& c)
 {
+    DCHECK(c.isValid()) << c;
     VisiblePosition next = nextBoundary(c, nextWordPositionBoundary);
     return honorEditingBoundaryAtOrAfter(next, c.deepEquivalent());
 }
 
 // ---------
 
 enum LineEndpointComputationMode { UseLogicalOrdering, UseInlineBoxOrdering };
 template <typename Strategy>
 static PositionWithAffinityTemplate<Strategy> startPositionForLine(const PositionWithAffinityTemplate<Strategy>& c, LineEndpointComputationMode mode)
 {
@@ skipping 51 matching lines @@
 }
 
 static PositionInFlatTreeWithAffinity startOfLine(const PositionInFlatTreeWithAffinity& currentPosition)
 {
     return startOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition startOfLine(const VisiblePosition& currentPosition)
 {
-    DCHECK(currentPosition.isValid());
+    DCHECK(currentPosition.isValid()) << currentPosition;
     return createVisiblePosition(startOfLine(currentPosition.toPositionWithAffinity()));
 }
 
 VisiblePositionInFlatTree startOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    DCHECK(currentPosition.isValid());
+    DCHECK(currentPosition.isValid()) << currentPosition;
     return createVisiblePosition(startOfLine(currentPosition.toPositionWithAffinity()));
 }
 
 template <typename Strategy>
 static PositionWithAffinityTemplate<Strategy> logicalStartOfLineAlgorithm(const PositionWithAffinityTemplate<Strategy>& c)
 {
     // TODO: this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     PositionWithAffinityTemplate<Strategy> visPos = startPositionForLine(c, UseLogicalOrdering);
 
     if (ContainerNode* editableRoot = highestEditableRoot(c.position())) {
         if (!editableRoot->contains(visPos.position().computeContainerNode()))
             return PositionWithAffinityTemplate<Strategy>(PositionTemplate<Strategy>::firstPositionInNode(editableRoot));
     }
 
     return honorEditingBoundaryAtOrBefore(visPos, c.position());
 }
 
 VisiblePosition logicalStartOfLine(const VisiblePosition& currentPosition)
 {
-    DCHECK(currentPosition.isValid());
+    DCHECK(currentPosition.isValid()) << currentPosition;
     return createVisiblePosition(logicalStartOfLineAlgorithm<EditingStrategy>(currentPosition.toPositionWithAffinity()));
 }
 
 VisiblePositionInFlatTree logicalStartOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    DCHECK(currentPosition.isValid());
+    DCHECK(currentPosition.isValid()) << currentPosition;
     return createVisiblePosition(logicalStartOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition.toPositionWithAffinity()));
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endPositionForLine(const VisiblePositionTemplate<Strategy>& c, LineEndpointComputationMode mode)
 {
-    DCHECK(c.isValid());
+    DCHECK(c.isValid()) << c;
     if (c.isNull())
         return VisiblePositionTemplate<Strategy>();
 
     RootInlineBox* rootBox = RenderedPosition(c).rootBox();
     if (!rootBox) {
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         const PositionTemplate<Strategy> p = c.deepEquivalent();
         if (p.anchorNode()->layoutObject() && p.anchorNode()->layoutObject()->isLayoutBlock() && !p.computeEditingOffset())
             return c;
@@ skipping 36 matching lines @@
         pos = PositionTemplate<Strategy>::afterNode(endNode);
     }
 
     return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // TODO(yosin) Rename this function to reflect the fact it ignores bidi levels.
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& currentPosition)
 {
+    DCHECK(currentPosition.isValid()) << currentPosition;
     // TODO(yosin) this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     VisiblePositionTemplate<Strategy> visPos = endPositionForLine(currentPosition, UseInlineBoxOrdering);
 
     // Make sure the end of line is at the same line as the given input
     // position. Else use the previous position to obtain end of line. This
     // condition happens when the input position is before the space character
     // at the end of a soft-wrapped non-editable line. In this scenario,
     // |endPositionForLine()| would incorrectly hand back a position in the next
     // line instead. This fix is to account for the discrepancy between lines
@@ skipping 16 matching lines @@
 }
 
 VisiblePositionInFlatTree endOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
     return endOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 template <typename Strategy>
 static bool inSameLogicalLine(const VisiblePositionTemplate<Strategy>& a, const VisiblePositionTemplate<Strategy>& b)
 {
+    DCHECK(a.isValid()) << a;
+    DCHECK(b.isValid()) << b;
     return a.isNotNull() && logicalStartOfLine(a).deepEquivalent() == logicalStartOfLine(b).deepEquivalent();
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> logicalEndOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& currentPosition)
 {
-    DCHECK(currentPosition.isValid());
+    DCHECK(currentPosition.isValid()) << currentPosition;
     // TODO(yosin) this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     VisiblePositionTemplate<Strategy> visPos = endPositionForLine(currentPosition, UseLogicalOrdering);
 
     // Make sure the end of line is at the same line as the given input
     // position. For a wrapping line, the logical end position for the
     // not-last-2-lines might incorrectly hand back the logical beginning of the
     // next line. For example,
     // <div contenteditable dir="rtl" style="line-break:before-white-space">xyz
     // a xyz xyz xyz xyz xyz xyz xyz xyz xyz xyz </div>
@@ skipping 43 matching lines @@
     return inSameLineAlgorithm<EditingStrategy>(a, b);
 }
 
 bool inSameLine(const PositionInFlatTreeWithAffinity& position1, const PositionInFlatTreeWithAffinity& position2)
 {
     return inSameLineAlgorithm<EditingInFlatTreeStrategy>(position1, position2);
 }
 
 bool inSameLine(const VisiblePosition& position1, const VisiblePosition& position2)
 {
+    DCHECK(position1.isValid()) << position1;
+    DCHECK(position2.isValid()) << position2;
     return inSameLine(position1.toPositionWithAffinity(), position2.toPositionWithAffinity());
 }
 
 bool inSameLine(const VisiblePositionInFlatTree& position1, const VisiblePositionInFlatTree& position2)
 {
+    DCHECK(position1.isValid()) << position1;
+    DCHECK(position2.isValid()) << position2;
     return inSameLine(position1.toPositionWithAffinity(), position2.toPositionWithAffinity());
 }
 
 template <typename Strategy>
 bool isStartOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& p)
 {
+    DCHECK(p.isValid()) << p;
     return p.isNotNull() && p.deepEquivalent() == startOfLine(p).deepEquivalent();
 }
 
 bool isStartOfLine(const VisiblePosition& p)
 {
     return isStartOfLineAlgorithm<EditingStrategy>(p);
 }
 
 bool isStartOfLine(const VisiblePositionInFlatTree& p)
 {
     return isStartOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 template <typename Strategy>
 bool isEndOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& p)
 {
+    DCHECK(p.isValid()) << p;
     return p.isNotNull() && p.deepEquivalent() == endOfLine(p).deepEquivalent();
 }
 
 bool isEndOfLine(const VisiblePosition& p)
 {
     return isEndOfLineAlgorithm<EditingStrategy>(p);
 }
 
 bool isEndOfLine(const VisiblePositionInFlatTree& p)
 {
     return isEndOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 template <typename Strategy>
 static bool isLogicalEndOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& p)
 {
+    DCHECK(p.isValid()) << p;
     return p.isNotNull() && p.deepEquivalent() == logicalEndOfLine(p).deepEquivalent();
 }
 
 bool isLogicalEndOfLine(const VisiblePosition& p)
 {
     return isLogicalEndOfLineAlgorithm<EditingStrategy>(p);
 }
 
 bool isLogicalEndOfLine(const VisiblePositionInFlatTree& p)
 {
     return isLogicalEndOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 static inline LayoutPoint absoluteLineDirectionPointToLocalPointInBlock(RootInlineBox* root, LayoutUnit lineDirectionPoint)
 {
     DCHECK(root);
     LineLayoutBlockFlow containingBlock = root->block();
     FloatPoint absoluteBlockPoint = containingBlock.localToAbsolute(FloatPoint());
     if (containingBlock.hasOverflowClip())
         absoluteBlockPoint -= FloatSize(containingBlock.scrolledContentOffset());
 
     if (root->block().isHorizontalWritingMode())
         return LayoutPoint(LayoutUnit(lineDirectionPoint - absoluteBlockPoint.x()), root->blockDirectionPointInLine());
 
     return LayoutPoint(root->blockDirectionPointInLine(), LayoutUnit(lineDirectionPoint - absoluteBlockPoint.y()));
 }
 
 VisiblePosition previousLinePosition(const VisiblePosition& visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
 
     Position p = visiblePosition.deepEquivalent();
     Node* node = p.anchorNode();
 
     if (!node)
         return VisiblePosition();
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
         return VisiblePosition();
@@ skipping 32 matching lines @@
     // 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 = hasEditableStyle(*node, editableType) ? rootEditableElement(*node, editableType) : node->document().documentElement();
     if (!rootElement)
         return VisiblePosition();
     return VisiblePosition::firstPositionInNode(rootElement);
 }
 
 VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition, LayoutUnit lineDirectionPoint, EditableType editableType)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
 
     Position p = visiblePosition.deepEquivalent();
     Node* node = p.anchorNode();
 
     if (!node)
         return VisiblePosition();
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject)
         return VisiblePosition();
@@ skipping 45 matching lines @@
 static unsigned startSentenceBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     // FIXME: The following function can return -1; we don't handle that.
     return iterator->preceding(length);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> startOfSentenceAlgorithm(const VisiblePositionTemplate<Strategy>& c)
 {
+    DCHECK(c.isValid()) << c;
     return previousBoundary(c, startSentenceBoundary);
 }
 
 VisiblePosition startOfSentence(const VisiblePosition& c)
 {
     return startOfSentenceAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree startOfSentence(const VisiblePositionInFlatTree& c)
 {
     return startOfSentenceAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 static unsigned endSentenceBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     return iterator->next();
 }
 
 // TODO(yosin) This includes the space after the punctuation that marks the end
 // of the sentence.
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfSentenceAlgorithm(const VisiblePositionTemplate<Strategy>& c)
 {
+    DCHECK(c.isValid()) << c;
     return nextBoundary(c, endSentenceBoundary);
 }
 
 VisiblePosition endOfSentence(const VisiblePosition& c)
 {
     return endOfSentenceAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree endOfSentence(const VisiblePositionInFlatTree& c)
 {
     return endOfSentenceAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 static unsigned previousSentencePositionBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     // FIXME: This is identical to startSentenceBoundary. I'm pretty sure that's not right.
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     // FIXME: The following function can return -1; we don't handle that.
     return iterator->preceding(length);
 }
 
 VisiblePosition previousSentencePosition(const VisiblePosition& c)
 {
+    DCHECK(c.isValid()) << c;
     VisiblePosition prev = previousBoundary(c, previousSentencePositionBoundary);
     return honorEditingBoundaryAtOrBefore(prev, c.deepEquivalent());
 }
 
 static unsigned nextSentencePositionBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     // FIXME: This is identical to endSentenceBoundary. This isn't right, it needs to
     // move to the equivlant position in the following sentence.
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     return iterator->following(0);
 }
 
 VisiblePosition nextSentencePosition(const VisiblePosition& c)
 {
+    DCHECK(c.isValid()) << c;
     VisiblePosition next = nextBoundary(c, nextSentencePositionBoundary);
     return honorEditingBoundaryAtOrAfter(next, c.deepEquivalent());
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> startOfParagraphAlgorithm(const PositionTemplate<Strategy>& position, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     Node* const startNode = position.anchorNode();
 
     if (!startNode)
@@ skipping 221 matching lines @@
     return isEndOfParagraphAlgorithm<EditingStrategy>(pos, boundaryCrossingRule);
 }
 
 bool isEndOfParagraph(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isEndOfParagraphAlgorithm<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
 }
 
 VisiblePosition previousParagraphPosition(const VisiblePosition& p, LayoutUnit x)
 {
+    DCHECK(p.isValid()) << p;
     VisiblePosition pos = p;
     do {
         VisiblePosition n = previousLinePosition(pos, x);
         if (n.isNull() || n.deepEquivalent() == pos.deepEquivalent())
             break;
         pos = n;
     } while (inSameParagraph(p, pos));
     return pos;
 }
 
 VisiblePosition nextParagraphPosition(const VisiblePosition& p, LayoutUnit x)
 {
+    DCHECK(p.isValid()) << p;
     VisiblePosition pos = p;
     do {
         VisiblePosition n = nextLinePosition(pos, x);
         if (n.isNull() || n.deepEquivalent() == pos.deepEquivalent())
             break;
         pos = n;
     } while (inSameParagraph(p, pos));
     return pos;
 }
 
 // ---------
 
 VisiblePosition startOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     Position position = visiblePosition.deepEquivalent();
     Element* startBlock = position.computeContainerNode() ? enclosingBlock(position.computeContainerNode(), rule) : 0;
     return startBlock ? VisiblePosition::firstPositionInNode(startBlock) : VisiblePosition();
 }
 
 VisiblePosition endOfBlock(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     Position position = visiblePosition.deepEquivalent();
     Element* endBlock = position.computeContainerNode() ? enclosingBlock(position.computeContainerNode(), rule) : 0;
     return endBlock ? VisiblePosition::lastPositionInNode(endBlock) : VisiblePosition();
 }
 
 bool inSameBlock(const VisiblePosition& a, const VisiblePosition& b)
 {
+    // TODO(xiaochengh): Ensure that this function is called with valid |a| and
+    // |b|, and add |DCHECK(a.isValid())| and |DCHECK(b.isValid())|
     return !a.isNull() && enclosingBlock(a.deepEquivalent().computeContainerNode()) == enclosingBlock(b.deepEquivalent().computeContainerNode());
 }
 
 bool isStartOfBlock(const VisiblePosition& pos)
 {
+    DCHECK(pos.isValid()) << pos;
     return pos.isNotNull() && pos.deepEquivalent() == startOfBlock(pos, CanCrossEditingBoundary).deepEquivalent();
 }
 
 bool isEndOfBlock(const VisiblePosition& pos)
 {
+    DCHECK(pos.isValid()) << pos;
     return pos.isNotNull() && pos.deepEquivalent() == endOfBlock(pos, CanCrossEditingBoundary).deepEquivalent();
 }
 
 // ---------
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> startOfDocumentAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     Node* node = visiblePosition.deepEquivalent().anchorNode();
     if (!node || !node->document().documentElement())
         return VisiblePositionTemplate<Strategy>();
 
     return createVisiblePosition(PositionTemplate<Strategy>::firstPositionInNode(node->document().documentElement()));
 }
 
 VisiblePosition startOfDocument(const VisiblePosition& c)
 {
     return startOfDocumentAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree startOfDocument(const VisiblePositionInFlatTree& c)
 {
     return startOfDocumentAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfDocumentAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     Node* node = visiblePosition.deepEquivalent().anchorNode();
     if (!node || !node->document().documentElement())
         return VisiblePositionTemplate<Strategy>();
 
     Element* doc = node->document().documentElement();
     return createVisiblePosition(PositionTemplate<Strategy>::lastPositionInNode(doc));
 }
 
 VisiblePosition endOfDocument(const VisiblePosition& c)
 {
     return endOfDocumentAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree endOfDocument(const VisiblePositionInFlatTree& c)
 {
     return endOfDocumentAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 bool isStartOfDocument(const VisiblePosition& p)
 {
+    DCHECK(p.isValid()) << p;
     return p.isNotNull() && previousPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 bool isEndOfDocument(const VisiblePosition& p)
 {
+    DCHECK(p.isValid()) << p;
     return p.isNotNull() && nextPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 // ---------
 
 VisiblePosition startOfEditableContent(const VisiblePosition& visiblePosition)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
     return VisiblePosition::firstPositionInNode(highestRoot);
 }
 
 VisiblePosition endOfEditableContent(const VisiblePosition& visiblePosition)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     ContainerNode* highestRoot = highestEditableRoot(visiblePosition.deepEquivalent());
     if (!highestRoot)
         return VisiblePosition();
 
     return VisiblePosition::lastPositionInNode(highestRoot);
 }
 
 bool isEndOfEditableOrNonEditableContent(const VisiblePosition& position)
 {
+    DCHECK(position.isValid()) << position;
     return position.isNotNull() && nextPositionOf(position).isNull();
 }
 
 // TODO(yosin) We should rename |isEndOfEditableOrNonEditableContent()| what
 // this function does, e.g. |isLastVisiblePositionOrEndOfInnerEditor()|.
 bool isEndOfEditableOrNonEditableContent(const VisiblePositionInFlatTree& position)
 {
+    DCHECK(position.isValid()) << position;
     if (position.isNull())
         return false;
     const VisiblePositionInFlatTree nextPosition = nextPositionOf(position);
     if (nextPosition.isNull())
         return true;
     // In DOM version, following condition, the last position of inner editor
     // of INPUT/TEXTAREA element, by |nextPosition().isNull()|, because of
     // an inner editor is an only leaf node.
     if (!nextPosition.deepEquivalent().isAfterAnchor())
         return false;
     return isHTMLTextFormControlElement(nextPosition.deepEquivalent().anchorNode());
 }
 
 VisiblePosition leftBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
+    DCHECK(c.isValid()) << c;
     return direction == LTR ? logicalStartOfLine(c) : logicalEndOfLine(c);
 }
 
 VisiblePosition rightBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
+    DCHECK(c.isValid()) << c;
     return direction == LTR ? logicalEndOfLine(c) : logicalStartOfLine(c);
 }
 
 static bool isNonTextLeafChild(LayoutObject* object)
 {
     if (object->slowFirstChild())
         return false;
     if (object->isText())
         return false;
     return true;
@@ skipping 241 matching lines @@
     return computeInlineBoxPositionTemplate<EditingStrategy>(position, affinity);
 }
 
 InlineBoxPosition computeInlineBoxPosition(const PositionInFlatTree& position, TextAffinity affinity)
 {
     return computeInlineBoxPositionTemplate<EditingInFlatTreeStrategy>(position, affinity);
 }
 
 InlineBoxPosition computeInlineBoxPosition(const VisiblePosition& position)
 {
+    DCHECK(position.isValid()) << position;
     return computeInlineBoxPosition(position.deepEquivalent(), position.affinity());
 }
 
 InlineBoxPosition computeInlineBoxPosition(const VisiblePositionInFlatTree& position)
 {
+    DCHECK(position.isValid()) << position;
     return computeInlineBoxPosition(position.deepEquivalent(), position.affinity());
 }
 
 InlineBoxPosition computeInlineBoxPosition(const Position& position, TextAffinity affinity, TextDirection primaryDirection)
 {
     return computeInlineBoxPositionTemplate<EditingStrategy>(position, affinity, primaryDirection);
 }
 
 InlineBoxPosition computeInlineBoxPosition(const PositionInFlatTree& position, TextAffinity affinity, TextDirection primaryDirection)
 {
@@ skipping 596 matching lines @@
 }
 
 bool isVisuallyEquivalentCandidate(const PositionInFlatTree& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 template <typename Strategy>
 static IntRect absoluteCaretBoundsOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
+    // TODO(xiaochengh): Ensure that this function is called with a valid
+    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|;
     LayoutObject* layoutObject;
     LayoutRect localRect = localCaretRectOfPosition(visiblePosition.toPositionWithAffinity(), layoutObject);
     if (localRect.isEmpty() || !layoutObject)
         return IntRect();
 
     return layoutObject->localToAbsoluteQuad(FloatRect(localRect)).enclosingBoundingBox();
 }
 
 IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 IntRect absoluteCaretBoundsOf(const VisiblePositionInFlatTree& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToEndOfEditingBoundary(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
-    DCHECK(pos.isValid());
+    DCHECK(pos.isValid()) << pos;
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region,
     // or both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
         return createVisiblePosition(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
 
     // That must mean that |pos| is not editable. Return the next position after
     // |pos| that is in the same editable region as this position
     DCHECK(highestRoot);
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), *highestRoot);
 }
 
 template <typename Strategy>
 static UChar32 characterAfterAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
+    // TODO(xiaochengh): Ensure that this function is called with a valid
+    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|
     // We canonicalize to the first of two equivalent candidates, but the second
     // of the two candidates is the one that will be inside the text node
     // containing the character after this visible position.
     const PositionTemplate<Strategy> pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
     if (!pos.isOffsetInAnchor())
         return 0;
     Node* containerNode = pos.computeContainerNode();
     if (!containerNode || !containerNode->isTextNode())
         return 0;
     unsigned offset = static_cast<unsigned>(pos.offsetInContainerNode());
@@ skipping 11 matching lines @@
 }
 
 UChar32 characterAfter(const VisiblePositionInFlatTree& visiblePosition)
 {
     return characterAfterAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static UChar32 characterBeforeAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
+    // TODO(xiaochengh): Ensure that this function is called with a valid
+    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|
     return characterAfter(previousPositionOf(visiblePosition));
 }
 
 UChar32 characterBefore(const VisiblePosition& visiblePosition)
 {
     return characterBeforeAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 UChar32 characterBefore(const VisiblePositionInFlatTree& visiblePosition)
 {
     return characterBeforeAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static PositionTemplate<Strategy> leftVisuallyDistinctCandidate(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     const PositionTemplate<Strategy> deepPosition = visiblePosition.deepEquivalent();
     PositionTemplate<Strategy> p = deepPosition;
 
     if (p.isNull())
         return PositionTemplate<Strategy>();
 
     const PositionTemplate<Strategy> downstreamStart = mostForwardCaretPosition(p);
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
 
@@ skipping 132 matching lines @@
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
         DCHECK_NE(p, deepPosition);
     }
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     const PositionTemplate<Strategy> pos = leftVisuallyDistinctCandidate(visiblePosition);
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     const VisiblePositionTemplate<Strategy> left = createVisiblePosition(pos);
     DCHECK_NE(left.deepEquivalent(), visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrBefore(left, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrAfter(left, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
 {
     return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 VisiblePositionInFlatTree leftPositionOf(const VisiblePositionInFlatTree& visiblePosition)
 {
     return leftPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static PositionTemplate<Strategy> rightVisuallyDistinctCandidate(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     const PositionTemplate<Strategy> deepPosition = visiblePosition.deepEquivalent();
     PositionTemplate<Strategy> p = deepPosition;
     if (p.isNull())
         return PositionTemplate<Strategy>();
 
     const PositionTemplate<Strategy> downstreamStart = mostForwardCaretPosition(p);
     TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
     const TextAffinity affinity = visiblePosition.affinity();
 
     while (true) {
@@ skipping 134 matching lines @@
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
         DCHECK_NE(p, deepPosition);
     }
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> rightPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    DCHECK(visiblePosition.isValid());
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     const PositionTemplate<Strategy> pos = rightVisuallyDistinctCandidate(visiblePosition);
     // FIXME: Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     const VisiblePositionTemplate<Strategy> right = createVisiblePosition(pos);
     DCHECK_NE(right.deepEquivalent(), visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrAfter(right, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrBefore(right, visiblePosition.deepEquivalent());
 }
@@ skipping 33 matching lines @@
 }
 
 VisiblePositionInFlatTree nextPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToStartOfEditingBoundary(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
-    DCHECK(pos.isValid());
+    DCHECK(pos.isValid()) << pos;
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region, or
     // both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
@@ skipping 44 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink