OLD | NEW |
(Empty) | |
| 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_registry.h" |
| 6 |
| 7 #include "base/basictypes.h" |
| 8 #include "base/bind.h" |
| 9 #include "base/bind_helpers.h" |
| 10 #include "base/memory/scoped_ptr.h" |
| 11 #include "testing/gtest/include/gtest/gtest.h" |
| 12 |
| 13 namespace base { |
| 14 namespace { |
| 15 |
| 16 class Listener { |
| 17 public: |
| 18 Listener() : total_(0), scaler_(1) {} |
| 19 explicit Listener(int scaler) : total_(0), scaler_(scaler) {} |
| 20 void IncrementTotal() { total_++; } |
| 21 void IncrementByMultipleOfScaler(const int& x) { total_ += x * scaler_; } |
| 22 |
| 23 int total_; |
| 24 |
| 25 private: |
| 26 int scaler_; |
| 27 DISALLOW_COPY_AND_ASSIGN(Listener); |
| 28 }; |
| 29 |
| 30 class Remover { |
| 31 public: |
| 32 Remover() : total_(0) {} |
| 33 void IncrementTotalAndRemove() { |
| 34 total_++; |
| 35 removal_subscription_.reset(); |
| 36 } |
| 37 void SetSubscriptionToRemove( |
| 38 scoped_ptr<CallbackRegistry<void>::Subscription> sub) { |
| 39 removal_subscription_ = sub.Pass(); |
| 40 } |
| 41 |
| 42 int total_; |
| 43 |
| 44 private: |
| 45 scoped_ptr<CallbackRegistry<void>::Subscription> removal_subscription_; |
| 46 DISALLOW_COPY_AND_ASSIGN(Remover); |
| 47 }; |
| 48 |
| 49 class Adder { |
| 50 public: |
| 51 explicit Adder(CallbackRegistry<void>* cb_reg) |
| 52 : added_(false), |
| 53 total_(0), |
| 54 cb_reg_(cb_reg) {} |
| 55 void AddCallback() { |
| 56 if (!added_) { |
| 57 added_ = true; |
| 58 subscription_ = |
| 59 cb_reg_->Add(Bind(&Adder::IncrementTotal, Unretained(this))); |
| 60 } |
| 61 } |
| 62 void IncrementTotal() { total_++; } |
| 63 |
| 64 bool added_; |
| 65 int total_; |
| 66 |
| 67 private: |
| 68 CallbackRegistry<void>* cb_reg_; |
| 69 scoped_ptr<CallbackRegistry<void>::Subscription> subscription_; |
| 70 DISALLOW_COPY_AND_ASSIGN(Adder); |
| 71 }; |
| 72 |
| 73 // Sanity check that closures added to the list will be run, and those removed |
| 74 // from the list will not be run. |
| 75 TEST(CallbackRegistryTest, BasicTest) { |
| 76 CallbackRegistry<void> cb_reg; |
| 77 Listener a, b, c; |
| 78 |
| 79 scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription = |
| 80 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a))); |
| 81 scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription = |
| 82 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); |
| 83 |
| 84 EXPECT_TRUE(a_subscription.get()); |
| 85 EXPECT_TRUE(b_subscription.get()); |
| 86 |
| 87 cb_reg.Notify(); |
| 88 |
| 89 EXPECT_EQ(1, a.total_); |
| 90 EXPECT_EQ(1, b.total_); |
| 91 |
| 92 b_subscription.reset(); |
| 93 |
| 94 scoped_ptr<CallbackRegistry<void>::Subscription> c_subscription = |
| 95 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&c))); |
| 96 |
| 97 cb_reg.Notify(); |
| 98 |
| 99 EXPECT_EQ(2, a.total_); |
| 100 EXPECT_EQ(1, b.total_); |
| 101 EXPECT_EQ(1, c.total_); |
| 102 |
| 103 a_subscription.reset(); |
| 104 b_subscription.reset(); |
| 105 c_subscription.reset(); |
| 106 } |
| 107 |
| 108 // 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. |
| 110 TEST(CallbackRegistryTest, BasicTestWithParams) { |
| 111 CallbackRegistry<int> cb_reg; |
| 112 Listener a(1), b(-1), c(1); |
| 113 |
| 114 scoped_ptr<CallbackRegistry<int>::Subscription> a_subscription = |
| 115 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&a))); |
| 116 scoped_ptr<CallbackRegistry<int>::Subscription> b_subscription = |
| 117 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&b))); |
| 118 |
| 119 EXPECT_TRUE(a_subscription.get()); |
| 120 EXPECT_TRUE(b_subscription.get()); |
| 121 |
| 122 cb_reg.Notify(10); |
| 123 |
| 124 EXPECT_EQ(10, a.total_); |
| 125 EXPECT_EQ(-10, b.total_); |
| 126 |
| 127 b_subscription.reset(); |
| 128 |
| 129 scoped_ptr<CallbackRegistry<int>::Subscription> c_subscription = |
| 130 cb_reg.Add(Bind(&Listener::IncrementByMultipleOfScaler, Unretained(&c))); |
| 131 |
| 132 cb_reg.Notify(10); |
| 133 |
| 134 EXPECT_EQ(20, a.total_); |
| 135 EXPECT_EQ(-10, b.total_); |
| 136 EXPECT_EQ(10, c.total_); |
| 137 |
| 138 a_subscription.reset(); |
| 139 b_subscription.reset(); |
| 140 c_subscription.reset(); |
| 141 } |
| 142 |
| 143 // Test the a callback can remove itself or a different callback from the list |
| 144 // during iteration without invalidating the iterator. |
| 145 TEST(CallbackRegistryTest, RemoveCallbacksDuringIteration) { |
| 146 CallbackRegistry<void> cb_reg; |
| 147 Listener a, b; |
| 148 Remover remover_1, remover_2; |
| 149 |
| 150 scoped_ptr<CallbackRegistry<void>::Subscription> remover_1_subscription = |
| 151 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove, |
| 152 Unretained(&remover_1))); |
| 153 scoped_ptr<CallbackRegistry<void>::Subscription> remover_2_subscription = |
| 154 cb_reg.Add(Bind(&Remover::IncrementTotalAndRemove, |
| 155 Unretained(&remover_2))); |
| 156 scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription = |
| 157 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&a))); |
| 158 scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription = |
| 159 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); |
| 160 |
| 161 // |remover_1| will remove itself. |
| 162 remover_1.SetSubscriptionToRemove(remover_1_subscription.Pass()); |
| 163 // |remover_2| will remove a. |
| 164 remover_2.SetSubscriptionToRemove(a_subscription.Pass()); |
| 165 |
| 166 cb_reg.Notify(); |
| 167 |
| 168 // |remover_1| runs once (and removes itself), |remover_2| runs once (and |
| 169 // removes a), |a| never runs, and |b| runs once. |
| 170 EXPECT_EQ(1, remover_1.total_); |
| 171 EXPECT_EQ(1, remover_2.total_); |
| 172 EXPECT_EQ(0, a.total_); |
| 173 EXPECT_EQ(1, b.total_); |
| 174 |
| 175 cb_reg.Notify(); |
| 176 |
| 177 // Only |remover_2| and |b| run this time. |
| 178 EXPECT_EQ(1, remover_1.total_); |
| 179 EXPECT_EQ(2, remover_2.total_); |
| 180 EXPECT_EQ(0, a.total_); |
| 181 EXPECT_EQ(2, b.total_); |
| 182 } |
| 183 |
| 184 // 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 |
| 186 // the current iteration as will all other callbacks in the list. |
| 187 TEST(CallbackRegistryTest, AddCallbacksDuringIteration) { |
| 188 CallbackRegistry<void> cb_reg; |
| 189 Adder a(&cb_reg); |
| 190 Listener b; |
| 191 scoped_ptr<CallbackRegistry<void>::Subscription> a_subscription = |
| 192 cb_reg.Add(Bind(&Adder::AddCallback, Unretained(&a))); |
| 193 scoped_ptr<CallbackRegistry<void>::Subscription> b_subscription = |
| 194 cb_reg.Add(Bind(&Listener::IncrementTotal, Unretained(&b))); |
| 195 |
| 196 cb_reg.Notify(); |
| 197 |
| 198 EXPECT_EQ(1, a.total_); |
| 199 EXPECT_EQ(1, b.total_); |
| 200 EXPECT_TRUE(a.added_); |
| 201 |
| 202 cb_reg.Notify(); |
| 203 |
| 204 EXPECT_EQ(2, a.total_); |
| 205 EXPECT_EQ(2, b.total_); |
| 206 } |
| 207 |
| 208 // Sanity check: notifying an empty list is a no-op. |
| 209 TEST(CallbackRegistryTest, EmptyList) { |
| 210 CallbackRegistry<void> cb_reg; |
| 211 |
| 212 cb_reg.Notify(); |
| 213 } |
| 214 |
| 215 } // namespace |
| 216 } // namespace base |
OLD | NEW |