Make various string_util functions take StringPieces instead of char[].

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 100 matching lines @@
 const std::wstring& EmptyWString() {
   return EmptyStrings::GetInstance()->ws;
 }
 
 const string16& EmptyString16() {
   return EmptyStrings::GetInstance()->s16;
 }
 
 template<typename STR>
 bool ReplaceCharsT(const STR& input,
-                   const typename STR::value_type replace_chars[],
+                   const STR& replace_chars,
                    const STR& replace_with,
                    STR* output) {
   bool removed = false;
   size_t replace_length = replace_with.length();
 
   *output = input;
 
   size_t found = output->find_first_of(replace_chars);
   while (found != STR::npos) {
     removed = true;
     output->replace(found, 1, replace_with);
     found = output->find_first_of(replace_chars, found + replace_length);
   }
 
   return removed;
 }
 
 bool ReplaceChars(const string16& input,
-                  const char16 replace_chars[],
+                  const base::StringPiece16& replace_chars,
                   const string16& replace_with,
                   string16* output) {
-  return ReplaceCharsT(input, replace_chars, replace_with, output);
+  return ReplaceCharsT(input, replace_chars.as_string(), replace_with, output);
 }
 
 bool ReplaceChars(const std::string& input,
-                  const char replace_chars[],
+                  const base::StringPiece& replace_chars,
                   const std::string& replace_with,
                   std::string* output) {
-  return ReplaceCharsT(input, replace_chars, replace_with, output);
+  return ReplaceCharsT(input, replace_chars.as_string(), replace_with, output);
 }
 
 bool RemoveChars(const string16& input,
-                 const char16 remove_chars[],
+                 const base::StringPiece16& remove_chars,
                  string16* output) {
-  return ReplaceChars(input, remove_chars, string16(), output);
+  return ReplaceChars(input, remove_chars.as_string(), string16(), output);
 }
 
 bool RemoveChars(const std::string& input,
-                 const char remove_chars[],
+                 const base::StringPiece& remove_chars,
                  std::string* output) {
-  return ReplaceChars(input, remove_chars, std::string(), output);
+  return ReplaceChars(input, remove_chars.as_string(), std::string(), output);
 }
 
 template<typename STR>
 TrimPositions TrimStringT(const STR& input,
-                          const typename STR::value_type trim_chars[],
+                          const STR& trim_chars,
                           TrimPositions positions,
                           STR* output) {
   // Find the edges of leading/trailing whitespace as desired.
-  const typename STR::size_type last_char = input.length() - 1;
-  const typename STR::size_type first_good_char = (positions & TRIM_LEADING) ?
+  const size_t last_char = input.length() - 1;
+  const size_t first_good_char = (positions & TRIM_LEADING) ?
       input.find_first_not_of(trim_chars) : 0;
-  const typename STR::size_type last_good_char = (positions & TRIM_TRAILING) ?
+  const size_t last_good_char = (positions & TRIM_TRAILING) ?
       input.find_last_not_of(trim_chars) : last_char;
 
   // When the string was all whitespace, report that we stripped off whitespace
   // from whichever position the caller was interested in.  For empty input, we
   // stripped no whitespace, but we still need to clear |output|.
   if (input.empty() ||
       (first_good_char == STR::npos) || (last_good_char == STR::npos)) {
     bool input_was_empty = input.empty();  // in case output == &input
     output->clear();
     return input_was_empty ? TRIM_NONE : positions;
   }
 
   // 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 string16& input,
-                const char16 trim_chars[],
+                const base::StringPiece16& trim_chars,
                 string16* output) {
-  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
+  return TrimStringT(input, trim_chars.as_string(), TRIM_ALL, output) !=
+      TRIM_NONE;
 }
 
 bool TrimString(const std::string& input,
-                const char trim_chars[],
+                const base::StringPiece& trim_chars,
                 std::string* output) {
-  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
+  return TrimStringT(input, trim_chars.as_string(), TRIM_ALL, output) !=
+      TRIM_NONE;
 }
 
 void TruncateUTF8ToByteSize(const std::string& input,
                             const size_t byte_size,
                             std::string* output) {
   DCHECK(output);
   if (byte_size > input.length()) {
     *output = input;
     return;
   }
@@ skipping 21 matching lines @@
 
   if (char_index >= 0 )
     *output = input.substr(0, char_index);
   else
     output->clear();
 }
 
 TrimPositions TrimWhitespace(const string16& input,
                              TrimPositions positions,
                              string16* output) {
-  return TrimStringT(input, kWhitespaceUTF16, positions, output);
+  return TrimStringT(input, base::string16(kWhitespaceUTF16), positions,
+                     output);
 }
 
 TrimPositions TrimWhitespaceASCII(const std::string& input,
                                   TrimPositions positions,
                                   std::string* output) {
-  return TrimStringT(input, kWhitespaceASCII, positions, output);
+  return TrimStringT(input, std::string(kWhitespaceASCII), positions, output);
 }
 
 // This function is only for backward-compatibility.
 // To be removed when all callers are updated.
 TrimPositions TrimWhitespace(const std::string& input,
                              TrimPositions positions,
                              std::string* output) {
   return TrimWhitespaceASCII(input, positions, output);
 }
 
