Remove base::StackString.

base/containers/stack_container.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_CONTAINERS_STACK_CONTAINER_H_
 #define BASE_CONTAINERS_STACK_CONTAINER_H_
 
 #include <stddef.h>
 
-#include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
-#include "base/strings/string16.h"
 #include "build/build_config.h"
 
 namespace base {
 
 // This allocator can be used with STL containers to provide a stack buffer
 // from which to allocate memory and overflows onto the heap. This stack buffer
 // would be allocated on the stack and allows us to avoid heap operations in
 // some situations.
 //
 // STL likes to make copies of allocators, so the allocator itself can't hold
@@ skipping 100 matching lines @@
 
  private:
   Source* source_;
 };
 
 // A wrapper around STL containers that maintains a stack-sized buffer that the
 // initial capacity of the vector is based on. Growing the container beyond the
 // stack capacity will transparently overflow onto the heap. The container must
 // support reserve().
 //
+// This will not work with std::string since some implementations allocate
+// more bytes than requested in calls to reserve(), forcing the allocation onto
+// the heap.  http://crbug.com/709273
+//
 // WATCH OUT: the ContainerType MUST use the proper StackAllocator for this
 // type. This object is really intended to be used only internally. You'll want
 // to use the wrappers below for different types.
 template<typename TContainerType, int stack_capacity>
 class StackContainer {
  public:
   typedef TContainerType ContainerType;
   typedef typename ContainerType::value_type ContainedType;
   typedef StackAllocator<ContainedType, stack_capacity> Allocator;
 
@@ skipping 29 matching lines @@
 
  protected:
   typename Allocator::Source stack_data_;
   Allocator allocator_;
   ContainerType container_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StackContainer);
 };
 
-// StackString -----------------------------------------------------------------
-
-template<size_t stack_capacity>
-class StackString : public StackContainer<
-    std::basic_string<char,
-                      std::char_traits<char>,
-                      StackAllocator<char, stack_capacity> >,
-    stack_capacity> {
- public:
-  StackString() : StackContainer<
-      std::basic_string<char,
-                        std::char_traits<char>,
-                        StackAllocator<char, stack_capacity> >,
-      stack_capacity>() {
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(StackString);
-};
-
-// StackStrin16 ----------------------------------------------------------------
-
-template<size_t stack_capacity>
-class StackString16 : public StackContainer<
-    std::basic_string<char16,
-                      base::string16_char_traits,
-                      StackAllocator<char16, stack_capacity> >,
-    stack_capacity> {
- public:
-  StackString16() : StackContainer<
-      std::basic_string<char16,
-                        base::string16_char_traits,
-                        StackAllocator<char16, stack_capacity> >,
-      stack_capacity>() {
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(StackString16);
-};
-
 // StackVector -----------------------------------------------------------------
 
 // Example:
 //   StackVector<int, 16> foo;
 //   foo->push_back(22);  // we have overloaded operator->
 //   foo[0] = 10;         // as well as operator[]
 template<typename T, size_t stack_capacity>
 class StackVector : public StackContainer<
     std::vector<T, StackAllocator<T, stack_capacity> >,
     stack_capacity> {
@@ skipping 24 matching lines @@
   // operator-> (using "->at()" does exception stuff we don't want).
   T& operator[](size_t i) { return this->container().operator[](i); }
   const T& operator[](size_t i) const {
     return this->container().operator[](i);
   }
 };
 
 }  // namespace base
 
 #endif  // BASE_CONTAINERS_STACK_CONTAINER_H_