Cleanup: Remove many unused wstring string_utils.

base/strings/string_util.cc

 // Copyright 2013 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/strings/string_util.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h>
@@ skipping 175 matching lines @@
   // Trim the whitespace.
   *output =
       input.substr(first_good_char, last_good_char - first_good_char + 1);
 
   // Return where we trimmed from.
   return static_cast<TrimPositions>(
       ((first_good_char == 0) ? TRIM_NONE : TRIM_LEADING) |
       ((last_good_char == last_char) ? TRIM_NONE : TRIM_TRAILING));
 }
 
-bool TrimString(const std::wstring& input,
-                const wchar_t trim_chars[],
-                std::wstring* output) {
-  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
-}
-
-#if !defined(WCHAR_T_IS_UTF16)
 bool TrimString(const string16& input,
                 const char16 trim_chars[],
                 string16* output) {
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
-#endif
 
 bool TrimString(const std::string& input,
                 const char trim_chars[],
                 std::string* output) {
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
 
 void TruncateUTF8ToByteSize(const std::string& input,
                             const size_t byte_size,
                             std::string* output) {
@@ skipping 85 matching lines @@
 
   if (in_whitespace && !already_trimmed) {
     // Any trailing whitespace is eliminated.
     --chars_written;
   }
 
   result.resize(chars_written);
   return result;
 }
 
-std::wstring CollapseWhitespace(const std::wstring& text,
-                                bool trim_sequences_with_line_breaks) {
-  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
-}
-
-#if !defined(WCHAR_T_IS_UTF16)
 string16 CollapseWhitespace(const string16& text,
                             bool trim_sequences_with_line_breaks) {
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
-#endif
 
 std::string CollapseWhitespaceASCII(const std::string& text,
                                     bool trim_sequences_with_line_breaks) {
   return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
 }
 
 bool ContainsOnlyWhitespaceASCII(const std::string& str) {
   for (std::string::const_iterator i(str.begin()); i != str.end(); ++i) {
     if (!IsAsciiWhitespace(*i))
       return false;
   }
   return true;
 }
 
 bool ContainsOnlyWhitespace(const string16& str) {
   return str.find_first_not_of(kWhitespaceUTF16) == string16::npos;
 }
 
 template<typename STR>
 static bool ContainsOnlyCharsT(const STR& input, const STR& characters) {
   for (typename STR::const_iterator iter = input.begin();
        iter != input.end(); ++iter) {
     if (characters.find(*iter) == STR::npos)
       return false;
   }
   return true;
 }
 
-bool ContainsOnlyChars(const std::wstring& input,
-                       const std::wstring& characters) {
-  return ContainsOnlyCharsT(input, characters);
-}
-
-#if !defined(WCHAR_T_IS_UTF16)
 bool ContainsOnlyChars(const string16& input, const string16& characters) {
   return ContainsOnlyCharsT(input, characters);
 }
-#endif
 
 bool ContainsOnlyChars(const std::string& input,
                        const std::string& characters) {
   return ContainsOnlyCharsT(input, characters);
 }
 
+#if !defined(WCHAR_T_IS_UTF16)
+bool IsStringASCII(const std::wstring& str);
+#endif
+
 std::string WideToASCII(const std::wstring& wide) {
   DCHECK(IsStringASCII(wide)) << wide;
   return std::string(wide.begin(), wide.end());
 }
 
 std::string UTF16ToASCII(const string16& utf16) {
   DCHECK(IsStringASCII(utf16)) << utf16;
   return std::string(utf16.begin(), utf16.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;
-}
-
 template<class STR>
 static bool DoIsStringASCII(const STR& str) {
   for (size_t i = 0; i < str.length(); i++) {
     typename ToUnsigned<typename STR::value_type>::Unsigned c = str[i];
     if (c > 0x7F)
       return false;
   }
   return true;
 }
 
+#if !defined(WCHAR_T_IS_UTF16)
 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 string16& str) {
+  return DoIsStringASCII(str);
+}
+
 bool IsStringASCII(const base::StringPiece& str) {
   return DoIsStringASCII(str);
 }
 
 bool IsStringUTF8(const std::string& str) {
   const char *src = str.data();
   int32 src_len = static_cast<int32>(str.length());
   int32 char_index = 0;
 
   while (char_index < src_len) {
@@ skipping 14 matching lines @@
       return false;
   }
   return *b == 0;
 }
 
 // Front-ends for LowerCaseEqualsASCII.
 bool LowerCaseEqualsASCII(const std::string& a, const char* b) {
   return DoLowerCaseEqualsASCII(a.begin(), a.end(), b);
 }
 
-bool LowerCaseEqualsASCII(const std::wstring& a, const char* b) {
+bool LowerCaseEqualsASCII(const string16& a, const char* b) {
   return DoLowerCaseEqualsASCII(a.begin(), a.end(), b);
 }
 
-#if !defined(WCHAR_T_IS_UTF16)
-bool LowerCaseEqualsASCII(const string16& a, const char* b) {
-  return DoLowerCaseEqualsASCII(a.begin(), a.end(), b);
-}
-#endif
-
 bool LowerCaseEqualsASCII(std::string::const_iterator a_begin,
                           std::string::const_iterator a_end,
                           const char* b) {
   return DoLowerCaseEqualsASCII(a_begin, a_end, b);
 }
 
-bool LowerCaseEqualsASCII(std::wstring::const_iterator a_begin,
-                          std::wstring::const_iterator a_end,
-                          const char* b) {
-  return DoLowerCaseEqualsASCII(a_begin, a_end, b);
-}
-
-#if !defined(WCHAR_T_IS_UTF16)
 bool LowerCaseEqualsASCII(string16::const_iterator a_begin,
                           string16::const_iterator a_end,
                           const char* b) {
   return DoLowerCaseEqualsASCII(a_begin, a_end, b);
 }
-#endif
 
 // TODO(port): Resolve wchar_t/iterator issues that require OS_ANDROID here.
 #if !defined(OS_ANDROID)
 bool LowerCaseEqualsASCII(const char* a_begin,
                           const char* a_end,
                           const char* b) {
   return DoLowerCaseEqualsASCII(a_begin, a_end, b);
 }
 
-bool LowerCaseEqualsASCII(const wchar_t* a_begin,
-                          const wchar_t* a_end,
-                          const char* b) {
-  return DoLowerCaseEqualsASCII(a_begin, a_end, b);
-}
-
-#if !defined(WCHAR_T_IS_UTF16)
 bool LowerCaseEqualsASCII(const char16* a_begin,
                           const char16* a_end,
                           const char* b) {
   return DoLowerCaseEqualsASCII(a_begin, a_end, b);
 }
-#endif
 
 #endif  // !defined(OS_ANDROID)
 
 bool EqualsASCII(const string16& a, const base::StringPiece& b) {
   if (a.length() != b.length())
     return false;
   return std::equal(b.begin(), b.end(), a.begin());
 }
 
 bool StartsWithASCII(const std::string& str,
@@ skipping 10 matching lines @@
   if (case_sensitive) {
     return str.compare(0, search.length(), search) == 0;
   } else {
     if (search.size() > str.size())
       return false;
     return std::equal(search.begin(), search.end(), str.begin(),
                       base::CaseInsensitiveCompare<typename STR::value_type>());
   }
 }
 
-bool StartsWith(const std::wstring& str, const std::wstring& search,
+bool StartsWith(const string16& str, const string16& search,
                 bool case_sensitive) {
   return StartsWithT(str, search, case_sensitive);
 }
 
-#if !defined(WCHAR_T_IS_UTF16)
-bool StartsWith(const string16& str, const string16& search,
-                bool case_sensitive) {
-  return StartsWithT(str, search, case_sensitive);
-}
-#endif
-
 template <typename STR>
 bool EndsWithT(const STR& str, const STR& search, bool case_sensitive) {
   typename STR::size_type str_length = str.length();
   typename STR::size_type search_length = search.length();
   if (search_length > str_length)
     return false;
   if (case_sensitive) {
     return str.compare(str_length - search_length, search_length, search) == 0;
   } else {
     return std::equal(search.begin(), search.end(),
                       str.begin() + (str_length - search_length),
                       base::CaseInsensitiveCompare<typename STR::value_type>());
   }
 }
 
 bool EndsWith(const std::string& str, const std::string& search,
               bool case_sensitive) {
   return EndsWithT(str, search, case_sensitive);
 }
 
-bool EndsWith(const std::wstring& str, const std::wstring& search,
+bool EndsWith(const string16& str, const string16& search,
               bool case_sensitive) {
   return EndsWithT(str, search, case_sensitive);
 }
 
-#if !defined(WCHAR_T_IS_UTF16)
-bool EndsWith(const string16& str, const string16& search,
-              bool case_sensitive) {
-  return EndsWithT(str, search, case_sensitive);
-}
-#endif
-
 static const char* const kByteStringsUnlocalized[] = {
   " B",
   " kB",
   " MB",
   " GB",
   " TB",
   " PB"
 };
 
 string16 FormatBytesUnlocalized(int64 bytes) {
@@ skipping 85 matching lines @@
       break;
     } else {
       tokens->push_back(str.substr(start, end - start));
       start = str.find_first_not_of(delimiters, end + 1);
     }
   }
 
   return tokens->size();
 }
 
-size_t Tokenize(const std::wstring& str,
-                const std::wstring& delimiters,
-                std::vector<std::wstring>* tokens) {
-  return TokenizeT(str, delimiters, tokens);
-}
-
-#if !defined(WCHAR_T_IS_UTF16)
 size_t Tokenize(const string16& str,
                 const string16& delimiters,
                 std::vector<string16>* tokens) {
   return TokenizeT(str, delimiters, tokens);
 }
-#endif
 
 size_t Tokenize(const std::string& str,
                 const std::string& delimiters,
                 std::vector<std::string>* tokens) {
   return TokenizeT(str, delimiters, tokens);
 }
 
 size_t Tokenize(const base::StringPiece& str,
                 const base::StringPiece& delimiters,
                 std::vector<base::StringPiece>* tokens) {
@@ skipping 110 matching lines @@
 }
 
 string16 ReplaceStringPlaceholders(const string16& format_string,
                                    const string16& a,
                                    size_t* offset) {
   std::vector<size_t> offsets;
   std::vector<string16> subst;
   subst.push_back(a);
   string16 result = ReplaceStringPlaceholders(format_string, subst, &offsets);
 
-  DCHECK(offsets.size() == 1);
-  if (offset) {
+  DCHECK_EQ(1U, offsets.size());
+  if (offset)
     *offset = offsets[0];
-  }
   return result;
 }
 
 static bool IsWildcard(base_icu::UChar32 character) {
   return character == '*' || character == '?';
 }
 
 // Move the strings pointers to the point where they start to differ.
 template <typename CHAR, typename NEXT>
 static void EatSameChars(const CHAR** pattern, const CHAR* pattern_end,
@@ skipping 168 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }