OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/at_exit.h" | 5 #include "base/at_exit.h" |
6 #include "base/memory/singleton.h" | 6 #include "base/memory/singleton.h" |
7 #include "testing/gtest/include/gtest/gtest.h" | 7 #include "testing/gtest/include/gtest/gtest.h" |
8 | 8 |
9 namespace { | 9 namespace { |
danakj
2015/09/01 20:55:13
you could wrap this file in the base namespace and
| |
10 | 10 |
11 COMPILE_ASSERT(DefaultSingletonTraits<int>::kRegisterAtExit == true, a); | 11 COMPILE_ASSERT(base::DefaultSingletonTraits<int>::kRegisterAtExit == true, a); |
12 | 12 |
13 typedef void (*CallbackFunc)(); | 13 typedef void (*CallbackFunc)(); |
14 | 14 |
15 class IntSingleton { | 15 class IntSingleton { |
16 public: | 16 public: |
17 static IntSingleton* GetInstance() { | 17 static IntSingleton* GetInstance() { |
18 return Singleton<IntSingleton>::get(); | 18 return base::Singleton<IntSingleton>::get(); |
19 } | 19 } |
20 | 20 |
21 int value_; | 21 int value_; |
22 }; | 22 }; |
23 | 23 |
24 class Init5Singleton { | 24 class Init5Singleton { |
25 public: | 25 public: |
26 struct Trait; | 26 struct Trait; |
27 | 27 |
28 static Init5Singleton* GetInstance() { | 28 static Init5Singleton* GetInstance() { |
29 return Singleton<Init5Singleton, Trait>::get(); | 29 return base::Singleton<Init5Singleton, Trait>::get(); |
30 } | 30 } |
31 | 31 |
32 int value_; | 32 int value_; |
33 }; | 33 }; |
34 | 34 |
35 struct Init5Singleton::Trait : public DefaultSingletonTraits<Init5Singleton> { | 35 struct Init5Singleton::Trait |
36 : public base::DefaultSingletonTraits<Init5Singleton> { | |
36 static Init5Singleton* New() { | 37 static Init5Singleton* New() { |
37 Init5Singleton* instance = new Init5Singleton(); | 38 Init5Singleton* instance = new Init5Singleton(); |
38 instance->value_ = 5; | 39 instance->value_ = 5; |
39 return instance; | 40 return instance; |
40 } | 41 } |
41 }; | 42 }; |
42 | 43 |
43 int* SingletonInt() { | 44 int* SingletonInt() { |
44 return &IntSingleton::GetInstance()->value_; | 45 return &IntSingleton::GetInstance()->value_; |
45 } | 46 } |
46 | 47 |
47 int* SingletonInt5() { | 48 int* SingletonInt5() { |
48 return &Init5Singleton::GetInstance()->value_; | 49 return &Init5Singleton::GetInstance()->value_; |
49 } | 50 } |
50 | 51 |
51 template <typename Type> | 52 template <typename Type> |
52 struct CallbackTrait : public DefaultSingletonTraits<Type> { | 53 struct CallbackTrait : public base::DefaultSingletonTraits<Type> { |
53 static void Delete(Type* instance) { | 54 static void Delete(Type* instance) { |
54 if (instance->callback_) | 55 if (instance->callback_) |
55 (instance->callback_)(); | 56 (instance->callback_)(); |
56 DefaultSingletonTraits<Type>::Delete(instance); | 57 base::DefaultSingletonTraits<Type>::Delete(instance); |
57 } | 58 } |
58 }; | 59 }; |
59 | 60 |
60 class CallbackSingleton { | 61 class CallbackSingleton { |
61 public: | 62 public: |
62 CallbackSingleton() : callback_(NULL) { } | 63 CallbackSingleton() : callback_(NULL) { } |
63 CallbackFunc callback_; | 64 CallbackFunc callback_; |
64 }; | 65 }; |
65 | 66 |
66 class CallbackSingletonWithNoLeakTrait : public CallbackSingleton { | 67 class CallbackSingletonWithNoLeakTrait : public CallbackSingleton { |
67 public: | 68 public: |
68 struct Trait : public CallbackTrait<CallbackSingletonWithNoLeakTrait> { }; | 69 struct Trait : public CallbackTrait<CallbackSingletonWithNoLeakTrait> { }; |
69 | 70 |
70 CallbackSingletonWithNoLeakTrait() : CallbackSingleton() { } | 71 CallbackSingletonWithNoLeakTrait() : CallbackSingleton() { } |
71 | 72 |
72 static CallbackSingletonWithNoLeakTrait* GetInstance() { | 73 static CallbackSingletonWithNoLeakTrait* GetInstance() { |
73 return Singleton<CallbackSingletonWithNoLeakTrait, Trait>::get(); | 74 return base::Singleton<CallbackSingletonWithNoLeakTrait, Trait>::get(); |
74 } | 75 } |
75 }; | 76 }; |
76 | 77 |
77 class CallbackSingletonWithLeakTrait : public CallbackSingleton { | 78 class CallbackSingletonWithLeakTrait : public CallbackSingleton { |
78 public: | 79 public: |
79 struct Trait : public CallbackTrait<CallbackSingletonWithLeakTrait> { | 80 struct Trait : public CallbackTrait<CallbackSingletonWithLeakTrait> { |
80 static const bool kRegisterAtExit = false; | 81 static const bool kRegisterAtExit = false; |
81 }; | 82 }; |
82 | 83 |
83 CallbackSingletonWithLeakTrait() : CallbackSingleton() { } | 84 CallbackSingletonWithLeakTrait() : CallbackSingleton() { } |
84 | 85 |
85 static CallbackSingletonWithLeakTrait* GetInstance() { | 86 static CallbackSingletonWithLeakTrait* GetInstance() { |
86 return Singleton<CallbackSingletonWithLeakTrait, Trait>::get(); | 87 return base::Singleton<CallbackSingletonWithLeakTrait, Trait>::get(); |
87 } | 88 } |
88 }; | 89 }; |
89 | 90 |
90 class CallbackSingletonWithStaticTrait : public CallbackSingleton { | 91 class CallbackSingletonWithStaticTrait : public CallbackSingleton { |
91 public: | 92 public: |
92 struct Trait; | 93 struct Trait; |
93 | 94 |
94 CallbackSingletonWithStaticTrait() : CallbackSingleton() { } | 95 CallbackSingletonWithStaticTrait() : CallbackSingleton() { } |
95 | 96 |
96 static CallbackSingletonWithStaticTrait* GetInstance() { | 97 static CallbackSingletonWithStaticTrait* GetInstance() { |
97 return Singleton<CallbackSingletonWithStaticTrait, Trait>::get(); | 98 return base::Singleton<CallbackSingletonWithStaticTrait, Trait>::get(); |
98 } | 99 } |
99 }; | 100 }; |
100 | 101 |
101 struct CallbackSingletonWithStaticTrait::Trait | 102 struct CallbackSingletonWithStaticTrait::Trait |
102 : public StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait> { | 103 : public base::StaticMemorySingletonTraits< |
104 CallbackSingletonWithStaticTrait> { | |
103 static void Delete(CallbackSingletonWithStaticTrait* instance) { | 105 static void Delete(CallbackSingletonWithStaticTrait* instance) { |
104 if (instance->callback_) | 106 if (instance->callback_) |
105 (instance->callback_)(); | 107 (instance->callback_)(); |
106 StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete( | 108 base::StaticMemorySingletonTraits<CallbackSingletonWithStaticTrait>::Delete( |
107 instance); | 109 instance); |
108 } | 110 } |
109 }; | 111 }; |
110 | 112 |
111 template <class Type> | 113 template <class Type> |
112 class AlignedTestSingleton { | 114 class AlignedTestSingleton { |
113 public: | 115 public: |
114 AlignedTestSingleton() {} | 116 AlignedTestSingleton() {} |
115 ~AlignedTestSingleton() {} | 117 ~AlignedTestSingleton() {} |
116 static AlignedTestSingleton* GetInstance() { | 118 static AlignedTestSingleton* GetInstance() { |
117 return Singleton<AlignedTestSingleton, | 119 return base::Singleton< |
118 StaticMemorySingletonTraits<AlignedTestSingleton> >::get(); | 120 AlignedTestSingleton, |
121 base::StaticMemorySingletonTraits<AlignedTestSingleton>>::get(); | |
119 } | 122 } |
120 | 123 |
121 Type type_; | 124 Type type_; |
122 }; | 125 }; |
123 | 126 |
124 | 127 |
125 void SingletonNoLeak(CallbackFunc CallOnQuit) { | 128 void SingletonNoLeak(CallbackFunc CallOnQuit) { |
126 CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit; | 129 CallbackSingletonWithNoLeakTrait::GetInstance()->callback_ = CallOnQuit; |
127 } | 130 } |
128 | 131 |
129 void SingletonLeak(CallbackFunc CallOnQuit) { | 132 void SingletonLeak(CallbackFunc CallOnQuit) { |
130 CallbackSingletonWithLeakTrait::GetInstance()->callback_ = CallOnQuit; | 133 CallbackSingletonWithLeakTrait::GetInstance()->callback_ = CallOnQuit; |
131 } | 134 } |
132 | 135 |
133 CallbackFunc* GetLeakySingleton() { | 136 CallbackFunc* GetLeakySingleton() { |
134 return &CallbackSingletonWithLeakTrait::GetInstance()->callback_; | 137 return &CallbackSingletonWithLeakTrait::GetInstance()->callback_; |
135 } | 138 } |
136 | 139 |
137 void DeleteLeakySingleton() { | 140 void DeleteLeakySingleton() { |
138 DefaultSingletonTraits<CallbackSingletonWithLeakTrait>::Delete( | 141 base::DefaultSingletonTraits<CallbackSingletonWithLeakTrait>::Delete( |
139 CallbackSingletonWithLeakTrait::GetInstance()); | 142 CallbackSingletonWithLeakTrait::GetInstance()); |
140 } | 143 } |
141 | 144 |
142 void SingletonStatic(CallbackFunc CallOnQuit) { | 145 void SingletonStatic(CallbackFunc CallOnQuit) { |
143 CallbackSingletonWithStaticTrait::GetInstance()->callback_ = CallOnQuit; | 146 CallbackSingletonWithStaticTrait::GetInstance()->callback_ = CallOnQuit; |
144 } | 147 } |
145 | 148 |
146 CallbackFunc* GetStaticSingleton() { | 149 CallbackFunc* GetStaticSingleton() { |
147 return &CallbackSingletonWithStaticTrait::GetInstance()->callback_; | 150 return &CallbackSingletonWithStaticTrait::GetInstance()->callback_; |
148 } | 151 } |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
278 AlignedTestSingleton<AlignedMemory<128, 128> >* align128 = | 281 AlignedTestSingleton<AlignedMemory<128, 128> >* align128 = |
279 AlignedTestSingleton<AlignedMemory<128, 128> >::GetInstance(); | 282 AlignedTestSingleton<AlignedMemory<128, 128> >::GetInstance(); |
280 AlignedTestSingleton<AlignedMemory<4096, 4096> >* align4096 = | 283 AlignedTestSingleton<AlignedMemory<4096, 4096> >* align4096 = |
281 AlignedTestSingleton<AlignedMemory<4096, 4096> >::GetInstance(); | 284 AlignedTestSingleton<AlignedMemory<4096, 4096> >::GetInstance(); |
282 | 285 |
283 EXPECT_ALIGNED(align4, 4); | 286 EXPECT_ALIGNED(align4, 4); |
284 EXPECT_ALIGNED(align32, 32); | 287 EXPECT_ALIGNED(align32, 32); |
285 EXPECT_ALIGNED(align128, 128); | 288 EXPECT_ALIGNED(align128, 128); |
286 EXPECT_ALIGNED(align4096, 4096); | 289 EXPECT_ALIGNED(align4096, 4096); |
287 } | 290 } |
OLD | NEW |