Use C++11 alignment primitives

cc/base/list_container_unittest.cc

 // Copyright 2014 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.
 
 #include "cc/base/list_container.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 33 matching lines @@
 
 class DerivedElement3 : public DerivedElement {
  protected:
   bool bool_values3[3];
   char char_values3[3];
   int int_values3[3];
   long long_values3[3];
 };
 
 const size_t kLargestDerivedElementSize = sizeof(DerivedElement3);
-const size_t kLargestDerivedElementAlign = ALIGNOF(DerivedElement3);
+const size_t kLargestDerivedElementAlign = alignof(DerivedElement3);
 
 static_assert(sizeof(DerivedElement1) <= kLargestDerivedElementSize,
               "Largest Derived Element size needs update. DerivedElement1 is "
               "currently largest.");
 static_assert(sizeof(DerivedElement2) <= kLargestDerivedElementSize,
               "Largest Derived Element size needs update. DerivedElement2 is "
               "currently largest.");
-static_assert(ALIGNOF(DerivedElement1) <= kLargestDerivedElementSize,
+static_assert(alignof(DerivedElement1) <= kLargestDerivedElementSize,
               "Largest Derived Element align needs update. DerivedElement1 is "
               "currently largest.");
-static_assert(ALIGNOF(DerivedElement2) <= kLargestDerivedElementSize,
+static_assert(alignof(DerivedElement2) <= kLargestDerivedElementSize,
               "Largest Derived Element align needs update. DerivedElement2 is "
               "currently largest.");
 
 // Element class having no derived classes.
 class NonDerivedElement {
  public:
   NonDerivedElement() {}
   ~NonDerivedElement() {}
 
   int int_values[1];
@@ skipping 54 matching lines @@
 class MockDerivedElementSubclass : public MockDerivedElement {
  public:
   MockDerivedElementSubclass() {
     set_value(kMagicNumberToUseForSimpleDerivedElementTwo);
   }
 };
 
 const size_t kCurrentLargestDerivedElementSize =
     std::max(kLargestDerivedElementSize, sizeof(MockDerivedElementSubclass));
 const size_t kCurrentLargestDerivedElementAlign =
-    std::max(kLargestDerivedElementAlign, ALIGNOF(MockDerivedElementSubclass));
+    std::max(kLargestDerivedElementAlign, alignof(MockDerivedElementSubclass));
 
 TEST(ListContainerTest, ConstructorCalledInAllocateAndConstruct) {
   ListContainer<DerivedElement> list(kCurrentLargestDerivedElementAlign,
                                      kCurrentLargestDerivedElementSize, 0);
 
   size_t size = 2;
   SimpleDerivedElementConstructMagicNumberOne* de_1 =
       list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberOne>();
   SimpleDerivedElementConstructMagicNumberTwo* de_2 =
       list.AllocateAndConstruct<SimpleDerivedElementConstructMagicNumberTwo>();
@@ skipping 119 matching lines @@
     EXPECT_CALL(*de_1, Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(*de_1, Destruct()).Times(0);
   }
 
   list.EraseAndInvalidateAllPointers(list.begin());
   separator.Call();
 }
 
 TEST(ListContainerTest, SimpleIndexAccessNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
 
   size_t size = 3;
   NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>();
   NonDerivedElement* nde_2 = list.AllocateAndConstruct<NonDerivedElement>();
   NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(nde_1, list.front());
   EXPECT_EQ(nde_3, list.back());
   EXPECT_EQ(list.front(), list.ElementAt(0));
   EXPECT_EQ(nde_2, list.ElementAt(1));
   EXPECT_EQ(list.back(), list.ElementAt(2));
 }
 
 TEST(ListContainerTest, SimpleInsertionNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
 
   size_t size = 3;
   NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>();
   list.AllocateAndConstruct<NonDerivedElement>();
   NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(nde_1, list.front());
   EXPECT_EQ(nde_3, list.back());
 }
 
 TEST(ListContainerTest, SimpleInsertionAndClearNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(0u, list.size());
 
   size_t size = 3;
   NonDerivedElement* nde_1 = list.AllocateAndConstruct<NonDerivedElement>();
   list.AllocateAndConstruct<NonDerivedElement>();
   NonDerivedElement* nde_3 = list.AllocateAndConstruct<NonDerivedElement>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(nde_1, list.front());
   EXPECT_EQ(nde_3, list.back());
   EXPECT_FALSE(list.empty());
 
   list.clear();
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(0u, list.size());
 }
 
 TEST(ListContainerTest, SimpleInsertionClearAndInsertAgainNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(0u, list.size());
 
   size_t size = 2;
   NonDerivedElement* nde_front = list.AllocateAndConstruct<NonDerivedElement>();
   NonDerivedElement* nde_back = list.AllocateAndConstruct<NonDerivedElement>();
 
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(nde_front, list.front());
@@ skipping 12 matching lines @@
   EXPECT_EQ(size, list.size());
   EXPECT_EQ(nde_front, list.front());
   EXPECT_EQ(nde_back, list.back());
   EXPECT_FALSE(list.empty());
 }
 
 // This test is used to test when there is more than one allocation needed
 // for, ListContainer can still perform like normal vector.
 TEST(ListContainerTest,
      SimpleInsertionTriggerMoreThanOneAllocationNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 2);
   std::vector<NonDerivedElement*> nde_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>());
   }
   EXPECT_EQ(size, list.size());
 
   ListContainer<NonDerivedElement>::Iterator iter = list.begin();
   for (std::vector<NonDerivedElement*>::const_iterator nde_iter =
            nde_list.begin();
        nde_iter != nde_list.end(); ++nde_iter) {
     EXPECT_EQ(*nde_iter, *iter);
     ++iter;
   }
 }
 
 TEST(ListContainerTest,
      CorrectAllocationSizeForMoreThanOneAllocationNonDerivedElement) {
   // Constructor sets the allocation size to 2. Every time ListContainer needs
   // to allocate again, it doubles allocation size. In this test, 10 elements is
   // needed, thus ListContainerShould allocate spaces 2, 4 and 8 elements.
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 2);
   std::vector<NonDerivedElement*> nde_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     // Before asking for a new element, space available without another
     // allocation follows.
     switch (i) {
       case 2:
       case 6:
         EXPECT_EQ(0u, list.AvailableSizeWithoutAnotherAllocationForTesting());
@@ skipping 60 matching lines @@
   ListContainer<NonDerivedElement>::Iterator iter = list.begin();
   for (std::vector<NonDerivedElement*>::const_iterator nde_iter =
            nde_list.begin();
        nde_iter != nde_list.end(); ++nde_iter) {
     EXPECT_EQ(*nde_iter, *iter);
     ++iter;
   }
 }
 
 TEST(ListContainerTest, SimpleIterationNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
   std::vector<NonDerivedElement*> nde_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>());
   }
   EXPECT_EQ(size, list.size());
 
   size_t num_iters_in_list = 0;
   {
@@ skipping 15 matching lines @@
       EXPECT_EQ(*nde_iter, *iter);
       ++num_iters_in_vector;
       ++iter;
     }
   }
 
   EXPECT_EQ(num_iters_in_vector, num_iters_in_list);
 }
 
 TEST(ListContainerTest, SimpleConstIteratorIterationNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
   std::vector<const NonDerivedElement*> nde_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>());
   }
   EXPECT_EQ(size, list.size());
 
   {
     std::vector<const NonDerivedElement*>::const_iterator nde_iter =
@@ skipping 22 matching lines @@
     for (std::vector<const NonDerivedElement*>::const_iterator nde_iter =
              nde_list.begin();
          nde_iter != nde_list.end(); ++nde_iter) {
       EXPECT_EQ(*nde_iter, *iter);
       ++iter;
     }
   }
 }
 
 TEST(ListContainerTest, SimpleReverseInsertionNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
   std::vector<NonDerivedElement*> nde_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>());
   }
   EXPECT_EQ(size, list.size());
 
   {
     std::vector<NonDerivedElement*>::const_reverse_iterator nde_iter =
@@ skipping 318 matching lines @@
   int i = 0;
   for (std::vector<SimpleDerivedElement*>::const_iterator
            de_iter = de_list.begin();
        de_iter != de_list.end(); ++de_iter, ++i) {
     EXPECT_EQ(i, (*de_iter)->get_value());
   }
 }
 
 TEST(ListContainerTest,
      SimpleIterationAndReverseIterationWithIndexNonDerivedElement) {
-  ListContainer<NonDerivedElement> list(ALIGNOF(NonDerivedElement),
+  ListContainer<NonDerivedElement> list(alignof(NonDerivedElement),
                                         sizeof(NonDerivedElement), 0);
   std::vector<NonDerivedElement*> nde_list;
   size_t size = 10;
   for (size_t i = 0; i < size; ++i) {
     nde_list.push_back(list.AllocateAndConstruct<NonDerivedElement>());
   }
   EXPECT_EQ(size, list.size());
 
   size_t i = 0;
   for (ListContainer<NonDerivedElement>::Iterator iter = list.begin();
@@ skipping 26 matching lines @@
   }
 
  private:
   int* counter_;
 };
 
 TEST(ListContainerTest, RemoveLastDestruction) {
   // We keep an explicit instance count to make sure that the destructors are
   // indeed getting called.
   int counter = 0;
-  ListContainer<InstanceCounter> list(ALIGNOF(InstanceCounter),
+  ListContainer<InstanceCounter> list(alignof(InstanceCounter),
                                       sizeof(InstanceCounter), 1);
   EXPECT_EQ(0, counter);
   EXPECT_EQ(0u, list.size());
 
   // We should be okay to add one and then go back to zero.
   list.AllocateAndConstruct<InstanceCounter>()->SetCounter(&counter);
   EXPECT_EQ(1, counter);
   EXPECT_EQ(1u, list.size());
   list.RemoveLast();
   EXPECT_EQ(0, counter);
@@ skipping 24 matching lines @@
     if (!(*it1 == *it2))
       return false;
   }
   return true;
 }
 
 TEST(ListContainerTest, RemoveLastIteration) {
   struct SmallStruct {
     char dummy[16];
   };
-  ListContainer<SmallStruct> list(ALIGNOF(SmallStruct), sizeof(SmallStruct), 1);
+  ListContainer<SmallStruct> list(alignof(SmallStruct), sizeof(SmallStruct), 1);
   std::vector<SmallStruct*> pointers;
 
   // Utilities which keep these two lists in sync and check that their iteration
   // order matches.
   auto push = [&list, &pointers]() {
     pointers.push_back(list.AllocateAndConstruct<SmallStruct>());
   };
   auto pop = [&list, &pointers]() {
     pointers.pop_back();
     list.RemoveLast();
@@ skipping 249 matching lines @@
     size_t capacity = list.GetCapacityInBytes();
     ASSERT_GE(capacity, list.size() * kLargestDerivedElementSize);
     ASSERT_LE(capacity, std::max(list.size(), upper_bound_on_min_capacity) *
                             max_waste_factor * kLargestDerivedElementSize);
     list.RemoveLast();
   }
 }
 
 }  // namespace
 }  // namespace cc