Use C++11 alignment primitives

third_party/crashpad/crashpad/util/stdlib/aligned_allocator.h

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #ifndef CRASHPAD_UTIL_STDLIB_ALIGNED_ALLOCATOR_H_
 #define CRASHPAD_UTIL_STDLIB_ALIGNED_ALLOCATOR_H_
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
 #include <new>
 #include <utility>
 #include <vector>
 
-#include "base/compiler_specific.h"
 #include "build/build_config.h"
 #include "util/stdlib/cxx.h"
 
 #if defined(COMPILER_MSVC) && _MSC_VER < 1900
 #define CRASHPAD_NOEXCEPT _NOEXCEPT
 #else
 #define CRASHPAD_NOEXCEPT noexcept
 #endif
 
 namespace crashpad {
@@ skipping 11 matching lines @@
 void AlignedFree(void* pointer);
 
 }  // namespace internal
 
 //! \brief A standard allocator that aligns its allocations as requested,
 //!     suitable for use as an allocator in standard containers.
 //!
 //! This is similar to `std::allocator<T>`, with the addition of an alignment
 //! guarantee. \a Alignment must be a power of 2. If \a Alignment is not
 //! specified, the default alignment for type \a T is used.
-template <class T, size_t Alignment = ALIGNOF(T)>
+template <class T, size_t Alignment = alignof(T)>
 struct AlignedAllocator {
  public:
   using value_type = T;
   using pointer = T*;
   using const_pointer = const T*;
   using reference = T&;
   using const_reference = const T&;
   using size_type = size_t;
   using difference_type = ptrdiff_t;
 
@@ skipping 54 matching lines @@
 bool operator!=(const AlignedAllocator<T1, Alignment>& lhs,
                 const AlignedAllocator<T2, Alignment>& rhs) CRASHPAD_NOEXCEPT {
   return false;
 }
 
 //! \brief A `std::vector` using AlignedAllocator.
 //!
 //! This is similar to `std::vector<T>`, with the addition of an alignment
 //! guarantee. \a Alignment must be a power of 2. If \a Alignment is not
 //! specified, the default alignment for type \a T is used.
-template <typename T, size_t Alignment = ALIGNOF(T)>
+template <typename T, size_t Alignment = alignof(T)>
 using AlignedVector = std::vector<T, AlignedAllocator<T, Alignment>>;
 
 }  // namespace crashpad
 
 #undef CRASHPAD_NOEXCEPT
 
 #endif  // CRASHPAD_UTIL_STDLIB_ALIGNED_ALLOCATOR_H_