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
3 // found in the LICENSE file.
4
5 #include "base/callback_list.h"
6
7 #include <gtest/gtest.h>
8 #include <utility>
9
10 #include "base/bind.h"
11 #include "base/bind_helpers.h"
12 #include "base/macros.h"
13 #include "base/memory/scoped_ptr.h"
14
15 namespace base {
16 namespace {
17
18 class Listener {
19 public:
Listener()20 Listener() : total_(0), scaler_(1) {}
Listener(int scaler)21 explicit Listener(int scaler) : total_(0), scaler_(scaler) {}
IncrementTotal()22 void IncrementTotal() { total_++; }
IncrementByMultipleOfScaler(int x)23 void IncrementByMultipleOfScaler(int x) { total_ += x * scaler_; }
24
total() const25 int total() const { return total_; }
26
27 private:
28 int total_;
29 int scaler_;
30 DISALLOW_COPY_AND_ASSIGN(Listener);
31 };
32
33 class Remover {
34 public:
Remover()35 Remover() : total_(0) {}
IncrementTotalAndRemove()36 void IncrementTotalAndRemove() {
37 total_++;
38 removal_subscription_.reset();
39 }
SetSubscriptionToRemove(scoped_ptr<CallbackList<void (void)>::Subscription> sub)40 void SetSubscriptionToRemove(
41 scoped_ptr<CallbackList<void(void)>::Subscription> sub) {
42 removal_subscription_ = std::move(sub);
43 }
44
total() const45 int total() const { return total_; }
46
47 private:
48 int total_;
49 scoped_ptr<CallbackList<void(void)>::Subscription> removal_subscription_;
50 DISALLOW_COPY_AND_ASSIGN(Remover);
51 };
52
53 class Adder {
54 public:
Adder(CallbackList<void (void)> * cb_reg)55 explicit Adder(CallbackList<void(void)>* cb_reg)
56 : added_(false),
57 total_(0),
58 cb_reg_(cb_reg) {
59 }
AddCallback()60 void AddCallback() {
61 if (!added_) {
62 added_ = true;
63 subscription_ =
64 cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this)));
65 }
66 }
IncrementTotal()67 void IncrementTotal() { total_++; }
68
added() const69 bool added() const { return added_; }
70
total() const71 int total() const { return total_; }
72
73 private:
74 bool added_;
75 int total_;
76 CallbackList<void(void)>* cb_reg_;
77 scoped_ptr<CallbackList<void(void)>::Subscription> subscription_;
78 DISALLOW_COPY_AND_ASSIGN(Adder);
79 };
80
81 class Summer {
82 public:
Summer()83 Summer() : value_(0) {}
84
AddOneParam(int a)85 void AddOneParam(int a) { value_ = a; }
AddTwoParam(int a,int b)86 void AddTwoParam(int a, int b) { value_ = a + b; }
AddThreeParam(int a,int b,int c)87 void AddThreeParam(int a, int b, int c) { value_ = a + b + c; }
AddFourParam(int a,int b,int c,int d)88 void AddFourParam(int a, int b, int c, int d) { value_ = a + b + c + d; }
AddFiveParam(int a,int b,int c,int d,int e)89 void AddFiveParam(int a, int b, int c, int d, int e) {
90 value_ = a + b + c + d + e;
91 }
AddSixParam(int a,int b,int c,int d,int e,int f)92 void AddSixParam(int a, int b, int c, int d, int e , int f) {
93 value_ = a + b + c + d + e + f;
94 }
95
value() const96 int value() const { return value_; }
97
98 private:
99 int value_;
100 DISALLOW_COPY_AND_ASSIGN(Summer);
101 };
102
103 class Counter {
104 public:
Counter()105 Counter() : value_(0) {}
106
Increment()107 void Increment() { value_++; }
108
value() const109 int value() const { return value_; }
110
111 private:
112 int value_;
113 DISALLOW_COPY_AND_ASSIGN(Counter);
114 };
115
116 // Sanity check that we can instantiate a CallbackList for each arity.
TEST(CallbackListTest,ArityTest)117 TEST(CallbackListTest, ArityTest) {
118 Summer s;
119
120 CallbackList<void(int)> c1;
121 scoped_ptr<CallbackList<void(int)>::Subscription> subscription1 =
122 c1.Add(Bind(&Summer::AddOneParam, Unretained(&s)));
123
124 c1.Notify(1);
125 EXPECT_EQ(1, s.value());
126
127 CallbackList<void(int, int)> c2;
128 scoped_ptr<CallbackList<void(int, int)>::Subscription> subscription2 =
129 c2.Add(Bind(&Summer::AddTwoParam, Unretained(&s)));
130
131 c2.Notify(1, 2);
132 EXPECT_EQ(3, s.value());
133
134 CallbackList<void(int, int, int)> c3;
135 scoped_ptr<CallbackList<void(int, int, int)>::Subscription>
136 subscription3 = c3.Add(Bind(&Summer::AddThreeParam, Unretained(&s)));
137
138 c3.Notify(1, 2, 3);
139 EXPECT_EQ(6, s.value());
140
141 CallbackList<void(int, int, int, int)> c4;
142 scoped_ptr<CallbackList<void(int, int, int, int)>::Subscription>
143 subscription4 = c4.Add(Bind(&Summer::AddFourParam, Unretained(&s)));
144
145 c4.Notify(1, 2, 3, 4);
146 EXPECT_EQ(10, s.value());
147
148 CallbackList<void(int, int, int, int, int)> c5;
149 scoped_ptr<CallbackList<void(int, int, int, int, int)>::Subscription>
150 subscription5 = c5.Add(Bind(&Summer::AddFiveParam, Unretained(&s)));
151
152 c5.Notify(1, 2, 3, 4, 5);
153 EXPECT_EQ(15, s.value());
154
155 CallbackList<void(int, int, int, int, int, int)> c6;
156 scoped_ptr<CallbackList<void(int, int, int, int, int, int)>::Subscription>
157 subscription6 = c6.Add(Bind(&Summer::AddSixParam, Unretained(&s)));
158
159 c6.Notify(1, 2, 3, 4, 5, 6);
160 EXPECT_EQ(21, s.value());
161 }
162
163 // Sanity check that closures added to the list will be run, and those removed
164 // from the list will not be run.
TEST(CallbackListTest,BasicTest)165 TEST(CallbackListTest, BasicTest) {
166 CallbackList<void(void)> cb_reg;
167 Listener a, b, c;
168
169 scoped_ptr<CallbackList<void(void)>::Subscription> a_subscription =
170 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
171 scoped_ptr<CallbackList<void(void)>::Subscription> b_subscription =
172 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
173
174 EXPECT_TRUE(a_subscription.get());
175 EXPECT_TRUE(b_subscription.get());
176
177 cb_reg.Notify();
178
179 EXPECT_EQ(1, a.total());
180 EXPECT_EQ(1, b.total());
181
182 b_subscription.reset();
183
184 scoped_ptr<CallbackList<void(void)>::Subscription> c_subscription =
185 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c)));
186
187 cb_reg.Notify();
188
189 EXPECT_EQ(2, a.total());
190 EXPECT_EQ(1, b.total());
191 EXPECT_EQ(1, c.total());
192
193 a_subscription.reset();
194 b_subscription.reset();
195 c_subscription.reset();
196 }
197
198 // Sanity check that callbacks with details added to the list will be run, with
199 // the correct details, and those removed from the list will not be run.
TEST(CallbackListTest,BasicTestWithParams)200 TEST(CallbackListTest, BasicTestWithParams) {
201 CallbackList<void(int)> cb_reg;
202 Listener a(1), b(-1), c(1);
203
204 scoped_ptr<CallbackList<void(int)>::Subscription> a_subscription =
205 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a)));
206 scoped_ptr<CallbackList<void(int)>::Subscription> b_subscription =
207 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b)));
208
209 EXPECT_TRUE(a_subscription.get());
210 EXPECT_TRUE(b_subscription.get());
211
212 cb_reg.Notify(10);
213
214 EXPECT_EQ(10, a.total());
215 EXPECT_EQ(-10, b.total());
216
217 b_subscription.reset();
218
219 scoped_ptr<CallbackList<void(int)>::Subscription> c_subscription =
220 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c)));
221
222 cb_reg.Notify(10);
223
224 EXPECT_EQ(20, a.total());
225 EXPECT_EQ(-10, b.total());
226 EXPECT_EQ(10, c.total());
227
228 a_subscription.reset();
229 b_subscription.reset();
230 c_subscription.reset();
231 }
232
233 // Test the a callback can remove itself or a different callback from the list
234 // during iteration without invalidating the iterator.
TEST(CallbackListTest,RemoveCallbacksDuringIteration)235 TEST(CallbackListTest, RemoveCallbacksDuringIteration) {
236 CallbackList<void(void)> cb_reg;
237 Listener a, b;
238 Remover remover_1, remover_2;
239
240 scoped_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
241 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
242 Unretained(&remover_1)));
243 scoped_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
244 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
245 Unretained(&remover_2)));
246 scoped_ptr<CallbackList<void(void)>::Subscription> a_subscription =
247 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a)));
248 scoped_ptr<CallbackList<void(void)>::Subscription> b_subscription =
249 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
250
251 // |remover_1| will remove itself.
252 remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
253 // |remover_2| will remove a.
254 remover_2.SetSubscriptionToRemove(std::move(a_subscription));
255
256 cb_reg.Notify();
257
258 // |remover_1| runs once (and removes itself), |remover_2| runs once (and
259 // removes a), |a| never runs, and |b| runs once.
260 EXPECT_EQ(1, remover_1.total());
261 EXPECT_EQ(1, remover_2.total());
262 EXPECT_EQ(0, a.total());
263 EXPECT_EQ(1, b.total());
264
265 cb_reg.Notify();
266
267 // Only |remover_2| and |b| run this time.
268 EXPECT_EQ(1, remover_1.total());
269 EXPECT_EQ(2, remover_2.total());
270 EXPECT_EQ(0, a.total());
271 EXPECT_EQ(2, b.total());
272 }
273
274 // Test that a callback can add another callback to the list durning iteration
275 // without invalidating the iterator. The newly added callback should be run on
276 // the current iteration as will all other callbacks in the list.
TEST(CallbackListTest,AddCallbacksDuringIteration)277 TEST(CallbackListTest, AddCallbacksDuringIteration) {
278 CallbackList<void(void)> cb_reg;
279 Adder a(&cb_reg);
280 Listener b;
281 scoped_ptr<CallbackList<void(void)>::Subscription> a_subscription =
282 cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a)));
283 scoped_ptr<CallbackList<void(void)>::Subscription> b_subscription =
284 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b)));
285
286 cb_reg.Notify();
287
288 EXPECT_EQ(1, a.total());
289 EXPECT_EQ(1, b.total());
290 EXPECT_TRUE(a.added());
291
292 cb_reg.Notify();
293
294 EXPECT_EQ(2, a.total());
295 EXPECT_EQ(2, b.total());
296 }
297
298 // Sanity check: notifying an empty list is a no-op.
TEST(CallbackListTest,EmptyList)299 TEST(CallbackListTest, EmptyList) {
300 CallbackList<void(void)> cb_reg;
301
302 cb_reg.Notify();
303 }
304
TEST(CallbackList,RemovalCallback)305 TEST(CallbackList, RemovalCallback) {
306 Counter remove_count;
307 CallbackList<void(void)> cb_reg;
308 cb_reg.set_removal_callback(
309 Bind(&Counter::Increment, Unretained(&remove_count)));
310
311 scoped_ptr<CallbackList<void(void)>::Subscription> subscription =
312 cb_reg.Add(Bind(&DoNothing));
313
314 // Removing a subscription outside of iteration signals the callback.
315 EXPECT_EQ(0, remove_count.value());
316 subscription.reset();
317 EXPECT_EQ(1, remove_count.value());
318
319 // Configure two subscriptions to remove themselves.
320 Remover remover_1, remover_2;
321 scoped_ptr<CallbackList<void(void)>::Subscription> remover_1_sub =
322 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
323 Unretained(&remover_1)));
324 scoped_ptr<CallbackList<void(void)>::Subscription> remover_2_sub =
325 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove,
326 Unretained(&remover_2)));
327 remover_1.SetSubscriptionToRemove(std::move(remover_1_sub));
328 remover_2.SetSubscriptionToRemove(std::move(remover_2_sub));
329
330 // The callback should be signaled exactly once.
331 EXPECT_EQ(1, remove_count.value());
332 cb_reg.Notify();
333 EXPECT_EQ(2, remove_count.value());
334 EXPECT_TRUE(cb_reg.empty());
335 }
336
337 } // namespace
338 } // namespace base
339