Revert "Revert "ASCII <-> UTF16 conversion functions. These are just copies of WideToASCII and""

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 432 matching lines @@
 std::string WideToASCII(const std::wstring& wide) {
   DCHECK(IsStringASCII(wide));
   return std::string(wide.begin(), wide.end());
 }
 
 std::wstring ASCIIToWide(const std::string& ascii) {
   DCHECK(IsStringASCII(ascii));
   return std::wstring(ascii.begin(), ascii.end());
 }
 
+std::string UTF16ToASCII(const string16& utf16) {
+  DCHECK(IsStringASCII(utf16));
+  return std::string(utf16.begin(), utf16.end());
+}
+
+string16 ASCIIToUTF16(const std::string& ascii) {
+  DCHECK(IsStringASCII(ascii));
+  return string16(ascii.begin(), ascii.end());
+}
+
 // Latin1 is just the low range of Unicode, so we can copy directly to convert.
 bool WideToLatin1(const std::wstring& wide, std::string* latin1) {
   std::string output;
   output.resize(wide.size());
   latin1->clear();
   for (size_t i = 0; i < wide.size(); i++) {
     if (wide[i] > 255)
       return false;
     output[i] = static_cast<char>(wide[i]);
   }
   latin1->swap(output);
   return true;
 }
 
 bool IsString8Bit(const std::wstring& str) {
   for (size_t i = 0; i < str.length(); i++) {
     if (str[i] > 255)
       return false;
   }
   return true;
 }
 
-bool IsStringASCII(const std::wstring& str) {
+template<class STR>
+static bool DoIsStringASCII(const STR& str) {
   for (size_t i = 0; i < str.length(); i++) {
-    if (str[i] > 0x7F)
+    typename ToUnsigned<typename STR::value_type>::Unsigned c = str[i];
+    if (c > 0x7F)
       return false;
   }
   return true;
 }
 
+bool IsStringASCII(const std::wstring& str) {
+  return DoIsStringASCII(str);
+}
+
+#if !defined(WCHAR_T_IS_UTF16)
+bool IsStringASCII(const string16& str) {
+  return DoIsStringASCII(str);
+}
+#endif
+
 bool IsStringASCII(const std::string& str) {
-  for (size_t i = 0; i < str.length(); i++) {
-    if (static_cast<unsigned char>(str[i]) > 0x7F)
-      return false;
-  }
-  return true;
+  return DoIsStringASCII(str);
 }
 
 // Helper functions that determine whether the given character begins a
 // UTF-8 sequence of bytes with the given length. A character satisfies
 // "IsInUTF8Sequence" if it is anything but the first byte in a multi-byte
 // character.
 static inline bool IsBegin2ByteUTF8(int c) {
   return (c & 0xE0) == 0xC0;
 }
 static inline bool IsBegin3ByteUTF8(int c) {
@@ skipping 1107 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;
 }