Add ALIGNAS and ALIGNOF macros to ensure proper alignment of StaticMemorySingletonTraits

base/memory/singleton_unittest.cc

 // Copyright (c) 2011 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 "base/at_exit.h"
 #include "base/file_util.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 92 matching lines @@
 struct CallbackSingletonWithStaticTrait::Trait
     : public StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait> {
   static void Delete(CallbackSingletonWithStaticTrait* instance) {
     if (instance->callback_)
       (instance->callback_)();
     StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete(
         instance);
   }
 };
 
+template <class Type>
+class AlignedTestSingleton {
+ public:
+  static AlignedTestSingleton* GetInstance() {
+    return Singleton<AlignedTestSingleton,
+        StaticMemorySingletonTraits<AlignedTestSingleton> >::get();
+  }
+
+  Type type_;
+};
+
+class ALIGNED(32) Aligned32Type {
+ public:
+  Aligned32Type() {
+    memset(data_, 32, sizeof(data_));
+  }
+ private:
+  int32 data_[32 / 4];
+};
+
 
 void SingletonNoLeak(CallbackFunc CallOnQuit) {
   CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 void SingletonLeak(CallbackFunc CallOnQuit) {
   CallbackSingletonWithLeakTrait::GetInstance()->callback_ = CallOnQuit;
 }
 
 CallbackFunc* GetLeakySingleton() {
@@ skipping 120 matching lines @@
     {
       // Resurrect the static singleton, and assert that it
       // still points to the same (static) memory.
       CallbackSingletonWithStaticTrait::Trait::Resurrect();
       EXPECT_EQ(GetStaticSingleton(), static_singleton);
     }
   }
   // The leaky singleton shouldn't leak since SingletonLeak has not been called.
   VerifiesCallbacksNotCalled();
 }
+
+TEST_F(SingletonTest, Alignment) {
+  AlignedTestSingleton<Aligned32Type>* singleton1_align32 =
+      AlignedTestSingleton<Aligned32Type>::GetInstance();
+  AlignedTestSingleton<int>* singleton2_align4 =
+      AlignedTestSingleton<int>::GetInstance();
+  AlignedTestSingleton<Aligned32Type>* singleton3_align32 =
+      AlignedTestSingleton<Aligned32Type>::GetInstance();
+  intptr_t singleton1_addr =
+      reinterpret_cast<intptr_t>(&singleton1_align32->type_);
+  intptr_t singleton2_addr =
+      reinterpret_cast<intptr_t>(&singleton2_align4->type_);
+  intptr_t singleton3_addr =
+      reinterpret_cast<intptr_t>(&singleton3_align32->type_);
+  EXPECT_EQ(intptr_t(0), singleton1_addr & 31);
+  EXPECT_EQ(intptr_t(0), singleton2_addr & 3);
+  EXPECT_EQ(intptr_t(0), singleton3_addr & 31);

[Jeffrey Yasskin (google), 2012/02/15 22:27:19]

Isn't a better test to check that singleton1_addr == singleton3_addr?

[jbates, 2012/02/15 22:51:33]

Yes! In fact, I had a nightmare about how broken this test is and fully plan to
fix it :)

+}