Move ReplaceStringPlaceholders to base namespace.

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>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <wchar.h>
 #include <wctype.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "build/build_config.h"
 
-// Remove when this entire file is in the base namespace.
-using base::char16;
-using base::string16;
+namespace base {
 
 namespace {
 
 // Force the singleton used by EmptyString[16] to be a unique type. This
 // prevents other code that might accidentally use Singleton<string> from
 // getting our internal one.
 struct EmptyStrings {
   EmptyStrings() {}
   const std::string s;
   const string16 s16;
@@ skipping 30 matching lines @@
 inline bool IsAlignedToMachineWord(const void* pointer) {
   return !(reinterpret_cast<MachineWord>(pointer) & kMachineWordAlignmentMask);
 }
 
 template<typename T> inline T* AlignToMachineWord(T* pointer) {
   return reinterpret_cast<T*>(reinterpret_cast<MachineWord>(pointer) &
                               ~kMachineWordAlignmentMask);
 }
 
 template<size_t size, typename CharacterType> struct NonASCIIMask;
-template<> struct NonASCIIMask<4, base::char16> {
+template<> struct NonASCIIMask<4, char16> {
     static inline uint32_t value() { return 0xFF80FF80U; }
 };
 template<> struct NonASCIIMask<4, char> {
     static inline uint32_t value() { return 0x80808080U; }
 };
-template<> struct NonASCIIMask<8, base::char16> {
+template<> struct NonASCIIMask<8, char16> {
     static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
 };
 template<> struct NonASCIIMask<8, char> {
     static inline uint64_t value() { return 0x8080808080808080ULL; }
 };
 #if defined(WCHAR_T_IS_UTF32)
 template<> struct NonASCIIMask<4, wchar_t> {
     static inline uint32_t value() { return 0xFFFFFF80U; }
 };
 template<> struct NonASCIIMask<8, wchar_t> {
     static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
 };
 #endif  // WCHAR_T_IS_UTF32
 
 // DO NOT USE. http://crbug.com/24917
 //
 // tolower() will given incorrect results for non-ASCII characters. Use the
 // ASCII version, base::i18n::ToLower, or base::i18n::FoldCase. This is here
 // for backwards-compat for StartsWith until such calls can be updated.
 struct CaseInsensitiveCompareDeprecated {
  public:
   bool operator()(char16 x, char16 y) const {
     return tolower(x) == tolower(y);
   }
 };
 
 }  // namespace
 
-namespace base {
-
 bool IsWprintfFormatPortable(const wchar_t* format) {
   for (const wchar_t* position = format; *position != '\0'; ++position) {
     if (*position == '%') {
       bool in_specification = true;
       bool modifier_l = false;
       while (in_specification) {
         // Eat up characters until reaching a known specifier.
         if (*++position == '\0') {
           // The format string ended in the middle of a specification.  Call
           // it portable because no unportable specifications were found.  The
@@ skipping 42 matching lines @@
   // End of one string hit before finding a different character. Expect the
   // common case to be "strings equal" at this point so check that first.
   if (a.length() == b.length())
     return 0;
 
   if (a.length() < b.length())
     return -1;
   return 1;
 }
 
-int CompareCaseInsensitiveASCII(base::StringPiece a, base::StringPiece b) {
+int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b) {
   return CompareCaseInsensitiveASCIIT<std::string>(a, b);
 }
 
-int CompareCaseInsensitiveASCII(base::StringPiece16 a, base::StringPiece16 b) {
-  return CompareCaseInsensitiveASCIIT<base::string16>(a, b);
+int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
+  return CompareCaseInsensitiveASCIIT<string16>(a, b);
 }
 
-bool EqualsCaseInsensitiveASCII(base::StringPiece a, base::StringPiece b) {
+bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
   if (a.length() != b.length())
     return false;
   return CompareCaseInsensitiveASCIIT<std::string>(a, b) == 0;
 }
 
-bool EqualsCaseInsensitiveASCII(base::StringPiece16 a, base::StringPiece16 b) {
+bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
   if (a.length() != b.length())
     return false;
-  return CompareCaseInsensitiveASCIIT<base::string16>(a, b) == 0;
+  return CompareCaseInsensitiveASCIIT<string16>(a, b) == 0;
 }
 
 const std::string& EmptyString() {
   return EmptyStrings::GetInstance()->s;
 }
 
 const string16& EmptyString16() {
   return EmptyStrings::GetInstance()->s16;
 }
 
@@ skipping 11 matching lines @@
   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 base::StringPiece16& replace_chars,
+                  const StringPiece16& replace_chars,
                   const string16& replace_with,
                   string16* output) {
   return ReplaceCharsT(input, replace_chars.as_string(), replace_with, output);
 }
 
 bool ReplaceChars(const std::string& input,
-                  const base::StringPiece& replace_chars,
+                  const StringPiece& replace_chars,
                   const std::string& replace_with,
                   std::string* output) {
   return ReplaceCharsT(input, replace_chars.as_string(), replace_with, output);
 }
 
 bool RemoveChars(const string16& input,
-                 const base::StringPiece16& remove_chars,
+                 const StringPiece16& remove_chars,
                  string16* output) {
   return ReplaceChars(input, remove_chars.as_string(), string16(), output);
 }
 
 bool RemoveChars(const std::string& input,
-                 const base::StringPiece& remove_chars,
+                 const StringPiece& remove_chars,
                  std::string* output) {
   return ReplaceChars(input, remove_chars.as_string(), std::string(), output);
 }
 
 template<typename Str>
 TrimPositions TrimStringT(const Str& input,
                           BasicStringPiece<Str> trim_chars,
                           TrimPositions positions,
                           Str* output) {
   // Find the edges of leading/trailing whitespace as desired. Need to use
@@ skipping 21 matching lines @@
   *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,
-                base::StringPiece16 trim_chars,
+                StringPiece16 trim_chars,
                 string16* output) {
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
 
 bool TrimString(const std::string& input,
-                base::StringPiece trim_chars,
+                StringPiece trim_chars,
                 std::string* output) {
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
 
 template<typename Str>
 BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
                                        BasicStringPiece<Str> trim_chars,
                                        TrimPositions positions) {
   size_t begin = (positions & TRIM_LEADING) ?
       input.find_first_not_of(trim_chars) : 0;
   size_t end = (positions & TRIM_TRAILING) ?
       input.find_last_not_of(trim_chars) + 1 : input.size();
   return input.substr(begin, end - begin);
 }
 
 StringPiece16 TrimString(StringPiece16 input,
-                         const base::StringPiece16& trim_chars,
+                         const StringPiece16& trim_chars,
                          TrimPositions positions) {
   return TrimStringPieceT(input, trim_chars, positions);
 }
 
 StringPiece TrimString(StringPiece input,
-                       const base::StringPiece& trim_chars,
+                       const StringPiece& trim_chars,
                        TrimPositions positions) {
   return TrimStringPieceT(input, trim_chars, positions);
 }
 
 void TruncateUTF8ToByteSize(const std::string& input,
                             const size_t byte_size,
                             std::string* output) {
   DCHECK(output);
   if (byte_size > input.length()) {
     *output = input;
@@ skipping 252 matching lines @@
   BasicStringPiece<Str> source = str.substr(0, search_for.size());
 
   switch (case_sensitivity) {
     case CompareCase::SENSITIVE:
       return source == search_for;
 
     case CompareCase::INSENSITIVE_ASCII:
       return std::equal(
           search_for.begin(), search_for.end(),
           source.begin(),
-          base::CaseInsensitiveCompareASCII<typename Str::value_type>());
+          CaseInsensitiveCompareASCII<typename Str::value_type>());
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool StartsWith(StringPiece str,
                 StringPiece search_for,
                 CompareCase case_sensitivity) {
@@ skipping 34 matching lines @@
                                             search_for.size());
 
   switch (case_sensitivity) {
     case CompareCase::SENSITIVE:
       return source == search_for;
 
     case CompareCase::INSENSITIVE_ASCII:
       return std::equal(
           source.begin(), source.end(),
           search_for.begin(),
-          base::CaseInsensitiveCompareASCII<typename Str::value_type>());
+          CaseInsensitiveCompareASCII<typename Str::value_type>());
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool EndsWith(StringPiece str,
               StringPiece search_for,
               CompareCase case_sensitivity) {
@@ skipping 212 matching lines @@
   DCHECK_GT(length_with_null, 1u);
   str->reserve(length_with_null);
   str->resize(length_with_null - 1);
   return &((*str)[0]);
 }
 
 char* WriteInto(std::string* str, size_t length_with_null) {
   return WriteIntoT(str, length_with_null);
 }
 
-char16* WriteInto(base::string16* str, size_t length_with_null) {
+char16* WriteInto(string16* str, size_t length_with_null) {
   return WriteIntoT(str, length_with_null);
 }
 
 template<typename STR>
 static STR JoinStringT(const std::vector<STR>& parts,
                        BasicStringPiece<STR> sep) {
   if (parts.empty())
     return STR();
 
   STR result(parts[0]);
@@ skipping 11 matching lines @@
 std::string JoinString(const std::vector<std::string>& parts,
                        StringPiece separator) {
   return JoinStringT(parts, separator);
 }
 
 string16 JoinString(const std::vector<string16>& parts,
                     StringPiece16 separator) {
   return JoinStringT(parts, separator);
 }
 
-}  // namespace base
-
 template<class FormatStringType, class OutStringType>
-OutStringType DoReplaceStringPlaceholders(const FormatStringType& format_string,
-    const std::vector<OutStringType>& subst, std::vector<size_t>* offsets) {
+OutStringType DoReplaceStringPlaceholders(
+    const FormatStringType& format_string,
+    const std::vector<OutStringType>& subst,
+    std::vector<size_t>* offsets) {
   size_t substitutions = subst.size();
 
   size_t sub_length = 0;
-  for (typename std::vector<OutStringType>::const_iterator iter = subst.begin();
-       iter != subst.end(); ++iter) {
-    sub_length += iter->length();
-  }
+  for (const auto& cur : subst)
+    sub_length += cur.length();
 
   OutStringType formatted;
   formatted.reserve(format_string.length() + sub_length);
 
   std::vector<ReplacementOffset> r_offsets;
-  for (typename FormatStringType::const_iterator i = format_string.begin();
-       i != format_string.end(); ++i) {
+  for (auto i = format_string.begin(); i != format_string.end(); ++i) {
     if ('$' == *i) {
       if (i + 1 != format_string.end()) {
         ++i;
         DCHECK('$' == *i || '1' <= *i) << "Invalid placeholder: " << *i;
         if ('$' == *i) {
           while (i != format_string.end() && '$' == *i) {
             formatted.push_back('$');
             ++i;
           }
           --i;
@@ skipping 17 matching lines @@
           }
           if (index < substitutions)
             formatted.append(subst.at(index));
         }
       }
     } else {
       formatted.push_back(*i);
     }
   }
   if (offsets) {
-    for (std::vector<ReplacementOffset>::const_iterator i = r_offsets.begin();
-         i != r_offsets.end(); ++i) {
-      offsets->push_back(i->offset);
-    }
+    for (const auto& cur : r_offsets)
+      offsets->push_back(cur.offset);
   }
   return formatted;
 }
 
 string16 ReplaceStringPlaceholders(const string16& format_string,
                                    const std::vector<string16>& subst,
                                    std::vector<size_t>* offsets) {
   return DoReplaceStringPlaceholders(format_string, subst, offsets);
 }
 
-std::string ReplaceStringPlaceholders(const base::StringPiece& format_string,
+std::string ReplaceStringPlaceholders(const StringPiece& format_string,
                                       const std::vector<std::string>& subst,
                                       std::vector<size_t>* offsets) {
   return DoReplaceStringPlaceholders(format_string, subst, offsets);
 }
 
 string16 ReplaceStringPlaceholders(const string16& format_string,
                                    const string16& a,
                                    size_t* offset) {
   std::vector<size_t> offsets;
   std::vector<string16> subst;
@@ skipping 23 matching lines @@
   if (dst_size != 0)
     dst[dst_size - 1] = 0;
 
   // Count the rest of the |src|, and return it's length in characters.
   while (src[dst_size]) ++dst_size;
   return dst_size;
 }
 
 }  // namespace
 
-size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
+size_t 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) {
+size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }
+
+}  // namespace base