Avoid duplicate functions/code in core/editing: kUnsetCodePoint

third_party/WebKit/Source/core/editing/state_machines/ForwardGraphemeBoundaryStateMachine.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/editing/state_machines/ForwardGraphemeBoundaryStateMachine.h"
 
 #include "core/editing/state_machines/StateMachineUtil.h"
 #include "core/editing/state_machines/TextSegmentationMachineState.h"
 #include "platform/text/Character.h"
 #include "wtf/text/Unicode.h"
 #include <ostream>  // NOLINT
 
 namespace blink {
 namespace {
-const UChar32 kInvalidCodePoint = WTF::Unicode::kMaxCodepoint + 1;
+const UChar32 kUnsetCodePoint = WTF::Unicode::kMaxCodepoint + 1;
 }  // namespace
 
 #define FOR_EACH_FORWARD_GRAPHEME_BOUNDARY_STATE(V)                    \
   /* Counting preceding regional indicators. This is initial state. */ \
   V(CountRIS)                                                          \
   /* Waiting lead surrogate during counting regional indicators. */    \
   V(CountRISWaitLeadSurrogate)                                         \
   /* Waiting first following code unit. */                             \
   V(StartForward)                                                      \
   /* Waiting trail surrogate for the first following code point. */    \
@@ skipping 19 matching lines @@
       FOR_EACH_FORWARD_GRAPHEME_BOUNDARY_STATE(V)
 #undef V
   };
   const auto& it = std::begin(texts) + static_cast<size_t>(state);
   DCHECK_GE(it, std::begin(texts)) << "Unknown state value";
   DCHECK_LT(it, std::end(texts)) << "Unknown state value";
   return os << *it;
 }
 
 ForwardGraphemeBoundaryStateMachine::ForwardGraphemeBoundaryStateMachine()
