Rename unchecked functions to appropriate name.

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 551 matching lines @@
     const int length = str.length();
     DCHECK_EQ(TextSegmentationMachineState::NeedFollowingCodeUnit, state);
     for (int i = current; i < length; ++i) {
         state = machine.feedFollowingCodeUnit(str[i]);
         if (state != TextSegmentationMachineState::NeedMoreCodeUnit)
             break;
     }
     return current + machine.finalizeAndGetBoundaryOffset();
 }
 
-int uncheckedPreviousOffset(const Node* node, int current)
+int previousGraphemeBoundaryOf(const Node* node, int current)
 {
     if (!node->isTextNode())
         return current - 1;
     const String& text = toText(node)->data();
     if (text.is8Bit())
         return current - 1; // TODO(nona): Good to support CR x LF.
     TextBreakIterator* iterator = cursorMovementIterator(text.characters16(), text.length());
     if (!iterator)
         return current - 1;
     const int result = iterator->preceding(current);
     return result == TextBreakDone ? current - 1 : result;
 }
 
-static int uncheckedPreviousOffsetForBackwardDeletion(const Node* node, int current)
+static int previousBackwardDeletionOffsetOf(const Node* node, int current)
 {
     DCHECK_GE(current, 0);
     if (current <= 1)
         return 0;
     if (!node->isTextNode())
         return current - 1;
 
     const String& text = toText(node)->data();
     DCHECK_LT(static_cast<unsigned>(current - 1), text.length());
     return findNextBoundaryOffset<BackspaceStateMachine>(text, current);
 }
 
-int uncheckedNextOffset(const Node* node, int current)
+int nextGraphemeBoundaryOf(const Node* node, int current)
 {
     if (!node->isTextNode())
         return current + 1;
     const String& text = toText(node)->data();
     if (text.is8Bit())
         return current + 1; // TODO(nona): Good to support CR x LF.
     TextBreakIterator* iterator = cursorMovementIterator(text.characters16(), text.length());
     if (!iterator)
         return current + 1;
     const int result = iterator->following(current);
@@ skipping 18 matching lines @@
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and
         //      therefore has no children. Going backward one character at a
         //      time is correct.
         //   2) The old offset was a bogus offset like (<br>, 1), and there is
         //      no child. Going from 1 to 0 is correct.
         switch (moveType) {
         case PositionMoveType::CodeUnit:
             return PositionTemplate<Strategy>(node, offset - 1);
         case PositionMoveType::CodePoint:
-            return PositionTemplate<Strategy>(node, uncheckedPreviousOffset(node, offset));
+            // TODO(nona): Move to PositionMoveType::GraphemeBoundary case.
+            return PositionTemplate<Strategy>(node, previousGraphemeBoundaryOf(node, offset));
         case PositionMoveType::BackwardDeletion:
-            return PositionTemplate<Strategy>(node, uncheckedPreviousOffsetForBackwardDeletion(node, offset));
+            return PositionTemplate<Strategy>(node, previousBackwardDeletionOffsetOf(node, offset));
         }
     }
 
     if (ContainerNode* parent = Strategy::parent(*node)) {
         if (editingIgnoresContent(parent))
             return PositionTemplate<Strategy>::beforeNode(parent);
         // TODO(yosin) We should use |Strategy::index(Node&)| instead of
         // |Node::nodeIndex()|.
         return PositionTemplate<Strategy>(parent, node->nodeIndex());
     }
@@ skipping 26 matching lines @@
 
     // TODO(yosin) We should use |Strategy::lastOffsetForEditing()| instead of
     // DOM tree version.
     if (!Strategy::hasChildren(*node) && offset < EditingStrategy::lastOffsetForEditing(node)) {
         // There are two reasons child might be 0:
         //   1) The node is node like a text node that is not an element, and
         //      therefore has no children. Going forward one character at a time
         //      is correct.
         //   2) The new offset is a bogus offset like (<br>, 1), and there is no
         //      child. Going from 0 to 1 is correct.
-        return PositionTemplate<Strategy>::editingPositionOf(node, (moveType == PositionMoveType::CodePoint) ? uncheckedNextOffset(node, offset) : offset + 1);
+        // TODO(nona): Call nextGraphemeBoundaryOf if
+        //             moveType == PositionMoveType::GraphemeBoundary
+        return PositionTemplate<Strategy>::editingPositionOf(node, (moveType == PositionMoveType::CodePoint) ? nextGraphemeBoundaryOf(node, offset) : offset + 1);
     }
 
     if (ContainerNode* parent = Strategy::parent(*node))
         return PositionTemplate<Strategy>::editingPositionOf(parent, Strategy::index(*node) + 1);
     return position;
 }
 
 Position nextPositionOf(const Position& position, PositionMoveType moveType)
 {
     return nextPositionOfAlgorithm<EditingStrategy>(position, moveType);
@@ skipping 1002 matching lines @@
     // instead of possibly at the end of the last node before the selection
     return mostForwardCaretPosition(visiblePosition.deepEquivalent());
 }
 
 bool isTextSecurityNode(const Node* node)
 {
     return node && node->layoutObject() && node->layoutObject()->style()->textSecurity() != TSNONE;
 }
 
 } // namespace blink