@@ skipping 168 matching lines @@
   }
 }
 
 bool StartsWith(const string16& str, const string16& search,
                 bool case_sensitive) {
   return StartsWithT(str, search, case_sensitive);
 }
 
 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();
+  size_t str_length = str.length();
+  size_t search_length = search.length();
   if (search_length > str_length)
     return false;
-  if (case_sensitive) {
+  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>());
-  }
+  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 string16& str, const string16& search,
               bool case_sensitive) {
   return EndsWithT(str, search, case_sensitive);
@@ skipping 25 matching lines @@
   } else {
     base::snprintf(buf, arraysize(buf), "%.0lf%s", unit_amount,
                    kByteStringsUnlocalized[dimension]);
   }
 
   return base::ASCIIToUTF16(buf);
 }
 
 template<class StringType>
 void DoReplaceSubstringsAfterOffset(StringType* str,
-                                    typename StringType::size_type start_offset,
+                                    size_t start_offset,
                                     const StringType& find_this,
                                     const StringType& replace_with,
                                     bool replace_all) {
   if ((start_offset == StringType::npos) || (start_offset >= str->length()))
     return;
 
   DCHECK(!find_this.empty());
-  for (typename StringType::size_type offs(str->find(find_this, start_offset));
+  for (size_t offs(str->find(find_this, start_offset));
       offs != StringType::npos; offs = str->find(find_this, offs)) {
     str->replace(offs, find_this.length(), replace_with);
     offs += replace_with.length();
 
     if (!replace_all)
       break;
   }
 }
 
 void ReplaceFirstSubstringAfterOffset(string16* str,
-                                      string16::size_type start_offset,
+                                      size_t start_offset,
                                       const string16& find_this,
                                       const string16& replace_with) {
   DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
                                  false);  // replace first instance
 }
 
 void ReplaceFirstSubstringAfterOffset(std::string* str,
-                                      std::string::size_type start_offset,
+                                      size_t start_offset,
                                       const std::string& find_this,
                                       const std::string& replace_with) {
   DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
                                  false);  // replace first instance
 }
 
 void ReplaceSubstringsAfterOffset(string16* str,
-                                  string16::size_type start_offset,
+                                  size_t start_offset,
                                   const string16& find_this,
                                   const string16& replace_with) {
   DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
                                  true);  // replace all instances
 }
 
 void ReplaceSubstringsAfterOffset(std::string* str,
-                                  std::string::size_type start_offset,
+                                  size_t start_offset,
                                   const std::string& find_this,
                                   const std::string& replace_with) {
   DoReplaceSubstringsAfterOffset(str, start_offset, find_this, replace_with,
                                  true);  // replace all instances
 }
 
 
 template<typename STR>
 static size_t TokenizeT(const STR& str,
                         const STR& delimiters,
                         std::vector<STR>* tokens) {
   tokens->clear();
 
-  typename STR::size_type start = str.find_first_not_of(delimiters);
+  size_t start = str.find_first_not_of(delimiters);
   while (start != STR::npos) {
-    typename STR::size_type end = str.find_first_of(delimiters, start + 1);
+    size_t end = str.find_first_of(delimiters, start + 1);
     if (end == STR::npos) {
       tokens->push_back(str.substr(start));
       break;
     } else {
       tokens->push_back(str.substr(start, end - start));
       start = str.find_first_not_of(delimiters, end + 1);
     }
   }
 
   return tokens->size();
@@ skipping 318 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);
 }