-    : m_prevCodePoint(kInvalidCodePoint),
+    : m_prevCodePoint(kUnsetCodePoint),
       m_internalState(InternalState::CountRIS) {}
 
 TextSegmentationMachineState
 ForwardGraphemeBoundaryStateMachine::feedPrecedingCodeUnit(UChar codeUnit) {
-  DCHECK_EQ(m_prevCodePoint, kInvalidCodePoint);
+  DCHECK_EQ(m_prevCodePoint, kUnsetCodePoint);
   DCHECK_EQ(m_boundaryOffset, 0);
   switch (m_internalState) {
     case InternalState::CountRIS:
       DCHECK_EQ(m_pendingCodeUnit, 0);
       if (U16_IS_TRAIL(codeUnit)) {
         m_pendingCodeUnit = codeUnit;
         return moveToNextState(InternalState::CountRISWaitLeadSurrogate);
       }
       return moveToNextState(InternalState::StartForward);
     case InternalState::CountRISWaitLeadSurrogate:
@@ skipping 28 matching lines @@
 TextSegmentationMachineState
 ForwardGraphemeBoundaryStateMachine::feedFollowingCodeUnit(UChar codeUnit) {
   switch (m_internalState) {
     case InternalState::CountRIS:  // Fallthrough
     case InternalState::CountRISWaitLeadSurrogate:
       NOTREACHED() << "Do not call feedFollowingCodeUnit() until "
                    << TextSegmentationMachineState::NeedFollowingCodeUnit
                    << " is returned. InternalState: " << m_internalState;
       return finish();
     case InternalState::StartForward:
-      DCHECK_EQ(m_prevCodePoint, kInvalidCodePoint);
+      DCHECK_EQ(m_prevCodePoint, kUnsetCodePoint);
       DCHECK_EQ(m_boundaryOffset, 0);
       DCHECK_EQ(m_pendingCodeUnit, 0);
       if (U16_IS_TRAIL(codeUnit)) {
         // Lonely trail surrogate.
         m_boundaryOffset = 1;
         return finish();
       }
       if (U16_IS_LEAD(codeUnit)) {
         m_pendingCodeUnit = codeUnit;
         return moveToNextState(InternalState::StartForwardWaitTrailSurrgate);
       }
       m_prevCodePoint = codeUnit;
       m_boundaryOffset = 1;
       return moveToNextState(InternalState::Search);
     case InternalState::StartForwardWaitTrailSurrgate:
-      DCHECK_EQ(m_prevCodePoint, kInvalidCodePoint);
+      DCHECK_EQ(m_prevCodePoint, kUnsetCodePoint);
       DCHECK_EQ(m_boundaryOffset, 0);
       DCHECK_NE(m_pendingCodeUnit, 0);
       if (U16_IS_TRAIL(codeUnit)) {
         m_prevCodePoint = U16_GET_SUPPLEMENTARY(m_pendingCodeUnit, codeUnit);
         m_boundaryOffset = 2;
         m_pendingCodeUnit = 0;
         return moveToNextState(InternalState::Search);
       }
       // Lonely lead surrogate.
       m_boundaryOffset = 1;
       return finish();
     case InternalState::Search:
-      DCHECK_NE(m_prevCodePoint, kInvalidCodePoint);
+      DCHECK_NE(m_prevCodePoint, kUnsetCodePoint);
       DCHECK_NE(m_boundaryOffset, 0);
       DCHECK_EQ(m_pendingCodeUnit, 0);
       if (U16_IS_LEAD(codeUnit)) {
         m_pendingCodeUnit = codeUnit;
         return moveToNextState(InternalState::SearchWaitTrailSurrogate);
       }
       if (U16_IS_TRAIL(codeUnit))
         return finish();  // Lonely trail surrogate.
       if (isGraphemeBreak(m_prevCodePoint, codeUnit))
         return finish();
       m_prevCodePoint = codeUnit;
       m_boundaryOffset += 1;
       return staySameState();
     case InternalState::SearchWaitTrailSurrogate:
-      DCHECK_NE(m_prevCodePoint, kInvalidCodePoint);
+      DCHECK_NE(m_prevCodePoint, kUnsetCodePoint);
       DCHECK_NE(m_boundaryOffset, 0);
       DCHECK_NE(m_pendingCodeUnit, 0);
       if (!U16_IS_TRAIL(codeUnit))
         return finish();  // Lonely lead surrogate.
 
       {
         const UChar32 codePoint =
             U16_GET_SUPPLEMENTARY(m_pendingCodeUnit, codeUnit);
         m_pendingCodeUnit = 0;
         if (Character::isRegionalIndicator(m_prevCodePoint) &&
@@ skipping 38 matching lines @@
   if (m_internalState != InternalState::Finished)
     finishWithEndOfText();
   DCHECK_GE(m_boundaryOffset, 0);
   return m_boundaryOffset;
 }
 
 void ForwardGraphemeBoundaryStateMachine::reset() {
   m_pendingCodeUnit = 0;
   m_boundaryOffset = 0;
   m_precedingRISCount = 0;
-  m_prevCodePoint = kInvalidCodePoint;
+  m_prevCodePoint = kUnsetCodePoint;
   m_internalState = InternalState::CountRIS;
 }
 
 TextSegmentationMachineState ForwardGraphemeBoundaryStateMachine::finish() {
   DCHECK_NE(m_internalState, InternalState::Finished);
   m_internalState = InternalState::Finished;
   return TextSegmentationMachineState::Finished;
 }
 
 TextSegmentationMachineState
@@ skipping 25 matching lines @@
       return;
     case InternalState::Search:                    // Fallthrough
     case InternalState::SearchWaitTrailSurrogate:  // Fallthrough
       return;
     case InternalState::Finished:  // Fallthrough
       NOTREACHED() << "Do not call finishWithEndOfText() once it finishes.";
   }
   NOTREACHED() << "Unhandled state: " << m_internalState;
 }
 }  // namespace blink