Remove base's ALIGNOF/ALIGNAS in favor of alignof/alignas.

base/metrics/persistent_memory_allocator.h

 // Copyright (c) 2015 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_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 #define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 
 #include <stdint.h>
 
 #include <atomic>
@@ skipping 409 matching lines @@
   T* ChangeObject(Reference ref, uint32_t from_type_id) {
     DCHECK_LE(sizeof(T), GetAllocSize(ref)) << "alloc not big enough for obj";
     // Make sure the memory is appropriate. This won't be used until after
     // the type is changed but checking first avoids the possibility of having
     // to change the type back.
     void* mem = const_cast<void*>(GetBlockData(ref, 0, sizeof(T)));
     if (!mem)
       return nullptr;
     // Ensure the allocator's internal alignment is sufficient for this object.
     // This protects against coding errors in the allocator.
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (ALIGNOF(T) - 1));
+    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
     // First change the type to "transitioning" so that there is no race
     // condition with the clearing and construction of the object should
     // another thread be simultaneously iterating over data. This will
     // "acquire" the memory so no changes get reordered before it.
     if (!ChangeType(ref, kReferenceTransitioning, from_type_id))
       return nullptr;
     // Clear the memory so that the property of all memory being zero after an
     // allocation also applies here.
     memset(mem, 0, GetAllocSize(ref));
     // Construct an object of the desired type on this memory, just as if
@@ skipping 21 matching lines @@
   // when the last field is actually variable length.
   template <typename T>
   T* AllocateObject(size_t size) {
     if (size < sizeof(T))
       size = sizeof(T);
     Reference ref = Allocate(size, T::kPersistentTypeId);
     void* mem =
         const_cast<void*>(GetBlockData(ref, T::kPersistentTypeId, size));
     if (!mem)
       return nullptr;
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (ALIGNOF(T) - 1));
+    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
     return new (mem) T();
   }
   template <typename T>
   T* AllocateObject() {
     return AllocateObject<T>(sizeof(T));
   }
 
   // Deletes an object by destructing it and then changing the type to a
   // different value (default 0).
   template <typename T>
@@ skipping 219 matching lines @@
  private:
   std::unique_ptr<MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
 };
 #endif  // !defined(OS_NACL)
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_