Making Unicode character names consistent

Source/wtf/text/TextCodecUTF8.cpp

 /*
  * Copyright (C) 2004, 2006, 2008, 2011 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 149 matching lines @@
     --m_partialSequenceSize;
     memmove(m_partialSequence, m_partialSequence + 1, m_partialSequenceSize);
 }
 
 void TextCodecUTF8::handleError(UChar*& destination, bool stopOnError, bool& sawError)
 {
     sawError = true;
     if (stopOnError)
         return;
     // Each error generates a replacement character and consumes one byte.
-    *destination++ = replacementCharacter;
+    *destination++ = characterReplacement;
     consumePartialSequenceByte();
 }
 
 template <>
 bool TextCodecUTF8::handlePartialSequence<LChar>(LChar*& destination, const uint8_t*& source, const uint8_t* end, bool flush, bool, bool&)
 {
     ASSERT(m_partialSequenceSize);
     do {
         if (isASCII(m_partialSequence[0])) {
             *destination++ = m_partialSequence[0];
             consumePartialSequenceByte();
             continue;
         }
         int count = nonASCIISequenceLength(m_partialSequence[0]);
         if (!count)
             return true;
 
         if (count > m_partialSequenceSize) {
             if (count - m_partialSequenceSize > end - source) {
                 if (!flush) {
                     // The new data is not enough to complete the sequence, so
                     // add it to the existing partial sequence.
                     memcpy(m_partialSequence + m_partialSequenceSize, source, end - source);
                     m_partialSequenceSize += end - source;
                     return false;
                 }
                 // An incomplete partial sequence at the end is an error, but it will create
-                // a 16 bit string due to the replacementCharacter. Let the 16 bit path handle
+                // a 16 bit string due to the characterReplacement. Let the 16 bit path handle
                 // the error.
                 return true;
             }
             memcpy(m_partialSequence + m_partialSequenceSize, source, count - m_partialSequenceSize);
             source += count - m_partialSequenceSize;
             m_partialSequenceSize = count;
         }
         int character = decodeNonASCIISequence(m_partialSequence, count);
         if (character & ~0xff)
             return true;
@@ skipping 195 matching lines @@
                     source = end;
                     break;
                 }
                 character = decodeNonASCIISequence(source, count);
             }
             if (character == nonCharacter) {
                 sawError = true;
                 if (stopOnError)
                     break;
                 // Each error generates a replacement character and consumes one byte.
-                *destination16++ = replacementCharacter;
+                *destination16++ = characterReplacement;
                 ++source;
                 continue;
             }
             source += count;
             destination16 = appendCharacter(destination16, character);
         }
     } while (flush && m_partialSequenceSize);
 
     buffer16.shrink(destination16 - buffer16.characters());
 
@@ skipping 11 matching lines @@
     Vector<uint8_t> bytes(length * 3);
 
     size_t i = 0;
     size_t bytesWritten = 0;
     while (i < length) {
         UChar32 character;
         U16_NEXT(characters, i, length, character);
         // U16_NEXT will simply emit a surrogate code point if an unmatched surrogate
         // is encountered; we must convert it to a U+FFFD (REPLACEMENT CHARACTER) here.
         if (0xD800 <= character && character <= 0xDFFF)
-            character = replacementCharacter;
+            character = characterReplacement;
         U8_APPEND_UNSAFE(bytes.data(), bytesWritten, character);
     }
 
     return CString(reinterpret_cast<char*>(bytes.data()), bytesWritten);
 }
 
 CString TextCodecUTF8::encode(const UChar* characters, size_t length, UnencodableHandling)
 {
     return encodeCommon(characters, length);
 }
 
 CString TextCodecUTF8::encode(const LChar* characters, size_t length, UnencodableHandling)
 {
     return encodeCommon(characters, length);
 }
 
 } // namespace WTF