Use C++11 alignment primitives

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 495 matching lines @@
   // when the last field is actually variable length.
   template <typename T>
   T* New(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* New() {
     return New<T>(sizeof(T));
   }
 
   // Similar to New, above, but construct the object out of an existing memory
   // block and of an expected type. If |clear| is true, memory will be zeroed
   // before construction. Though this is not standard object behavior, it
   // is present to match with new allocations that always come from zeroed
   // memory. Anything previously present simply ceases to exist; no destructor
   // is called for it so explicitly Delete() the old object first if need be.
   // Calling this will not invalidate existing pointers to the object, either
   // in this process or others, so changing the object could have unpredictable
   // results. USE WITH CARE!
   template <typename T>
   T* New(Reference ref, uint32_t from_type_id, bool clear) {
     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));
     // Change the type, clearing the memory if so desired. The new type is
     // "transitioning" so that there is no race condition with the 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, kTypeIdTransitioning, from_type_id, clear))
       return nullptr;
     // Construct an object of the desired type on this memory, just as if
     // New() had been called to create it.
     T* obj = new (mem) T();
@@ skipping 306 matching lines @@
   // share the same pointer then an allocation on one will amount to an
   // allocation for all.
   volatile std::atomic<Reference>* const reference_;
 
   // No DISALLOW_COPY_AND_ASSIGN as it's okay to copy/move these objects.
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_