Remove base::StackString.

tools/gn/escape.cc

 // Copyright (c) 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 "tools/gn/escape.h"
 
 #include <stddef.h>
 
-#include "base/containers/stack_container.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 
 namespace {
 
 // A "1" in this lookup table means that char is valid in the Posix shell.
 const char kShellValid[0x80] = {
 // 00-1f: all are invalid
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 // ' ' !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
 //  0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0,
 //  @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 //  P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
 //  `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o
     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 //  p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0 };
 
 // Append one character to the given string, escaping it for Ninja.
 //
 // Ninja's escaping rules are very simple. We always escape colons even
 // though they're OK in many places, in case the resulting string is used on
 // the left-hand-side of a rule.
-template<typename DestString>
-inline void NinjaEscapeChar(char ch, DestString* dest) {
+inline void NinjaEscapeChar(char ch, std::string* dest) {
   if (ch == '$' || ch == ' ' || ch == ':')
     dest->push_back('$');
   dest->push_back(ch);
 }
 
-template<typename DestString>
 void EscapeStringToString_Ninja(const base::StringPiece& str,
                                 const EscapeOptions& options,
-                                DestString* dest,
+                                std::string* dest,
                                 bool* needed_quoting) {
   for (const auto& elem : str)
     NinjaEscapeChar(elem, dest);
 }
 
-template<typename DestString>
 void EscapeStringToString_NinjaPreformatted(const base::StringPiece& str,
-                                            DestString* dest) {
+                                            std::string* dest) {
   // Only Ninja-escape $.
   for (const auto& elem : str) {
     if (elem == '$')
       dest->push_back('$');
     dest->push_back(elem);
   }
 }
 
 // Escape for CommandLineToArgvW and additionally escape Ninja characters.
 //
 // The basic algorithm is if the string doesn't contain any parse-affecting
 // characters, don't do anything (other than the Ninja processing). If it does,
 // quote the string, and backslash-escape all quotes and backslashes.
 // See:
 //   http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx
 //   http://blogs.msdn.com/b/oldnewthing/archive/2010/09/17/10063629.aspx
-template<typename DestString>
 void EscapeStringToString_WindowsNinjaFork(const base::StringPiece& str,
                                            const EscapeOptions& options,
-                                           DestString* dest,
+                                           std::string* dest,
                                            bool* needed_quoting) {
   // We assume we don't have any whitespace chars that aren't spaces.
   DCHECK(str.find_first_of("\r\n\v\t") == std::string::npos);
 
   if (str.find_first_of(" \"") == std::string::npos) {
     // Simple case, don't quote.
     EscapeStringToString_Ninja(str, options, dest, needed_quoting);
   } else {
     if (!options.inhibit_quoting)
       dest->push_back('"');
@@ skipping 22 matching lines @@
       }
     }
 
     if (!options.inhibit_quoting)
       dest->push_back('"');
     if (needed_quoting)
       *needed_quoting = true;
   }
 }
 
-template<typename DestString>
 void EscapeStringToString_PosixNinjaFork(const base::StringPiece& str,
                                          const EscapeOptions& options,
-                                         DestString* dest,
+                                         std::string* dest,
                                          bool* needed_quoting) {
   for (const auto& elem : str) {
     if (elem == '$' || elem == ' ') {
       // Space and $ are special to both Ninja and the shell. '$' escape for
       // Ninja, then backslash-escape for the shell.
       dest->push_back('\\');
       dest->push_back('$');
       dest->push_back(elem);
     } else if (elem == ':') {
       // Colon is the only other Ninja special char, which is not special to
       // the shell.
       dest->push_back('$');
       dest->push_back(':');
     } else if (static_cast<unsigned>(elem) >= 0x80 ||
                !kShellValid[static_cast<int>(elem)]) {
       // All other invalid shell chars get backslash-escaped.
       dest->push_back('\\');
       dest->push_back(elem);
     } else {
       // Everything else is a literal.
       dest->push_back(elem);
     }
   }
 }
 
-template<typename DestString>
 void EscapeStringToString(const base::StringPiece& str,
                           const EscapeOptions& options,
-                          DestString* dest,
+                          std::string* dest,
                           bool* needed_quoting) {
   switch (options.mode) {
     case ESCAPE_NONE:
       dest->append(str.data(), str.size());
       break;
     case ESCAPE_NINJA:
       EscapeStringToString_Ninja(str, options, dest, needed_quoting);
       break;
     case ESCAPE_NINJA_COMMAND:
       switch (options.platform) {
@@ skipping 33 matching lines @@
                          bool* needed_quoting) {
   std::string result;
   result.reserve(str.size() + 4);  // Guess we'll add a couple of extra chars.
   EscapeStringToString(str, options, &result, needed_quoting);
   return result;
 }
 
 void EscapeStringToStream(std::ostream& out,
                           const base::StringPiece& str,
                           const EscapeOptions& options) {
-  base::StackString<256> escaped;
-  EscapeStringToString(str, options, &escaped.container(), nullptr);
-  if (!escaped->empty())
-    out.write(escaped->data(), escaped->size());
+  std::string escaped;
+  EscapeStringToString(str, options, &escaped, nullptr);
+  if (!escaped.empty())
+    out.write(escaped.data(), escaped.size());
 }