OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/callback_registry.h" | 5 #include "base/callback_registry.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/bind_helpers.h" | 9 #include "base/bind_helpers.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
11 #include "testing/gtest/include/gtest/gtest.h" | 11 #include "testing/gtest/include/gtest/gtest.h" |
12 | 12 |
13 namespace base { | 13 namespace base { |
14 namespace { | 14 namespace { |
15 | 15 |
16 class Listener { | 16 class Listener { |
17 public: | 17 public: |
18 Listener() : total_(0), scaler_(1) {} | 18 Listener() : total_(0), scaler_(1) {} |
19 explicit Listener(int scaler) : total_(0), scaler_(scaler) {} | 19 explicit Listener(int scaler) : total_(0), scaler_(scaler) {} |
20 void IncrementTotal() { total_++; } | 20 void IncrementTotal() { total_++; } |
21 void IncrementByMultipleOfScaler(const int& x) { total_ += x * scaler_; } | 21 void IncrementByMultipleOfScaler(int x) { total_ += x * scaler_; } |
22 | 22 |
23 int total_; | 23 int total_; |
24 | 24 |
25 private: | 25 private: |
26 int scaler_; | 26 int scaler_; |
27 DISALLOW_COPY_AND_ASSIGN(Listener); | 27 DISALLOW_COPY_AND_ASSIGN(Listener); |
28 }; | 28 }; |
29 | 29 |
30 class Remover { | 30 class Remover { |
31 public: | 31 public: |
32 Remover() : total_(0) {} | 32 Remover() : total_(0) {} |
33 void IncrementTotalAndRemove() { | 33 void IncrementTotalAndRemove() { |
34 total_++; | 34 total_++; |
35 removal_subscription_.reset(); | 35 removal_subscription_.reset(); |
36 } | 36 } |
37 void SetSubscriptionToRemove( | 37 void SetSubscriptionToRemove( |
38 scoped_ptr<CallbackRegistry<void>::Subscription> sub) { | 38 scoped_ptr<CallbackRegistry<void(void)>::Subscription> sub) { |
39 removal_subscription_ = sub.Pass(); | 39 removal_subscription_ = sub.Pass(); |
40 } | 40 } |
41 | 41 |
42 int total_; | 42 int total_; |
43 | 43 |
44 private: | 44 private: |
45 scoped_ptr<CallbackRegistry<void>::Subscription> removal_subscription_; | 45 scoped_ptr<CallbackRegistry<void(void)>::Subscription> removal_subscription_; |
46 DISALLOW_COPY_AND_ASSIGN(Remover); | 46 DISALLOW_COPY_AND_ASSIGN(Remover); |
47 }; | 47 }; |
48 | 48 |
49 class Adder { | 49 class Adder { |
50 public: | 50 public: |
51 explicit Adder(CallbackRegistry<void>* cb_reg) | 51 explicit Adder(CallbackRegistry<void(void)>* cb_reg) |
52 : added_(false), | 52 : added_(false), |
53 total_(0), | 53 total_(0), |
54 cb_reg_(cb_reg) {} | 54 cb_reg_(cb_reg) {} |
55 void AddCallback() { | 55 void AddCallback() { |
56 if (!added_) { | 56 if (!added_) { |
57 added_ = true; | 57 added_ = true; |
58 subscription_ = | 58 subscription_ = |
59 cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this))); | 59 cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this))); |
60 } | 60 } |
61 } | 61 } |
62 void IncrementTotal() { total_++; } | 62 void IncrementTotal() { total_++; } |
63 | 63 |
64 bool added_; | 64 bool added_; |
65 int total_; | 65 int total_; |
66 | 66 |
67 private: | 67 private: |
68 CallbackRegistry<void>* cb_reg_; | 68 CallbackRegistry<void(void)>* cb_reg_; |
69 scoped_ptr<CallbackRegistry<void>::Subscription> subscription_; | 69 scoped_ptr<CallbackRegistry<void(void)>::Subscription> subscription_; |
70 DISALLOW_COPY_AND_ASSIGN(Adder); | 70 DISALLOW_COPY_AND_ASSIGN(Adder); |
71 }; | 71 }; |
72 | 72 |
| 73 class Summer { |
| 74 public: |
| 75 Summer() : value_(0) {} |
| 76 |
| 77 void AddOneParam(int a) { value_ = a; } |
| 78 void AddTwoParam(int a, int b) { value_ = a + b; } |
| 79 void AddThreeParam(int a, int b, int c) { value_ = a + b + c; } |
| 80 void AddFourParam(int a, int b, int c, int d) { value_ = a + b + c + d; } |
| 81 void AddFiveParam(int a, int b, int c, int d, int e) { |
| 82 value_ = a + b + c + d + e; |
| 83 } |
| 84 void AddSixParam(int a, int b, int c, int d, int e , int f) { |
| 85 value_ = a + b + c + d + e + f; |
| 86 } |
| 87 |
| 88 int value_; |
| 89 |
| 90 private: |
| 91 DISALLOW_COPY_AND_ASSIGN(Summer); |
| 92 }; |
| 93 |
| 94 // Sanity check that we can instantiate a CallbackRegistry for each arity. |
| 95 TEST(CallbackRegistryTest, ArityTest) { |
| 96 Summer s; |
| 97 |
| 98 CallbackRegistry<void(int)> c1; |
| 99 scoped_ptr<CallbackRegistry<void(int)>::Subscription> subscription1 = |
| 100 c1.Add(Bind(&Summer::AddOneParam, Unretained(&s))); |
| 101 |
| 102 c1.Notify(1); |
| 103 EXPECT_EQ(1, s.value_); |
| 104 |
| 105 CallbackRegistry<void(int, int)> c2; |
| 106 scoped_ptr<CallbackRegistry<void(int, int)>::Subscription> subscription2 = |
| 107 c2.Add(Bind(&Summer::AddTwoParam, Unretained(&s))); |
| 108 |
| 109 c2.Notify(1, 2); |
| 110 EXPECT_EQ(3, s.value_); |
| 111 |
| 112 CallbackRegistry<void(int, int, int)> c3; |
| 113 scoped_ptr<CallbackRegistry<void(int, int, int)>::Subscription> |
| 114 subscription3 = c3.Add(Bind(&Summer::AddThreeParam, Unretained(&s))); |
| 115 |
| 116 c3.Notify(1, 2, 3); |
| 117 EXPECT_EQ(6, s.value_); |
| 118 |
| 119 CallbackRegistry<void(int, int, int, int)> c4; |
| 120 scoped_ptr<CallbackRegistry<void(int, int, int, int)>::Subscription> |
| 121 subscription4 = c4.Add(Bind(&Summer::AddFourParam, Unretained(&s))); |
| 122 |
| 123 c4.Notify(1, 2, 3, 4); |
| 124 EXPECT_EQ(10, s.value_); |
| 125 |
| 126 CallbackRegistry<void(int, int, int, int, int)> c5; |
| 127 scoped_ptr<CallbackRegistry<void(int, int, int, int, int)>::Subscription> |
| 128 subscription5 = c5.Add(Bind(&Summer::AddFiveParam, Unretained(&s))); |
| 129 |
| 130 c5.Notify(1, 2, 3, 4, 5); |
| 131 EXPECT_EQ(15, s.value_); |
| 132 |
| 133 CallbackRegistry<void(int, int, int, int, int, int)> c6; |
| 134 scoped_ptr<CallbackRegistry<void(int, int, int, int, int, int)>::Subscription> |
| 135 subscription6 = c6.Add(Bind(&Summer::AddSixParam, Unretained(&s))); |
| 136 |
| 137 c6.Notify(1, 2, 3, 4, 5, 6); |
| 138 EXPECT_EQ(21, s.value_); |
| 139 } |
| 140 |
73 // Sanity check that closures added to the list will be run, and those removed | 141 // Sanity check that closures added to the list will be run, and those removed |
74 // from the list will not be run. | 142 // from the list will not be run. |
75 TEST(CallbackRegistryTest, BasicTest) { | 143 TEST(CallbackRegistryTest, BasicTest) { |
76 CallbackRegistry<void> cb_reg; | 144 CallbackRegistry<void(void)> cb_reg; |
77 Listener a, b, c; | 145 Listener a, b, c; |
78 | 146 |
79 scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription = | 147 scoped_ptr<CallbackRegistry<void(void)>::Subscription> a_subscription = |
80 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a))); | 148 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a))); |
81 scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription = | 149 scoped_ptr<CallbackRegistry<void(void)>::Subscription> b_subscription = |
82 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); | 150 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); |
83 | 151 |
84 EXPECT_TRUE(a_subscription.get()); | 152 EXPECT_TRUE(a_subscription.get()); |
85 EXPECT_TRUE(b_subscription.get()); | 153 EXPECT_TRUE(b_subscription.get()); |
86 | 154 |
87 cb_reg.Notify(); | 155 cb_reg.Notify(); |
88 | 156 |
89 EXPECT_EQ(1, a.total_); | 157 EXPECT_EQ(1, a.total_); |
90 EXPECT_EQ(1, b.total_); | 158 EXPECT_EQ(1, b.total_); |
91 | 159 |
92 b_subscription.reset(); | 160 b_subscription.reset(); |
93 | 161 |
94 scoped_ptr<CallbackRegistry<void>::Subscription> c_subscription = | 162 scoped_ptr<CallbackRegistry<void(void)>::Subscription> c_subscription = |
95 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c))); | 163 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c))); |
96 | 164 |
97 cb_reg.Notify(); | 165 cb_reg.Notify(); |
98 | 166 |
99 EXPECT_EQ(2, a.total_); | 167 EXPECT_EQ(2, a.total_); |
100 EXPECT_EQ(1, b.total_); | 168 EXPECT_EQ(1, b.total_); |
101 EXPECT_EQ(1, c.total_); | 169 EXPECT_EQ(1, c.total_); |
102 | 170 |
103 a_subscription.reset(); | 171 a_subscription.reset(); |
104 b_subscription.reset(); | 172 b_subscription.reset(); |
105 c_subscription.reset(); | 173 c_subscription.reset(); |
106 } | 174 } |
107 | 175 |
108 // Sanity check that callbacks with details added to the list will be run, with | 176 // Sanity check that callbacks with details added to the list will be run, with |
109 // the correct details, and those removed from the list will not be run. | 177 // the correct details, and those removed from the list will not be run. |
110 TEST(CallbackRegistryTest, BasicTestWithParams) { | 178 TEST(CallbackRegistryTest, BasicTestWithParams) { |
111 CallbackRegistry<int> cb_reg; | 179 CallbackRegistry<void(int)> cb_reg; |
112 Listener a(1), b(-1), c(1); | 180 Listener a(1), b(-1), c(1); |
113 | 181 |
114 scoped_ptr<CallbackRegistry<int>::Subscription> a_subscription = | 182 scoped_ptr<CallbackRegistry<void(int)>::Subscription> a_subscription = |
115 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a))); | 183 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a))); |
116 scoped_ptr<CallbackRegistry<int>::Subscription> b_subscription = | 184 scoped_ptr<CallbackRegistry<void(int)>::Subscription> b_subscription = |
117 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b))); | 185 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b))); |
118 | 186 |
119 EXPECT_TRUE(a_subscription.get()); | 187 EXPECT_TRUE(a_subscription.get()); |
120 EXPECT_TRUE(b_subscription.get()); | 188 EXPECT_TRUE(b_subscription.get()); |
121 | 189 |
122 cb_reg.Notify(10); | 190 cb_reg.Notify(10); |
123 | 191 |
124 EXPECT_EQ(10, a.total_); | 192 EXPECT_EQ(10, a.total_); |
125 EXPECT_EQ(-10, b.total_); | 193 EXPECT_EQ(-10, b.total_); |
126 | 194 |
127 b_subscription.reset(); | 195 b_subscription.reset(); |
128 | 196 |
129 scoped_ptr<CallbackRegistry<int>::Subscription> c_subscription = | 197 scoped_ptr<CallbackRegistry<void(int)>::Subscription> c_subscription = |
130 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c))); | 198 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c))); |
131 | 199 |
132 cb_reg.Notify(10); | 200 cb_reg.Notify(10); |
133 | 201 |
134 EXPECT_EQ(20, a.total_); | 202 EXPECT_EQ(20, a.total_); |
135 EXPECT_EQ(-10, b.total_); | 203 EXPECT_EQ(-10, b.total_); |
136 EXPECT_EQ(10, c.total_); | 204 EXPECT_EQ(10, c.total_); |
137 | 205 |
138 a_subscription.reset(); | 206 a_subscription.reset(); |
139 b_subscription.reset(); | 207 b_subscription.reset(); |
140 c_subscription.reset(); | 208 c_subscription.reset(); |
141 } | 209 } |
142 | 210 |
143 // Test the a callback can remove itself or a different callback from the list | 211 // Test the a callback can remove itself or a different callback from the list |
144 // during iteration without invalidating the iterator. | 212 // during iteration without invalidating the iterator. |
145 TEST(CallbackRegistryTest, RemoveCallbacksDuringIteration) { | 213 TEST(CallbackRegistryTest, RemoveCallbacksDuringIteration) { |
146 CallbackRegistry<void> cb_reg; | 214 CallbackRegistry<void(void)> cb_reg; |
147 Listener a, b; | 215 Listener a, b; |
148 Remover remover_1, remover_2; | 216 Remover remover_1, remover_2; |
149 | 217 |
150 scoped_ptr<CallbackRegistry<void>::Subscription> remover_1_subscription = | 218 scoped_ptr<CallbackRegistry<void(void)>::Subscription> remover_1_sub = |
151 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove, | 219 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove, |
152 Unretained(&remover_1))); | 220 Unretained(&remover_1))); |
153 scoped_ptr<CallbackRegistry<void>::Subscription> remover_2_subscription = | 221 scoped_ptr<CallbackRegistry<void(void)>::Subscription> remover_2_sub = |
154 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove, | 222 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove, |
155 Unretained(&remover_2))); | 223 Unretained(&remover_2))); |
156 scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription = | 224 scoped_ptr<CallbackRegistry<void(void)>::Subscription> a_subscription = |
157 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a))); | 225 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a))); |
158 scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription = | 226 scoped_ptr<CallbackRegistry<void(void)>::Subscription> b_subscription = |
159 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); | 227 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); |
160 | 228 |
161 // |remover_1| will remove itself. | 229 // |remover_1| will remove itself. |
162 remover_1.SetSubscriptionToRemove(remover_1_subscription.Pass()); | 230 remover_1.SetSubscriptionToRemove(remover_1_sub.Pass()); |
163 // |remover_2| will remove a. | 231 // |remover_2| will remove a. |
164 remover_2.SetSubscriptionToRemove(a_subscription.Pass()); | 232 remover_2.SetSubscriptionToRemove(a_subscription.Pass()); |
165 | 233 |
166 cb_reg.Notify(); | 234 cb_reg.Notify(); |
167 | 235 |
168 // |remover_1| runs once (and removes itself), |remover_2| runs once (and | 236 // |remover_1| runs once (and removes itself), |remover_2| runs once (and |
169 // removes a), |a| never runs, and |b| runs once. | 237 // removes a), |a| never runs, and |b| runs once. |
170 EXPECT_EQ(1, remover_1.total_); | 238 EXPECT_EQ(1, remover_1.total_); |
171 EXPECT_EQ(1, remover_2.total_); | 239 EXPECT_EQ(1, remover_2.total_); |
172 EXPECT_EQ(0, a.total_); | 240 EXPECT_EQ(0, a.total_); |
173 EXPECT_EQ(1, b.total_); | 241 EXPECT_EQ(1, b.total_); |
174 | 242 |
175 cb_reg.Notify(); | 243 cb_reg.Notify(); |
176 | 244 |
177 // Only |remover_2| and |b| run this time. | 245 // Only |remover_2| and |b| run this time. |
178 EXPECT_EQ(1, remover_1.total_); | 246 EXPECT_EQ(1, remover_1.total_); |
179 EXPECT_EQ(2, remover_2.total_); | 247 EXPECT_EQ(2, remover_2.total_); |
180 EXPECT_EQ(0, a.total_); | 248 EXPECT_EQ(0, a.total_); |
181 EXPECT_EQ(2, b.total_); | 249 EXPECT_EQ(2, b.total_); |
182 } | 250 } |
183 | 251 |
184 // Test that a callback can add another callback to the list durning iteration | 252 // Test that a callback can add another callback to the list durning iteration |
185 // without invalidating the iterator. The newly added callback should be run on | 253 // without invalidating the iterator. The newly added callback should be run on |
186 // the current iteration as will all other callbacks in the list. | 254 // the current iteration as will all other callbacks in the list. |
187 TEST(CallbackRegistryTest, AddCallbacksDuringIteration) { | 255 TEST(CallbackRegistryTest, AddCallbacksDuringIteration) { |
188 CallbackRegistry<void> cb_reg; | 256 CallbackRegistry<void(void)> cb_reg; |
189 Adder a(&cb_reg); | 257 Adder a(&cb_reg); |
190 Listener b; | 258 Listener b; |
191 scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription = | 259 scoped_ptr<CallbackRegistry<void(void)>::Subscription> a_subscription = |
192 cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a))); | 260 cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a))); |
193 scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription = | 261 scoped_ptr<CallbackRegistry<void(void)>::Subscription> b_subscription = |
194 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); | 262 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); |
195 | 263 |
196 cb_reg.Notify(); | 264 cb_reg.Notify(); |
197 | 265 |
198 EXPECT_EQ(1, a.total_); | 266 EXPECT_EQ(1, a.total_); |
199 EXPECT_EQ(1, b.total_); | 267 EXPECT_EQ(1, b.total_); |
200 EXPECT_TRUE(a.added_); | 268 EXPECT_TRUE(a.added_); |
201 | 269 |
202 cb_reg.Notify(); | 270 cb_reg.Notify(); |
203 | 271 |
204 EXPECT_EQ(2, a.total_); | 272 EXPECT_EQ(2, a.total_); |
205 EXPECT_EQ(2, b.total_); | 273 EXPECT_EQ(2, b.total_); |
206 } | 274 } |
207 | 275 |
208 // Sanity check: notifying an empty list is a no-op. | 276 // Sanity check: notifying an empty list is a no-op. |
209 TEST(CallbackRegistryTest, EmptyList) { | 277 TEST(CallbackRegistryTest, EmptyList) { |
210 CallbackRegistry<void> cb_reg; | 278 CallbackRegistry<void(void)> cb_reg; |
211 | 279 |
212 cb_reg.Notify(); | 280 cb_reg.Notify(); |
213 } | 281 } |
214 | 282 |
215 } // namespace | 283 } // namespace |
216 } // namespace base | 284 } // namespace base |
OLD | NEW |