Use C++11 alignment primitives

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 <vector>
 
 #include "base/macros.h"
-#include "base/memory/aligned_memory.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 16 matching lines @@
   typedef typename std::allocator<T>::size_type size_type;
 
   // Backing store for the allocator. The container owner is responsible for
   // maintaining this for as long as any containers using this allocator are
   // live.
   struct Source {
     Source() : used_stack_buffer_(false) {
     }
 
     // Casts the buffer in its right type.
-    T* stack_buffer() { return stack_buffer_.template data_as<T>(); }
+    T* stack_buffer() { return reinterpret_cast<T*>(&stack_buffer_); }
     const T* stack_buffer() const {
-      return stack_buffer_.template data_as<T>();
+      return reinterpret_cast<const T*>(&stack_buffer_);
     }
 
     // The buffer itself. It is not of type T because we don't want the
     // constructors and destructors to be automatically called. Define a POD
     // buffer of the right size instead.
-    base::AlignedMemory<sizeof(T[stack_capacity]), ALIGNOF(T)> stack_buffer_;
+    typename std::aligned_storage<sizeof(T[stack_capacity]), alignof(T)>::type

[danakj, 2017/06/12 18:32:10]

Since you're having issues maybe we can/should split the removal of ALIGNOF()
from the removal of base::AlignedMemory?

+        stack_buffer_;
 #if defined(__GNUC__) && !defined(ARCH_CPU_X86_FAMILY)
-    static_assert(ALIGNOF(T) <= 16, "http://crbug.com/115612");
+    static_assert(alignof(T) <= 16, "http://crbug.com/115612");
 #endif
 
     // Set when the stack buffer is used for an allocation. We do not track
     // how much of the buffer is used, only that somebody is using it.
     bool used_stack_buffer_;
   };
 
   // Used by containers when they want to refer to an allocator of type U.
   template<typename U>
   struct rebind {
@@ skipping 150 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_