Remove the locale parameter from the StringToDouble and

DoubleToString methods and only leave the
locale independent methods.  It turns out this code is
only used in the json code and if people want locale
formatting, they should use ICU.

Review URL: http://codereview.chromium.org/11423


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@5585 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 60 insertions, 104 deletions

diff --git a/base/string_util.cc b/base/string_util.cc
index 4cc67d7..b77a7fe 100644
--- a/base/string_util.cc
+++ b/base/string_util.cc
@@ -89,14 +89,13 @@ static bool CompareParameter(const ReplacementOffset& elem1,
 //    should check for leading whitespace.
 template<typename StringToNumberTraits>
 bool StringToNumber(const typename StringToNumberTraits::string_type& input,
-                    typename StringToNumberTraits::value_type* output,
-                    base::LocaleDependence locale_dependent) {
+                    typename StringToNumberTraits::value_type* output) {
   typedef StringToNumberTraits traits;
 
   errno = 0;  // Thread-safe?  It is on at least Mac, Linux, and Windows.
   typename traits::string_type::value_type* endptr = NULL;
   typename traits::value_type value = traits::convert_func(input.c_str(),
-      &endptr, locale_dependent == base::LOCALE_DEPENDENT);
+                                                           &endptr);
   *output = value;
 
   // Cases to return false:
@@ -120,8 +119,7 @@ class StringToLongTraits {
   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,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return strtol(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
@@ -135,8 +133,7 @@ class WStringToLongTraits {
   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,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return wcstol(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
@@ -150,8 +147,7 @@ class StringToInt64Traits {
   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,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
 #ifdef OS_WIN
     return _strtoi64(str, endptr, kBase);
 #else  // assume OS_POSIX
@@ -169,8 +165,7 @@ class WStringToInt64Traits {
   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,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
 #ifdef OS_WIN
     return _wcstoi64(str, endptr, kBase);
 #else  // assume OS_POSIX
@@ -191,8 +186,7 @@ class HexStringToLongTraits {
   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,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return strtoul(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
@@ -206,8 +200,7 @@ class HexWStringToLongTraits {
   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,
-                                        bool locale_dependent) {
+                                        string_type::value_type** endptr) {
     return wcstoul(str, endptr, kBase);
   }
   static inline bool valid_func(const string_type& str) {
@@ -220,13 +213,8 @@ class StringToDoubleTraits {
   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,
-                                        bool locale_dependent) {
-    if (locale_dependent) {
-      return strtod(str, endptr);
-    } else {
-      return dmg_fp::strtod(str, endptr);
-    }
+                                        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]);
@@ -238,25 +226,20 @@ class WStringToDoubleTraits {
   typedef std::wstring string_type;
   typedef double value_type;
   static inline value_type convert_func(const string_type::value_type* str,
-                                        string_type::value_type** endptr,
-                                        bool locale_dependent) {
-    if (locale_dependent) {
-      return wcstod(str, endptr);
-    } else {
-      // 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
-      // might get ignored by accident causing something to be parsed when it
-      // shouldn't.
-      std::string ascii_string = WideToASCII(std::wstring(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);
-      }
-
-      return ret;
+                                        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
+    // might get ignored by accident causing something to be parsed when it
+    // shouldn't.
+    std::string ascii_string = WideToASCII(std::wstring(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);
     }
+
+    return ret;
   }
   static inline bool valid_func(const string_type& str) {
     return !str.empty() && !iswspace(str[0]);
@@ -305,45 +288,6 @@ bool IsWprintfFormatPortable(const wchar_t* format) {
   return true;
 }
 
-std::string DoubleToString(double value, LocaleDependence locale_dependent) {
-  if (LOCALE_DEPENDENT == locale_dependent) {
-    return StringPrintf("%g", value);
-  } else {
-    char buffer[32];
-    dmg_fp::g_fmt(buffer, value);
-    return std::string(buffer);
-  }
-}
-
-std::wstring DoubleToWString(double value, LocaleDependence locale_dependent) {
-  return ASCIIToWide(DoubleToString(value, locale_dependent));
-}
-
-bool StringToDouble(const std::string& input, double* output,
-                    LocaleDependence locale_dependent) {
-  return StringToNumber<StringToDoubleTraits>(input, output,
-                                              locale_dependent);
-}
-
-bool StringToDouble(const std::wstring& input, double* output,
-                    LocaleDependence locale_dependent) {
-  return StringToNumber<WStringToDoubleTraits>(input, output,
-                                               locale_dependent);
-}
-
-double StringToDouble(const std::string& value,
-                      LocaleDependence locale_dependent) {
-  double result;
-  StringToDouble(value, &result, locale_dependent);
-  return result;
-}
-
-double StringToDouble(const std::wstring& value,
-                      LocaleDependence locale_dependent) {
-  double result;
-  StringToDouble(value, &result, locale_dependent);
-  return result;
-}
 
 }  // namespace base
 
@@ -1054,6 +998,17 @@ std::wstring Uint64ToWString(uint64 value) {
       IntToString(value);
 }
 
+std::string DoubleToString(double value) {
+  // According to g_fmt.cc, it is sufficient to declare a buffer of size 32.
+  char buffer[32];
+  dmg_fp::g_fmt(buffer, value);
+  return std::string(buffer);
+}
+
+std::wstring DoubleToWString(double value) {
+  return ASCIIToWide(DoubleToString(value));
+}
+
 inline void StringAppendV(std::string* dst, const char* format, va_list ap) {
   StringAppendVT<char>(dst, format, ap);
 }
@@ -1064,22 +1019,6 @@ inline void StringAppendV(std::wstring* dst,
   StringAppendVT<wchar_t>(dst, format, ap);
 }
 
-bool StringToDouble(const std::string& input, double* output) {
-  return StringToDouble(input, output, base::LOCALE_DEPENDENT);
-}
-
-bool StringToDouble(const std::wstring& input, double* output) {
-  return StringToDouble(input, output, base::LOCALE_DEPENDENT);
-}
-
-double StringToDouble(const std::string& value) {
-  return StringToDouble(value, base::LOCALE_DEPENDENT);
-}
-
-double StringToDouble(const std::wstring& value) {
-  return StringToDouble(value, base::LOCALE_DEPENDENT);
-}
-
 std::string StringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
@@ -1419,36 +1358,33 @@ bool MatchPattern(const std::string& eval, const std::string& pattern) {
 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),
-                                            base::LOCALE_DEPENDENT);
+                                            reinterpret_cast<long*>(output));
 }
 
 bool StringToInt(const std::wstring& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
   return StringToNumber<WStringToLongTraits>(input,
-                                             reinterpret_cast<long*>(output),
-                                             base::LOCALE_DEPENDENT);
+                                             reinterpret_cast<long*>(output));
 }
 
 bool StringToInt64(const std::string& input, int64* output) {
-  return StringToNumber<StringToInt64Traits>(input, output, base::LOCALE_DEPENDENT);
+  return StringToNumber<StringToInt64Traits>(input, output);
 }
 
 bool StringToInt64(const std::wstring& input, int64* output) {
-  return StringToNumber<WStringToInt64Traits>(input, output, base::LOCALE_DEPENDENT);
+  return StringToNumber<WStringToInt64Traits>(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),
-                                               base::LOCALE_DEPENDENT);
+                                               reinterpret_cast<long*>(output));
 }
 
 bool HexStringToInt(const std::wstring& input, int* output) {
   COMPILE_ASSERT(sizeof(int) == sizeof(long), cannot_wcstol_to_int);
   return StringToNumber<HexWStringToLongTraits>(
-      input, reinterpret_cast<long*>(output), base::LOCALE_DEPENDENT);
+      input, reinterpret_cast<long*>(output));
 }
 
 int StringToInt(const std::string& value) {
@@ -1487,6 +1423,26 @@ int HexStringToInt(const std::wstring& value) {
   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);
+}
+
+double StringToDouble(const std::string& value) {
+  double result;
+  StringToDouble(value, &result);
+  return result;
+}
+
+double StringToDouble(const std::wstring& 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