Get rid of wstring variants of StringToFoo.

base/string_util.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 "build/build_config.h"
 
 #include <ctype.h>
 #include <errno.h>
@@ skipping 109 matching lines @@
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
     return strtol(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
-class WStringToLongTraits {
+class String16ToLongTraits {
  public:
-  typedef std::wstring string_type;
+  typedef string16 string_type;
   typedef long value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
+#if defined(WCHAR_T_IS_UTF16)
     return wcstol(str, endptr, kBase);
+#elif defined(WCHAR_T_IS_UTF32)
+    std::string ascii_string = UTF16ToASCII(string16(str));
+    char* ascii_end = NULL;
+    value_type ret = strtol(ascii_string.c_str(), &ascii_end, kBase);
+    if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
+      *endptr =
+          const_cast<string_type::value_type*>(str) + ascii_string.length();
+    }
+    return ret;
+#endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 class StringToInt64Traits {
  public:
   typedef std::string string_type;
   typedef int64 value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
 #ifdef OS_WIN
     return _strtoi64(str, endptr, kBase);
 #else  // assume OS_POSIX
     return strtoll(str, endptr, kBase);
 #endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
-class WStringToInt64Traits {
+class String16ToInt64Traits {
  public:
-  typedef std::wstring string_type;
+  typedef string16 string_type;
   typedef int64 value_type;
   static const int kBase = 10;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
 #ifdef OS_WIN
     return _wcstoi64(str, endptr, kBase);
 #else  // assume OS_POSIX
-    return wcstoll(str, endptr, kBase);
+    std::string ascii_string = UTF16ToASCII(string16(str));
+    char* ascii_end = NULL;
+    value_type ret = strtoll(ascii_string.c_str(), &ascii_end, kBase);
+    if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
+      *endptr =
+          const_cast<string_type::value_type*>(str) + ascii_string.length();
+    }
+    return ret;
 #endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 // For the HexString variants, use the unsigned variants like strtoul for
 // convert_func so that input like "0x80000000" doesn't result in an overflow.
 
 class HexStringToLongTraits {
  public:
   typedef std::string string_type;
   typedef long value_type;
   static const int kBase = 16;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
     return strtoul(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
-class HexWStringToLongTraits {
+class HexString16ToLongTraits {
  public:
-  typedef std::wstring string_type;
+  typedef string16 string_type;
   typedef long value_type;
   static const int kBase = 16;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
+#if defined(WCHAR_T_IS_UTF16)
     return wcstoul(str, endptr, kBase);
+#elif defined(WCHAR_T_IS_UTF32)
+    std::string ascii_string = UTF16ToASCII(string16(str));
+    char* ascii_end = NULL;
+    value_type ret = strtoul(ascii_string.c_str(), &ascii_end, kBase);
+    if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
+      *endptr =
+          const_cast<string_type::value_type*>(str) + ascii_string.length();
+    }
+    return ret;
+#endif
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 class StringToDoubleTraits {
  public:
   typedef std::string string_type;
   typedef double value_type;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
     return dmg_fp::strtod(str, endptr);
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !isspace(str[0]);
   }
 };
 
-class WStringToDoubleTraits {
+class String16ToDoubleTraits {
  public:
-  typedef std::wstring string_type;
+  typedef string16 string_type;
   typedef double value_type;
   static inline value_type convert_func(const string_type::value_type* str,
                                         string_type::value_type** endptr) {
-    // Because dmg_fp::strtod does not like wchar_t, we convert it to ASCII.
-    // In theory, this should be safe, but it's possible that wide chars
+    // Because dmg_fp::strtod does not like char16, we convert it to ASCII.
+    // In theory, this should be safe, but it's possible that 16-bit chars
     // might get ignored by accident causing something to be parsed when it
     // shouldn't.
-    std::string ascii_string = WideToASCII(std::wstring(str));
+    std::string ascii_string = UTF16ToASCII(string16(str));
     char* ascii_end = NULL;
     value_type ret = dmg_fp::strtod(ascii_string.c_str(), &ascii_end);
     if (ascii_string.c_str() + ascii_string.length() == ascii_end) {
       // Put endptr at end of input string, so it's not recognized as an error.
-      *endptr = const_cast<string_type::value_type*>(str) + wcslen(str);
+      *endptr =
+          const_cast<string_type::value_type*>(str) + ascii_string.length();
     }
 
     return ret;
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
   }
 };
 
 }  // namespace
@@ skipping 1169 matching lines @@
 // because there's no such thing as strtoi.  Use *ToLongTraits through a cast
 // instead, requiring that long and int are compatible and equal-width.  They
 // are on our target platforms.
 
 bool StringToInt(const std::string& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_strtol_to_int);
   return StringToNumber<StringToLongTraits>(input,
                                             reinterpret_cast<long*>(output));
 }
 
-bool StringToInt(const std::wstring& input, int* output) {
+bool StringToInt(const string16& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
-  return StringToNumber<WStringToLongTraits>(input,
-                                             reinterpret_cast<long*>(output));
+  return StringToNumber<String16ToLongTraits>(input,
+                                              reinterpret_cast<long*>(output));
 }
 
 bool StringToInt64(const std::string& input, int64* output) {
   return StringToNumber<StringToInt64Traits>(input, output);
 }
 
-bool StringToInt64(const std::wstring& input, int64* output) {
-  return StringToNumber<WStringToInt64Traits>(input, output);
+bool StringToInt64(const string16& input, int64* output) {
+  return StringToNumber<String16ToInt64Traits>(input, output);
 }
 
 bool HexStringToInt(const std::string& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_strtol_to_int);
   return StringToNumber<HexStringToLongTraits>(input,
                                                reinterpret_cast<long*>(output));
 }
 
-bool HexStringToInt(const std::wstring& input, int* output) {
+bool HexStringToInt(const string16& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
-  return StringToNumber<HexWStringToLongTraits>(
+  return StringToNumber<HexString16ToLongTraits>(
       input, reinterpret_cast<long*>(output));
 }
 
 namespace {
 
 template<class CHAR>
 bool HexDigitToIntT(const CHAR digit, uint8* val) {
   if (digit >= '0' && digit <= '9')
     *val = digit - '0';
   else if (digit >= 'a' && digit <= 'f')
@@ skipping 21 matching lines @@
   }
   return true;
 }
 
 }  // namespace
 
 bool HexStringToBytes(const std::string& input, std::vector<uint8>* output) {
   return HexStringToBytesT(input, output);
 }
 
-bool HexStringToBytes(const std::wstring& input, std::vector<uint8>* output) {
+bool HexStringToBytes(const string16& input, std::vector<uint8>* output) {
   return HexStringToBytesT(input, output);
 }
 
 int StringToInt(const std::string& value) {
   int result;
   StringToInt(value, &result);
   return result;
 }
 
-int StringToInt(const std::wstring& value) {
+int StringToInt(const string16& value) {
   int result;
   StringToInt(value, &result);
   return result;
 }
 
 int64 StringToInt64(const std::string& value) {
   int64 result;
   StringToInt64(value, &result);
   return result;
 }
 
-int64 StringToInt64(const std::wstring& value) {
+int64 StringToInt64(const string16& value) {
   int64 result;
   StringToInt64(value, &result);
   return result;
 }
 
 int HexStringToInt(const std::string& value) {
   int result;
   HexStringToInt(value, &result);
   return result;
 }
 
-int HexStringToInt(const std::wstring& value) {
+int HexStringToInt(const string16& value) {
   int result;
   HexStringToInt(value, &result);
   return result;
 }
 
 bool StringToDouble(const std::string& input, double* output) {
   return StringToNumber<StringToDoubleTraits>(input, output);
 }
 
-bool StringToDouble(const std::wstring& input, double* output) {
-  return StringToNumber<WStringToDoubleTraits>(input, output);
+bool StringToDouble(const string16& input, double* output) {
+  return StringToNumber<String16ToDoubleTraits>(input, output);
 }
 
 double StringToDouble(const std::string& value) {
   double result;
   StringToDouble(value, &result);
   return result;
 }
 
-double StringToDouble(const std::wstring& value) {
+double StringToDouble(const string16& value) {
   double result;
   StringToDouble(value, &result);
   return result;
 }
 
 // The following code is compatible with the OpenBSD lcpy interface.  See:
 //   http://www.gratisoft.us/todd/papers/strlcpy.html
 //   ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
 
 namespace {
@@ skipping 66 matching lines @@
   // Each input byte creates two output hex characters.
   std::string ret(size * 2, '\0');
 
   for (size_t i = 0; i < size; ++i) {
     char b = reinterpret_cast<const char*>(bytes)[i];
     ret[(i * 2)] = kHexChars[(b >> 4) & 0xf];
     ret[(i * 2) + 1] = kHexChars[b & 0xf];
   }
   return ret;
 }