Pass through non-character codepoints in UTF-8,16,32 and Wide conversion func...

base/string_util_icu.cc

 // Copyright (c) 2006-2008 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 "base/string_util.h"
 
 #include <string.h>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "unicode/ucnv.h"
 #include "unicode/numfmt.h"
 #include "unicode/ustring.h"
 
 namespace {
 
+inline bool IsValidCodepoint(uint32 code_point) {
+  // Excludes the surrogate code points ([0xD800, 0xDFFF]) and
+  // codepoints larger than 0x10FFFF (the highest codepoint allowed).
+  // Non-characters and unassigned codepoints are allowed.
+  return code_point < 0xD800u ||
+         (code_point >= 0xE000u && code_point <= 0x10FFFFu);
+}
+
 // ReadUnicodeCharacter --------------------------------------------------------
 
 // Reads a UTF-8 stream, placing the next code point into the given output
 // |*code_point|. |src| represents the entire string to read, and |*char_index|
 // is the character offset within the string to start reading at. |*char_index|
 // will be updated to index the last character read, such that incrementing it
 // (as in a for loop) will take the reader to the next character.
 //
 // Returns true on success. On false, |*code_point| will be invalid.
 bool ReadUnicodeCharacter(const char* src, int32 src_len,
                           int32* char_index, uint32* code_point_out) {
   // U8_NEXT expects to be able to use -1 to signal an error, so we must
   // use a signed type for code_point.  But this function returns false
   // on error anyway, so code_point_out is unsigned.
   int32 code_point;
   U8_NEXT(src, *char_index, src_len, code_point);
   *code_point_out = static_cast<uint32>(code_point);
 
   // The ICU macro above moves to the next char, we want to point to the last
   // char consumed.
   (*char_index)--;
 
   // Validate the decoded value.
-  return U_IS_UNICODE_CHAR(code_point);
+  return IsValidCodepoint(code_point);
 }
 
 // Reads a UTF-16 character. The usage is the same as the 8-bit version above.
 bool ReadUnicodeCharacter(const char16* src, int32 src_len,
                           int32* char_index, uint32* code_point) {
   if (U16_IS_SURROGATE(src[*char_index])) {
     if (!U16_IS_SURROGATE_LEAD(src[*char_index]) ||
         *char_index + 1 >= src_len ||
         !U16_IS_TRAIL(src[*char_index + 1])) {
       // Invalid surrogate pair.
       return false;
     }
 
     // Valid surrogate pair.
     *code_point = U16_GET_SUPPLEMENTARY(src[*char_index],
                                         src[*char_index + 1]);
     (*char_index)++;
   } else {
     // Not a surrogate, just one 16-bit word.
     *code_point = src[*char_index];
   }
 
-  return U_IS_UNICODE_CHAR(*code_point);
+  return IsValidCodepoint(*code_point);
 }
 
 #if defined(WCHAR_T_IS_UTF32)
 // Reads UTF-32 character. The usage is the same as the 8-bit version above.
 bool ReadUnicodeCharacter(const wchar_t* src, int32 src_len,
                         int32* char_index, uint32* code_point) {
   // Conversion is easy since the source is 32-bit.
   *code_point = src[*char_index];
 
   // Validate the value.
-  return U_IS_UNICODE_CHAR(*code_point);
+  return IsValidCodepoint(*code_point);
 }
 #endif  // defined(WCHAR_T_IS_UTF32)
 
 // WriteUnicodeCharacter -------------------------------------------------------
 
 // Appends a UTF-8 character to the given 8-bit string.
 void WriteUnicodeCharacter(uint32 code_point, std::string* output) {
   if (code_point <= 0x7f) {
     // Fast path the common case of one byte.
     output->push_back(code_point);
@@ skipping 40 matching lines @@
 // the result.
 template<typename SRC_CHAR, typename DEST_STRING>
 bool ConvertUnicode(const SRC_CHAR* src, size_t src_len, DEST_STRING* output) {
   output->clear();
 
   // ICU requires 32-bit numbers.
   bool success = true;
   int32 src_len32 = static_cast<int32>(src_len);
   for (int32 i = 0; i < src_len32; i++) {
     uint32 code_point;
-    if (ReadUnicodeCharacter(src, src_len32, &i, &code_point))
+    if (ReadUnicodeCharacter(src, src_len32, &i, &code_point)) {
       WriteUnicodeCharacter(code_point, output);
-    else
+    } else {
+      // TODO(jungshik): consider adding 'Replacement character' (U+FFFD)
+      // in place of an invalid codepoint.
       success = false;
+    }
   }
   return success;
 }
 
 
 // Guesses the length of the output in UTF-8 in bytes, and reserves that amount
 // of space in the given string. We also assume that the input character types
 // are unsigned, which will be true for UTF-16 and -32 on our systems. We assume
 // the string length is greater than zero.
 template<typename CHAR>
@@ skipping 270 matching lines @@
                     const char* codepage_name,
                     OnStringUtilConversionError::Type on_error,
                     std::wstring* wide) {
   wide->clear();
 
   UErrorCode status = U_ZERO_ERROR;
   UConverter* converter = ucnv_open(codepage_name, &status);
   if (!U_SUCCESS(status))
     return false;
 
-  // The worst case is all the input characters are non-BMP (32-bit) ones.
-  size_t uchar_max_length = encoded.length() * 2 + 1;
+  // Even in the worst case, the maximum length in 2-byte units of UTF-16
+  // output would be at most the same as the number of bytes in input. There
+  // is no single-byte encoding in which a character is mapped to a
+  // non-BMP character requiring two 2-byte units.
+  //
+  // Moreover, non-BMP characters in legacy multibyte encodings
+  // (e.g. EUC-JP, GB18030) take at least 2 bytes. The only exceptions are
+  // BOCU and SCSU, but we don't care about them.
+  size_t uchar_max_length = encoded.length() + 1;
 
   UChar* uchar_dst;
 #if defined(WCHAR_T_IS_UTF16)
   uchar_dst = WriteInto(wide, uchar_max_length);
 #elif defined(WCHAR_T_IS_UTF32)
   // When wchar_t is wider than UChar (16 bits), convert into a temporary
   // UChar* buffer.
   std::vector<UChar> wide_uchar(uchar_max_length);
   uchar_dst = &wide_uchar[0];
 #endif  // defined(WCHAR_T_IS_UTF32)
@@ skipping 93 matching lines @@
   // This implementation is not so fast since it converts the text encoding
   // twice. Please feel free to file a bug if this function hurts the
   // performance of Chrome.
   DCHECK(IsStringUTF8(input));
   std::wstring input_wide = UTF8ToWide(input);
   std::wstring output_wide;
   TrimPositions result = TrimWhitespace(input_wide, positions, &output_wide);
   *output = WideToUTF8(output_wide);
   return result;
 }