Clean up recent string conversion function changes, part 1: Remove unnecessar...

base/i18n/icu_string_conversions.cc

 // Copyright (c) 2009 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/i18n/icu_string_conversions.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 139 matching lines @@
 
 }  // namespace
 
 const char kCodepageLatin1[] = "ISO-8859-1";
 const char kCodepageUTF8[] = "UTF-8";
 const char kCodepageUTF16BE[] = "UTF-16BE";
 const char kCodepageUTF16LE[] = "UTF-16LE";
 
 // Codepage <-> Wide/UTF-16  ---------------------------------------------------
 
-// Convert a UTF-16 string into the specified codepage_name.  If the codepage
-// isn't found, return false.
 bool UTF16ToCodepage(const string16& utf16,
                      const char* codepage_name,
                      OnStringConversionError::Type on_error,
                      std::string* encoded) {
   encoded->clear();
 
   UErrorCode status = U_ZERO_ERROR;
   UConverter* converter = ucnv_open(codepage_name, &status);
   if (!U_SUCCESS(status))
     return false;
 
   return ConvertFromUTF16(converter, utf16.c_str(),
                           static_cast<int>(utf16.length()), on_error, encoded);
 }
 
-bool CodepageToUTF16AndAdjustOffset(const std::string& encoded,
-                                    const char* codepage_name,
-                                    OnStringConversionError::Type on_error,
-                                    string16* utf16,
-                                    size_t* offset_for_adjustment) {
+bool CodepageToUTF16(const std::string& encoded,
+                     const char* codepage_name,
+                     OnStringConversionError::Type on_error,
+                     string16* utf16) {
   utf16->clear();
 
   UErrorCode status = U_ZERO_ERROR;
   UConverter* converter = ucnv_open(codepage_name, &status);
   if (!U_SUCCESS(status))
     return false;
 
   // 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;
 
   SetUpErrorHandlerForToUChars(on_error, converter, &status);
-  char16* byte_buffer = WriteInto(utf16, uchar_max_length);
-  int byte_buffer_length = static_cast<int>(uchar_max_length);
-  const char* data = encoded.data();
-  int length = static_cast<int>(encoded.length());
-  int actual_size = 0;
-  if (offset_for_adjustment) {
-    if (*offset_for_adjustment >= encoded.length()) {
-      *offset_for_adjustment = string16::npos;
-    } else if (*offset_for_adjustment != 0) {
-      // Try to adjust the offset by converting the string in two pieces and
-      // using the length of the first piece as the adjusted offset.
-      actual_size += ucnv_toUChars(converter, byte_buffer, byte_buffer_length,
-          data, static_cast<int>(*offset_for_adjustment), &status);
-      if (U_SUCCESS(status)) {
-        // Conversion succeeded, so update the offset and then fall through to
-        // appending the second half of the string.
-        data += *offset_for_adjustment;
-        length -= *offset_for_adjustment;
-        *offset_for_adjustment = actual_size;
-        byte_buffer += actual_size;
-        byte_buffer_length -= actual_size;
-      } else {
-        // The offset may have been in the middle of an encoding sequence; mark
-        // it as having failed to adjust and then try to convert the entire
-        // string.
-        *offset_for_adjustment = string16::npos;
-        actual_size = 0;
-        ucnv_reset(converter);
-        status = U_ZERO_ERROR;
-      }
-    }
-  }
-  actual_size += ucnv_toUChars(converter, byte_buffer, byte_buffer_length, data,
-                               length, &status);
+  int actual_size = ucnv_toUChars(converter, WriteInto(utf16, uchar_max_length),
+      static_cast<int>(uchar_max_length), encoded.data(),
+      static_cast<int>(encoded.length()), &status);
   ucnv_close(converter);
   if (!U_SUCCESS(status)) {
     utf16->clear();  // Make sure the output is empty on error.
     return false;
   }
 
   utf16->resize(actual_size);
   return true;
 }
 
-// Convert a wstring into the specified codepage_name.  If the codepage
-// isn't found, return false.
 bool WideToCodepage(const std::wstring& wide,
                     const char* codepage_name,
                     OnStringConversionError::Type on_error,
                     std::string* encoded) {
 #if defined(WCHAR_T_IS_UTF16)
   return UTF16ToCodepage(wide, codepage_name, on_error, encoded);
 #elif defined(WCHAR_T_IS_UTF32)
   encoded->clear();
 
   UErrorCode status = U_ZERO_ERROR;
   UConverter* converter = ucnv_open(codepage_name, &status);
   if (!U_SUCCESS(status))
     return false;
 
   int utf16_len;
   // When wchar_t is wider than UChar (16 bits), transform |wide| into a
   // UChar* string.  Size the UChar* buffer to be large enough to hold twice
   // as many UTF-16 code units (UChar's) as there are Unicode code points,
   // in case each code points translates to a UTF-16 surrogate pair,
   // and leave room for a NUL terminator.
   std::vector<UChar> utf16(wide.length() * 2 + 1);
   u_strFromWCS(&utf16[0], utf16.size(), &utf16_len,
                wide.c_str(), wide.length(), &status);
   DCHECK(U_SUCCESS(status)) << "failed to convert wstring to UChar*";
 
   return ConvertFromUTF16(converter, &utf16[0], utf16_len, on_error, encoded);
 #endif  // defined(WCHAR_T_IS_UTF32)
 }
 
-// Converts a string of the given codepage into wstring.
-// If the codepage isn't found, return false.
-bool CodepageToWideAndAdjustOffset(const std::string& encoded,
-                                   const char* codepage_name,
-                                   OnStringConversionError::Type on_error,
-                                   std::wstring* wide,
-                                   size_t* offset_for_adjustment) {
+bool CodepageToWide(const std::string& encoded,
+                    const char* codepage_name,
+                    OnStringConversionError::Type on_error,
+                    std::wstring* wide) {
 #if defined(WCHAR_T_IS_UTF16)
-  return CodepageToUTF16AndAdjustOffset(encoded, codepage_name, on_error, wide,
-                                        offset_for_adjustment);
+  return CodepageToUTF16(encoded, codepage_name, on_error, wide);
 #elif defined(WCHAR_T_IS_UTF32)
   wide->clear();
 
   UErrorCode status = U_ZERO_ERROR;
   UConverter* converter = ucnv_open(codepage_name, &status);
   if (!U_SUCCESS(status))
     return false;
 
   // The maximum length in 4 byte unit of UTF-32 output would be
   // at most the same as the number of bytes in input. In the worst
   // case of GB18030 (excluding escaped-based encodings like ISO-2022-JP),
   // this can be 4 times larger than actually needed.
   size_t wchar_max_length = encoded.length() + 1;
 
   SetUpErrorHandlerForToUChars(on_error, converter, &status);
-  char* byte_buffer =
-      reinterpret_cast<char*>(WriteInto(wide, wchar_max_length));
-  int byte_buffer_length = static_cast<int>(wchar_max_length) * sizeof(wchar_t);
-  const char* data = encoded.data();
-  int length = static_cast<int>(encoded.length());
-  int actual_size = 0;
-  if (offset_for_adjustment) {
-    if (*offset_for_adjustment >= encoded.length()) {
-      *offset_for_adjustment = std::wstring::npos;
-    } else if (*offset_for_adjustment != 0) {
-      // Try to adjust the offset by converting the string in two pieces and
-      // using the length of the first piece as the adjusted offset.
-      actual_size += ucnv_toAlgorithmic(utf32_platform_endian(), converter,
-          byte_buffer, byte_buffer_length, data,
-          static_cast<int>(*offset_for_adjustment), &status);
-      if (U_SUCCESS(status)) {
-        // Conversion succeeded, so update the offset and then fall through to
-        // appending the second half of the string.
-        data += *offset_for_adjustment;
-        length -= *offset_for_adjustment;
-        *offset_for_adjustment = actual_size / sizeof(wchar_t);
-        byte_buffer += actual_size;
-        byte_buffer_length -= actual_size;
-      } else {
-        // The offset may have been in the middle of an encoding sequence; mark
-        // it as having failed to adjust and then try to convert the entire
-        // string.
-        *offset_for_adjustment = std::wstring::npos;
-        actual_size = 0;
-        ucnv_reset(converter);
-        status = U_ZERO_ERROR;
-      }
-    }
-  }
-  actual_size += ucnv_toAlgorithmic(utf32_platform_endian(), converter,
-      byte_buffer, byte_buffer_length, data, length, &status);
+  int actual_size = ucnv_toAlgorithmic(utf32_platform_endian(), converter,
+      reinterpret_cast<char*>(WriteInto(wide, wchar_max_length)),
+      static_cast<int>(wchar_max_length) * sizeof(wchar_t), encoded.data(),
+      static_cast<int>(encoded.length()), &status);
   ucnv_close(converter);
   if (!U_SUCCESS(status)) {
     wide->clear();  // Make sure the output is empty on error.
     return false;
   }
 
   // actual_size is # of bytes.
   wide->resize(actual_size / sizeof(wchar_t));
   return true;
 #endif  // defined(WCHAR_T_IS_UTF32)
 }
 
 }  // namespace base