Add VisibleUnits::startOfWordPosition

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 1025 matching lines @@
     return 0;
   }
   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(
+static PositionTemplate<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;
+      return c.deepEquivalent();
 
     p = nextPositionOf(c);
     if (p.isNull())
-      return c;
+      return c.deepEquivalent();
   }
-  return createVisiblePosition(previousBoundary(p, startWordBoundary));
+  return previousBoundary(p, startWordBoundary);
 }
 
-VisiblePosition startOfWord(const VisiblePosition& c, EWordSide side) {
-  return startOfWordAlgorithm<EditingStrategy>(c, side);
+Position startOfWordPosition(const VisiblePosition& position, EWordSide side) {
+  return startOfWordAlgorithm<EditingStrategy>(position, side);
 }
 
-VisiblePositionInFlatTree startOfWord(const VisiblePositionInFlatTree& c,
+VisiblePosition startOfWord(const VisiblePosition& position, EWordSide side) {
+  return createVisiblePosition(startOfWordPosition(position, side));
+}
+
+PositionInFlatTree startOfWordPosition(
+    const VisiblePositionInFlatTree& position,
+    EWordSide side) {
+  return startOfWordAlgorithm<EditingInFlatTreeStrategy>(position, side);
+}
+
+VisiblePositionInFlatTree startOfWord(const VisiblePositionInFlatTree& position,
                                       EWordSide side) {
-  return startOfWordAlgorithm<EditingInFlatTreeStrategy>(c, side);
+  return createVisiblePosition(startOfWordPosition(position, side));
 }
 
 static unsigned endWordBoundary(
     const UChar* characters,
     unsigned length,
     unsigned offset,
     BoundarySearchContextAvailability mayHaveMoreContext,
     bool& needMoreContext) {
   DCHECK_LE(offset, length);
   if (mayHaveMoreContext &&
@@ skipping 2905 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink