Convert ReplaceStringPlaceholders(std::string...) to take a

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 1405 matching lines @@
                                 std::vector<string16>* result) {
   SplitStringAlongWhitespaceT(str, result);
 }
 #endif
 
 void SplitStringAlongWhitespace(const std::string& str,
                                 std::vector<std::string>* result) {
   SplitStringAlongWhitespaceT(str, result);
 }
 
-template<class StringType>
-StringType DoReplaceStringPlaceholders(const StringType& format_string,
-                                       const std::vector<StringType>& subst,
-                                       std::vector<size_t>* offsets) {
+template<class FormatStringType, class OutStringType>
+OutStringType DoReplaceStringPlaceholders(const FormatStringType& format_string,
+    const std::vector<OutStringType>& subst, std::vector<size_t>* offsets) {
   int substitutions = subst.size();
   DCHECK(substitutions < 10);
 
   int sub_length = 0;
-  for (typename std::vector<StringType>::const_iterator iter = subst.begin();
-       iter != subst.end();
-       ++iter) {
+  for (typename std::vector<OutStringType>::const_iterator iter = subst.begin();
+       iter != subst.end(); ++iter) {
     sub_length += (*iter).length();
   }
 
-  StringType formatted;
+  OutStringType formatted;
   formatted.reserve(format_string.length() + sub_length);
 
   std::vector<ReplacementOffset> r_offsets;
-  for (typename StringType::const_iterator i = format_string.begin();
+  for (typename FormatStringType::const_iterator 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) {
           formatted.push_back('$');
         } else {
           int index = *i - '1';
           if (offsets) {
@@ skipping 20 matching lines @@
   }
   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 std::string& format_string,
+std::string ReplaceStringPlaceholders(const base::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 311 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;
 }