Change VisibleUnits::previousBoundary to return Position rather than VisiblePosition

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
@@ skipping 792 matching lines @@
   MayHaveMoreContext
 };
 
 typedef unsigned (*BoundarySearchFunction)(const UChar*,
                                            unsigned length,
                                            unsigned offset,
                                            BoundarySearchContextAvailability,
                                            bool& needMoreContext);
 
 template <typename Strategy>
-static VisiblePositionTemplate<Strategy> previousBoundary(
+static PositionTemplate<Strategy> previousBoundary(
     const VisiblePositionTemplate<Strategy>& c,
     BoundarySearchFunction searchFunction) {
   DCHECK(c.isValid()) << c;
   const PositionTemplate<Strategy> pos = c.deepEquivalent();
   Node* boundary = parentEditingBoundary(pos);
   if (!boundary)
-    return VisiblePositionTemplate<Strategy>();
+    return PositionTemplate<Strategy>();
 
   const PositionTemplate<Strategy> start =
       PositionTemplate<Strategy>::editingPositionOf(boundary, 0)
           .parentAnchoredEquivalent();
   const PositionTemplate<Strategy> end = pos.parentAnchoredEquivalent();
 
   ForwardsTextBuffer suffixString;
   if (requiresContextForWordBoundary(characterBefore(c))) {
     TextIteratorAlgorithm<Strategy> forwardsIterator(
         end, PositionTemplate<Strategy>::afterNode(boundary));
@@ skipping 50 matching lines @@
     // more context, but there is no earlier text. Force a search with
     // what's available.
     // TODO(xiaochengh): Do we have to search the whole string?
     next = searchFunction(string.data(), string.size(),
                           string.size() - suffixLength, DontHaveMoreContext,
                           needMoreContext);
     DCHECK(!needMoreContext);
   }
 
   if (!next)
-    return createVisiblePosition(it.atEnd() ? it.startPosition() : pos);
+    return it.atEnd() ? it.startPosition() : pos;
 
   Node* node = it.startContainer();
   int boundaryOffset = remainingLength + next;
   if (node->isTextNode() && boundaryOffset <= node->maxCharacterOffset()) {
     // The next variable contains a usable index into a text node
-    return createVisiblePosition(
-        PositionTemplate<Strategy>(node, boundaryOffset));
+    return PositionTemplate<Strategy>(node, boundaryOffset);
   }
 
   // Use the character iterator to translate the next value into a DOM
   // 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());
+  return charIt.endPosition();
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> nextBoundary(
     const VisiblePositionTemplate<Strategy>& c,
     BoundarySearchFunction searchFunction) {
   DCHECK(c.isValid()) << c;
   PositionTemplate<Strategy> pos = c.deepEquivalent();
   Node* boundary = parentEditingBoundary(pos);
   if (!boundary)
@@ skipping 137 matching lines @@
   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())
       return c;
   }
-  return previousBoundary(p, startWordBoundary);
+  return createVisiblePosition(previousBoundary(p, startWordBoundary));
 }
 
 VisiblePosition startOfWord(const VisiblePosition& c, EWordSide side) {
   return startOfWordAlgorithm<EditingStrategy>(c, side);
 }
 
 VisiblePositionInFlatTree startOfWord(const VisiblePositionInFlatTree& c,
                                       EWordSide side) {
   return startOfWordAlgorithm<EditingInFlatTreeStrategy>(c, side);
 }
@@ skipping 54 matching lines @@
       !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);
+  VisiblePosition prev =
+      createVisiblePosition(previousBoundary(c, previousWordPositionBoundary));
   return honorEditingBoundaryAtOrBefore(prev, c.deepEquivalent());
 }
 
 static unsigned nextWordPositionBoundary(
     const UChar* characters,
     unsigned length,
     unsigned offset,
     BoundarySearchContextAvailability mayHaveMoreContext,
     bool& needMoreContext) {
   if (mayHaveMoreContext &&
@@ skipping 517 matching lines @@
                                       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);
+  return createVisiblePosition(previousBoundary(c, startSentenceBoundary));
 }
 
 VisiblePosition startOfSentence(const VisiblePosition& c) {
   return startOfSentenceAlgorithm<EditingStrategy>(c);
 }
 
 VisiblePositionInFlatTree startOfSentence(const VisiblePositionInFlatTree& c) {
   return startOfSentenceAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
@@ skipping 31 matching lines @@
     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);
+  VisiblePosition prev = createVisiblePosition(
+      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.
@@ skipping 2225 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink