OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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/cancelable_callback.h" | 5 #include "base/cancelable_callback.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/bind_helpers.h" | 8 #include "base/bind_helpers.h" |
9 #include "base/memory/ref_counted.h" | 9 #include "base/memory/ref_counted.h" |
10 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 | 21 |
22 void Increment(int* count) { (*count)++; } | 22 void Increment(int* count) { (*count)++; } |
23 void IncrementBy(int* count, int n) { (*count) += n; } | 23 void IncrementBy(int* count, int n) { (*count) += n; } |
24 void RefCountedParam(const scoped_refptr<TestRefCounted>& ref_counted) {} | 24 void RefCountedParam(const scoped_refptr<TestRefCounted>& ref_counted) {} |
25 | 25 |
26 // Cancel(). | 26 // Cancel(). |
27 // - Callback can be run multiple times. | 27 // - Callback can be run multiple times. |
28 // - After Cancel(), Run() completes but has no effect. | 28 // - After Cancel(), Run() completes but has no effect. |
29 TEST(CancelableCallbackTest, Cancel) { | 29 TEST(CancelableCallbackTest, Cancel) { |
30 int count = 0; | 30 int count = 0; |
31 CancelableCallback cancelable( | 31 CancelableClosure cancelable( |
32 base::Bind(&Increment, base::Unretained(&count))); | 32 base::Bind(&Increment, base::Unretained(&count))); |
33 | 33 |
34 base::Closure callback = cancelable.callback(); | 34 base::Closure callback = cancelable.callback(); |
35 callback.Run(); | 35 callback.Run(); |
36 EXPECT_EQ(1, count); | 36 EXPECT_EQ(1, count); |
37 | 37 |
38 callback.Run(); | 38 callback.Run(); |
39 EXPECT_EQ(2, count); | 39 EXPECT_EQ(2, count); |
40 | 40 |
41 cancelable.Cancel(); | 41 cancelable.Cancel(); |
42 callback.Run(); | 42 callback.Run(); |
43 EXPECT_EQ(2, count); | 43 EXPECT_EQ(2, count); |
44 } | 44 } |
45 | 45 |
46 // Cancel() called multiple times. | 46 // Cancel() called multiple times. |
47 // - Cancel() cancels all copies of the wrapped callback. | 47 // - Cancel() cancels all copies of the wrapped callback. |
| 48 // - Calling Cancel() more than once has no effect. |
| 49 // - After Cancel(), callback() returns a null callback. |
48 TEST(CancelableCallbackTest, MultipleCancel) { | 50 TEST(CancelableCallbackTest, MultipleCancel) { |
49 int count = 0; | 51 int count = 0; |
50 CancelableCallback cancelable( | 52 CancelableClosure cancelable( |
51 base::Bind(&Increment, base::Unretained(&count))); | 53 base::Bind(&Increment, base::Unretained(&count))); |
52 | 54 |
53 base::Closure callback1 = cancelable.callback(); | 55 base::Closure callback1 = cancelable.callback(); |
| 56 base::Closure callback2 = cancelable.callback(); |
54 cancelable.Cancel(); | 57 cancelable.Cancel(); |
55 | 58 |
56 callback1.Run(); | 59 callback1.Run(); |
57 EXPECT_EQ(0, count); | 60 EXPECT_EQ(0, count); |
58 | 61 |
59 base::Closure callback2 = cancelable.callback(); | |
60 callback2.Run(); | 62 callback2.Run(); |
61 EXPECT_EQ(0, count); | 63 EXPECT_EQ(0, count); |
62 | 64 |
63 // Cancel() should have no effect, but callback() is still runnable. | 65 // Calling Cancel() again has no effect. |
| 66 cancelable.Cancel(); |
| 67 |
| 68 // callback() of a cancelled callback is null. |
64 base::Closure callback3 = cancelable.callback(); | 69 base::Closure callback3 = cancelable.callback(); |
65 cancelable.Cancel(); | 70 EXPECT_TRUE(callback3.is_null()); |
66 callback3.Run(); | |
67 EXPECT_EQ(0, count); | |
68 } | 71 } |
69 | 72 |
70 // CancelableCallback destroyed before callback is run. | 73 // CancelableCallback destroyed before callback is run. |
71 // - Destruction of CancelableCallback cancels outstanding callbacks. | 74 // - Destruction of CancelableCallback cancels outstanding callbacks. |
72 TEST(CancelableCallbackTest, CallbackCanceledOnDestruction) { | 75 TEST(CancelableCallbackTest, CallbackCanceledOnDestruction) { |
73 int count = 0; | 76 int count = 0; |
74 base::Closure callback; | 77 base::Closure callback; |
75 | 78 |
76 { | 79 { |
77 CancelableCallback cancelable( | 80 CancelableClosure cancelable( |
78 base::Bind(&Increment, base::Unretained(&count))); | 81 base::Bind(&Increment, base::Unretained(&count))); |
79 | 82 |
80 callback = cancelable.callback(); | 83 callback = cancelable.callback(); |
81 callback.Run(); | 84 callback.Run(); |
82 EXPECT_EQ(1, count); | 85 EXPECT_EQ(1, count); |
83 } | 86 } |
84 | 87 |
85 callback.Run(); | 88 callback.Run(); |
86 EXPECT_EQ(1, count); | 89 EXPECT_EQ(1, count); |
87 } | 90 } |
88 | 91 |
89 // Cancel() called on bound closure with a RefCounted parameter. | 92 // Cancel() called on bound closure with a RefCounted parameter. |
90 // - Cancel drops wrapped callback (and, implicitly, its bound arguments). | 93 // - Cancel drops wrapped callback (and, implicitly, its bound arguments). |
91 TEST(CancelableCallbackTest, CancelDropsCallback) { | 94 TEST(CancelableCallbackTest, CancelDropsCallback) { |
92 scoped_refptr<TestRefCounted> ref_counted = new TestRefCounted; | 95 scoped_refptr<TestRefCounted> ref_counted = new TestRefCounted; |
93 EXPECT_TRUE(ref_counted->HasOneRef()); | 96 EXPECT_TRUE(ref_counted->HasOneRef()); |
94 | 97 |
95 CancelableCallback cancelable(base::Bind(RefCountedParam, ref_counted)); | 98 CancelableClosure cancelable(base::Bind(RefCountedParam, ref_counted)); |
96 EXPECT_FALSE(cancelable.IsCancelled()); | 99 EXPECT_FALSE(cancelable.IsCancelled()); |
97 EXPECT_TRUE(ref_counted.get()); | 100 EXPECT_TRUE(ref_counted.get()); |
98 EXPECT_FALSE(ref_counted->HasOneRef()); | 101 EXPECT_FALSE(ref_counted->HasOneRef()); |
99 | 102 |
100 // There is only one reference to |ref_counted| after the Cancel(). | 103 // There is only one reference to |ref_counted| after the Cancel(). |
101 cancelable.Cancel(); | 104 cancelable.Cancel(); |
102 EXPECT_TRUE(cancelable.IsCancelled()); | 105 EXPECT_TRUE(cancelable.IsCancelled()); |
103 EXPECT_TRUE(ref_counted.get()); | 106 EXPECT_TRUE(ref_counted.get()); |
104 EXPECT_TRUE(ref_counted->HasOneRef()); | 107 EXPECT_TRUE(ref_counted->HasOneRef()); |
105 } | 108 } |
106 | 109 |
107 // Reset(). | 110 // Reset(). |
108 // - Reset() replaces the existing wrapped callback with a new callback. | 111 // - Reset() replaces the existing wrapped callback with a new callback. |
109 // - Reset() deactivates outstanding callbacks. | 112 // - Reset() deactivates outstanding callbacks. |
110 TEST(CancelableCallbackTest, Reset) { | 113 TEST(CancelableCallbackTest, Reset) { |
111 int count = 0; | 114 int count = 0; |
112 CancelableCallback cancelable( | 115 CancelableClosure cancelable( |
113 base::Bind(&Increment, base::Unretained(&count))); | 116 base::Bind(&Increment, base::Unretained(&count))); |
114 | 117 |
115 base::Closure callback = cancelable.callback(); | 118 base::Closure callback = cancelable.callback(); |
116 callback.Run(); | 119 callback.Run(); |
117 EXPECT_EQ(1, count); | 120 EXPECT_EQ(1, count); |
118 | 121 |
119 callback.Run(); | 122 callback.Run(); |
120 EXPECT_EQ(2, count); | 123 EXPECT_EQ(2, count); |
121 | 124 |
122 cancelable.Reset( | 125 cancelable.Reset( |
(...skipping 10 matching lines...) Expand all Loading... |
133 base::Closure callback2 = cancelable.callback(); | 136 base::Closure callback2 = cancelable.callback(); |
134 ASSERT_FALSE(callback2.is_null()); | 137 ASSERT_FALSE(callback2.is_null()); |
135 | 138 |
136 callback2.Run(); | 139 callback2.Run(); |
137 EXPECT_EQ(5, count); | 140 EXPECT_EQ(5, count); |
138 } | 141 } |
139 | 142 |
140 // IsCanceled(). | 143 // IsCanceled(). |
141 // - Cancel() transforms the CancelableCallback into a cancelled state. | 144 // - Cancel() transforms the CancelableCallback into a cancelled state. |
142 TEST(CancelableCallbackTest, IsNull) { | 145 TEST(CancelableCallbackTest, IsNull) { |
143 CancelableCallback cancelable; | 146 CancelableClosure cancelable; |
144 EXPECT_TRUE(cancelable.IsCancelled()); | 147 EXPECT_TRUE(cancelable.IsCancelled()); |
145 | 148 |
146 int count = 0; | 149 int count = 0; |
147 cancelable.Reset(base::Bind(&Increment, | 150 cancelable.Reset(base::Bind(&Increment, |
148 base::Unretained(&count))); | 151 base::Unretained(&count))); |
149 EXPECT_FALSE(cancelable.IsCancelled()); | 152 EXPECT_FALSE(cancelable.IsCancelled()); |
150 | 153 |
151 cancelable.Cancel(); | 154 cancelable.Cancel(); |
152 EXPECT_TRUE(cancelable.IsCancelled()); | 155 EXPECT_TRUE(cancelable.IsCancelled()); |
153 } | 156 } |
154 | 157 |
155 // CancelableCallback posted to a MessageLoop with PostTask. | 158 // CancelableCallback posted to a MessageLoop with PostTask. |
156 // - Callbacks posted to a MessageLoop can be cancelled. | 159 // - Callbacks posted to a MessageLoop can be cancelled. |
157 TEST(CancelableCallbackTest, PostTask) { | 160 TEST(CancelableCallbackTest, PostTask) { |
158 MessageLoop loop(MessageLoop::TYPE_DEFAULT); | 161 MessageLoop loop(MessageLoop::TYPE_DEFAULT); |
159 | 162 |
160 int count = 0; | 163 int count = 0; |
161 CancelableCallback cancelable(base::Bind(&Increment, | 164 CancelableClosure cancelable(base::Bind(&Increment, |
162 base::Unretained(&count))); | 165 base::Unretained(&count))); |
163 | 166 |
164 MessageLoop::current()->PostTask(FROM_HERE, cancelable.callback()); | 167 MessageLoop::current()->PostTask(FROM_HERE, cancelable.callback()); |
165 MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); | 168 MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); |
166 MessageLoop::current()->Run(); | 169 MessageLoop::current()->Run(); |
167 | 170 |
168 EXPECT_EQ(1, count); | 171 EXPECT_EQ(1, count); |
169 | 172 |
170 MessageLoop::current()->PostTask(FROM_HERE, cancelable.callback()); | 173 MessageLoop::current()->PostTask(FROM_HERE, cancelable.callback()); |
171 MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); | 174 MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure()); |
172 | 175 |
173 // Cancel before running the message loop. | 176 // Cancel before running the message loop. |
174 cancelable.Cancel(); | 177 cancelable.Cancel(); |
175 MessageLoop::current()->Run(); | 178 MessageLoop::current()->Run(); |
176 | 179 |
177 // Callback never ran due to cancellation; count is the same. | 180 // Callback never ran due to cancellation; count is the same. |
178 EXPECT_EQ(1, count); | 181 EXPECT_EQ(1, count); |
179 } | 182 } |
180 | 183 |
181 } // namespace | 184 } // namespace |
182 } // namespace base | 185 } // namespace base |
OLD | NEW |