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 <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 pool_owner_.pool()->FlushForTesting(); | 57 pool_owner_.pool()->FlushForTesting(); |
58 } | 58 } |
59 | 59 |
60 private: | 60 private: |
61 MessageLoop message_loop_; // Needed by SequencedWorkerPool to function. | 61 MessageLoop message_loop_; // Needed by SequencedWorkerPool to function. |
62 SequencedWorkerPoolOwner pool_owner_; | 62 SequencedWorkerPoolOwner pool_owner_; |
63 | 63 |
64 DISALLOW_COPY_AND_ASSIGN(SequenceCheckerTest); | 64 DISALLOW_COPY_AND_ASSIGN(SequenceCheckerTest); |
65 }; | 65 }; |
66 | 66 |
67 void ExpectCalledOnValidSequencedThread(SequenceCheckerImpl* sequence_checker) { | 67 void ExpectCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) { |
68 ASSERT_TRUE(sequence_checker); | 68 ASSERT_TRUE(sequence_checker); |
69 | 69 |
70 // This should bind |sequence_checker| to the current sequence if it wasn't | 70 // This should bind |sequence_checker| to the current sequence if it wasn't |
71 // already bound to a sequence. | 71 // already bound to a sequence. |
72 EXPECT_TRUE(sequence_checker->CalledOnValidSequencedThread()); | 72 EXPECT_TRUE(sequence_checker->CalledOnValidSequence()); |
73 | 73 |
74 // Since |sequence_checker| is now bound to the current sequence, another call | 74 // Since |sequence_checker| is now bound to the current sequence, another call |
75 // to CalledOnValidSequencedThread() should return true. | 75 // to CalledOnValidSequence() should return true. |
76 EXPECT_TRUE(sequence_checker->CalledOnValidSequencedThread()); | 76 EXPECT_TRUE(sequence_checker->CalledOnValidSequence()); |
77 } | 77 } |
78 | 78 |
79 void ExpectCalledOnValidSequencedThreadWithSequenceToken( | 79 void ExpectCalledOnValidSequenceWithSequenceToken( |
80 SequenceCheckerImpl* sequence_checker, | 80 SequenceCheckerImpl* sequence_checker, |
81 SequenceToken sequence_token) { | 81 SequenceToken sequence_token) { |
82 ScopedSetSequenceTokenForCurrentThread | 82 ScopedSetSequenceTokenForCurrentThread |
83 scoped_set_sequence_token_for_current_thread(sequence_token); | 83 scoped_set_sequence_token_for_current_thread(sequence_token); |
84 ExpectCalledOnValidSequencedThread(sequence_checker); | 84 ExpectCalledOnValidSequence(sequence_checker); |
85 } | 85 } |
86 | 86 |
87 void ExpectNotCalledOnValidSequencedThread( | 87 void ExpectNotCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) { |
88 SequenceCheckerImpl* sequence_checker) { | |
89 ASSERT_TRUE(sequence_checker); | 88 ASSERT_TRUE(sequence_checker); |
90 EXPECT_FALSE(sequence_checker->CalledOnValidSequencedThread()); | 89 EXPECT_FALSE(sequence_checker->CalledOnValidSequence()); |
91 } | 90 } |
92 | 91 |
93 } // namespace | 92 } // namespace |
94 | 93 |
95 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThreadNoSequenceToken) { | 94 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThreadNoSequenceToken) { |
96 SequenceCheckerImpl sequence_checker; | 95 SequenceCheckerImpl sequence_checker; |
97 EXPECT_TRUE(sequence_checker.CalledOnValidSequencedThread()); | 96 EXPECT_TRUE(sequence_checker.CalledOnValidSequence()); |
98 } | 97 } |
99 | 98 |
100 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThreadSameSequenceToken) { | 99 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThreadSameSequenceToken) { |
101 ScopedSetSequenceTokenForCurrentThread | 100 ScopedSetSequenceTokenForCurrentThread |
102 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); | 101 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); |
103 SequenceCheckerImpl sequence_checker; | 102 SequenceCheckerImpl sequence_checker; |
104 EXPECT_TRUE(sequence_checker.CalledOnValidSequencedThread()); | 103 EXPECT_TRUE(sequence_checker.CalledOnValidSequence()); |
105 } | 104 } |
106 | 105 |
107 TEST_F(SequenceCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) { | 106 TEST_F(SequenceCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) { |
108 SequenceCheckerImpl sequence_checker; | 107 SequenceCheckerImpl sequence_checker; |
109 RunCallbackThread thread(Bind(&ExpectNotCalledOnValidSequencedThread, | 108 RunCallbackThread thread( |
110 Unretained(&sequence_checker))); | 109 Bind(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker))); |
111 } | 110 } |
112 | 111 |
113 TEST_F(SequenceCheckerTest, CallsAllowedOnDifferentThreadsSameSequenceToken) { | 112 TEST_F(SequenceCheckerTest, CallsAllowedOnDifferentThreadsSameSequenceToken) { |
114 const SequenceToken sequence_token(SequenceToken::Create()); | 113 const SequenceToken sequence_token(SequenceToken::Create()); |
115 | 114 |
116 ScopedSetSequenceTokenForCurrentThread | 115 ScopedSetSequenceTokenForCurrentThread |
117 scoped_set_sequence_token_for_current_thread(sequence_token); | 116 scoped_set_sequence_token_for_current_thread(sequence_token); |
118 SequenceCheckerImpl sequence_checker; | 117 SequenceCheckerImpl sequence_checker; |
119 EXPECT_TRUE(sequence_checker.CalledOnValidSequencedThread()); | 118 EXPECT_TRUE(sequence_checker.CalledOnValidSequence()); |
120 | 119 |
121 RunCallbackThread thread( | 120 RunCallbackThread thread(Bind(&ExpectCalledOnValidSequenceWithSequenceToken, |
122 Bind(&ExpectCalledOnValidSequencedThreadWithSequenceToken, | 121 Unretained(&sequence_checker), sequence_token)); |
123 Unretained(&sequence_checker), sequence_token)); | |
124 } | 122 } |
125 | 123 |
126 TEST_F(SequenceCheckerTest, CallsDisallowedOnSameThreadDifferentSequenceToken) { | 124 TEST_F(SequenceCheckerTest, CallsDisallowedOnSameThreadDifferentSequenceToken) { |
127 std::unique_ptr<SequenceCheckerImpl> sequence_checker; | 125 std::unique_ptr<SequenceCheckerImpl> sequence_checker; |
128 | 126 |
129 { | 127 { |
130 ScopedSetSequenceTokenForCurrentThread | 128 ScopedSetSequenceTokenForCurrentThread |
131 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); | 129 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); |
132 sequence_checker.reset(new SequenceCheckerImpl); | 130 sequence_checker.reset(new SequenceCheckerImpl); |
133 } | 131 } |
134 | 132 |
135 { | 133 { |
136 // Different SequenceToken. | 134 // Different SequenceToken. |
137 ScopedSetSequenceTokenForCurrentThread | 135 ScopedSetSequenceTokenForCurrentThread |
138 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); | 136 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); |
139 EXPECT_FALSE(sequence_checker->CalledOnValidSequencedThread()); | 137 EXPECT_FALSE(sequence_checker->CalledOnValidSequence()); |
140 } | 138 } |
141 | 139 |
142 // No SequenceToken. | 140 // No SequenceToken. |
143 EXPECT_FALSE(sequence_checker->CalledOnValidSequencedThread()); | 141 EXPECT_FALSE(sequence_checker->CalledOnValidSequence()); |
144 } | 142 } |
145 | 143 |
146 TEST_F(SequenceCheckerTest, DetachFromSequence) { | 144 TEST_F(SequenceCheckerTest, DetachFromSequence) { |
147 std::unique_ptr<SequenceCheckerImpl> sequence_checker; | 145 std::unique_ptr<SequenceCheckerImpl> sequence_checker; |
148 | 146 |
149 { | 147 { |
150 ScopedSetSequenceTokenForCurrentThread | 148 ScopedSetSequenceTokenForCurrentThread |
151 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); | 149 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); |
152 sequence_checker.reset(new SequenceCheckerImpl); | 150 sequence_checker.reset(new SequenceCheckerImpl); |
153 } | 151 } |
154 | 152 |
155 sequence_checker->DetachFromSequence(); | 153 sequence_checker->DetachFromSequence(); |
156 | 154 |
157 { | 155 { |
158 // Verify that CalledOnValidSequencedThread() returns true when called with | 156 // Verify that CalledOnValidSequence() returns true when called with |
159 // a different sequence token after a call to DetachFromSequence(). | 157 // a different sequence token after a call to DetachFromSequence(). |
160 ScopedSetSequenceTokenForCurrentThread | 158 ScopedSetSequenceTokenForCurrentThread |
161 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); | 159 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); |
162 EXPECT_TRUE(sequence_checker->CalledOnValidSequencedThread()); | 160 EXPECT_TRUE(sequence_checker->CalledOnValidSequence()); |
163 } | 161 } |
164 } | 162 } |
165 | 163 |
166 TEST_F(SequenceCheckerTest, DetachFromSequenceNoSequenceToken) { | 164 TEST_F(SequenceCheckerTest, DetachFromSequenceNoSequenceToken) { |
167 SequenceCheckerImpl sequence_checker; | 165 SequenceCheckerImpl sequence_checker; |
168 sequence_checker.DetachFromSequence(); | 166 sequence_checker.DetachFromSequence(); |
169 | 167 |
170 // Verify that CalledOnValidSequencedThread() returns true when called on a | 168 // Verify that CalledOnValidSequence() returns true when called on a |
171 // different thread after a call to DetachFromSequence(). | 169 // different thread after a call to DetachFromSequence(). |
172 RunCallbackThread thread( | 170 RunCallbackThread thread( |
173 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker))); | 171 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker))); |
174 | 172 |
175 EXPECT_FALSE(sequence_checker.CalledOnValidSequencedThread()); | 173 EXPECT_FALSE(sequence_checker.CalledOnValidSequence()); |
176 } | 174 } |
177 | 175 |
178 TEST_F(SequenceCheckerTest, SequencedWorkerPool_SameSequenceTokenValid) { | 176 TEST_F(SequenceCheckerTest, SequencedWorkerPool_SameSequenceTokenValid) { |
179 SequenceCheckerImpl sequence_checker; | 177 SequenceCheckerImpl sequence_checker; |
180 sequence_checker.DetachFromSequence(); | 178 sequence_checker.DetachFromSequence(); |
181 | 179 |
182 PostToSequencedWorkerPool( | 180 PostToSequencedWorkerPool( |
183 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 181 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
184 "A"); | |
185 PostToSequencedWorkerPool( | 182 PostToSequencedWorkerPool( |
186 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 183 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
187 "A"); | |
188 FlushSequencedWorkerPoolForTesting(); | 184 FlushSequencedWorkerPoolForTesting(); |
189 } | 185 } |
190 | 186 |
191 TEST_F(SequenceCheckerTest, SequencedWorkerPool_DetachSequenceTokenValid) { | 187 TEST_F(SequenceCheckerTest, SequencedWorkerPool_DetachSequenceTokenValid) { |
192 SequenceCheckerImpl sequence_checker; | 188 SequenceCheckerImpl sequence_checker; |
193 sequence_checker.DetachFromSequence(); | 189 sequence_checker.DetachFromSequence(); |
194 | 190 |
195 PostToSequencedWorkerPool( | 191 PostToSequencedWorkerPool( |
196 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 192 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
197 "A"); | |
198 PostToSequencedWorkerPool( | 193 PostToSequencedWorkerPool( |
199 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 194 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
200 "A"); | |
201 FlushSequencedWorkerPoolForTesting(); | 195 FlushSequencedWorkerPoolForTesting(); |
202 | 196 |
203 sequence_checker.DetachFromSequence(); | 197 sequence_checker.DetachFromSequence(); |
204 | 198 |
205 PostToSequencedWorkerPool( | 199 PostToSequencedWorkerPool( |
206 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 200 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "B"); |
207 "B"); | |
208 PostToSequencedWorkerPool( | 201 PostToSequencedWorkerPool( |
209 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 202 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "B"); |
210 "B"); | |
211 FlushSequencedWorkerPoolForTesting(); | 203 FlushSequencedWorkerPoolForTesting(); |
212 } | 204 } |
213 | 205 |
214 TEST_F(SequenceCheckerTest, | 206 TEST_F(SequenceCheckerTest, |
215 SequencedWorkerPool_DifferentSequenceTokensInvalid) { | 207 SequencedWorkerPool_DifferentSequenceTokensInvalid) { |
216 SequenceCheckerImpl sequence_checker; | 208 SequenceCheckerImpl sequence_checker; |
217 sequence_checker.DetachFromSequence(); | 209 sequence_checker.DetachFromSequence(); |
218 | 210 |
219 PostToSequencedWorkerPool( | 211 PostToSequencedWorkerPool( |
220 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 212 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
221 "A"); | |
222 PostToSequencedWorkerPool( | 213 PostToSequencedWorkerPool( |
223 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 214 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
224 "A"); | |
225 FlushSequencedWorkerPoolForTesting(); | 215 FlushSequencedWorkerPoolForTesting(); |
226 | 216 |
227 PostToSequencedWorkerPool(Bind(&ExpectNotCalledOnValidSequencedThread, | 217 PostToSequencedWorkerPool( |
228 Unretained(&sequence_checker)), | 218 Bind(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker)), |
229 "B"); | 219 "B"); |
230 PostToSequencedWorkerPool(Bind(&ExpectNotCalledOnValidSequencedThread, | 220 PostToSequencedWorkerPool( |
231 Unretained(&sequence_checker)), | 221 Bind(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker)), |
232 "B"); | 222 "B"); |
233 FlushSequencedWorkerPoolForTesting(); | 223 FlushSequencedWorkerPoolForTesting(); |
234 } | 224 } |
235 | 225 |
236 TEST_F(SequenceCheckerTest, | 226 TEST_F(SequenceCheckerTest, |
237 SequencedWorkerPool_WorkerPoolAndSimpleThreadInvalid) { | 227 SequencedWorkerPool_WorkerPoolAndSimpleThreadInvalid) { |
238 SequenceCheckerImpl sequence_checker; | 228 SequenceCheckerImpl sequence_checker; |
239 sequence_checker.DetachFromSequence(); | 229 sequence_checker.DetachFromSequence(); |
240 | 230 |
241 PostToSequencedWorkerPool( | 231 PostToSequencedWorkerPool( |
242 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 232 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
243 "A"); | |
244 PostToSequencedWorkerPool( | 233 PostToSequencedWorkerPool( |
245 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 234 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
246 "A"); | |
247 FlushSequencedWorkerPoolForTesting(); | 235 FlushSequencedWorkerPoolForTesting(); |
248 | 236 |
249 EXPECT_FALSE(sequence_checker.CalledOnValidSequencedThread()); | 237 EXPECT_FALSE(sequence_checker.CalledOnValidSequence()); |
250 } | 238 } |
251 | 239 |
252 TEST_F(SequenceCheckerTest, | 240 TEST_F(SequenceCheckerTest, |
253 SequencedWorkerPool_TwoDifferentWorkerPoolsInvalid) { | 241 SequencedWorkerPool_TwoDifferentWorkerPoolsInvalid) { |
254 SequenceCheckerImpl sequence_checker; | 242 SequenceCheckerImpl sequence_checker; |
255 sequence_checker.DetachFromSequence(); | 243 sequence_checker.DetachFromSequence(); |
256 | 244 |
257 PostToSequencedWorkerPool( | 245 PostToSequencedWorkerPool( |
258 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 246 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
259 "A"); | |
260 PostToSequencedWorkerPool( | 247 PostToSequencedWorkerPool( |
261 Bind(&ExpectCalledOnValidSequencedThread, Unretained(&sequence_checker)), | 248 Bind(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)), "A"); |
262 "A"); | |
263 FlushSequencedWorkerPoolForTesting(); | 249 FlushSequencedWorkerPoolForTesting(); |
264 | 250 |
265 SequencedWorkerPoolOwner second_pool_owner(kNumWorkerThreads, "test2"); | 251 SequencedWorkerPoolOwner second_pool_owner(kNumWorkerThreads, "test2"); |
266 second_pool_owner.pool()->PostNamedSequencedWorkerTask( | 252 second_pool_owner.pool()->PostNamedSequencedWorkerTask( |
267 "A", FROM_HERE, base::Bind(&ExpectNotCalledOnValidSequencedThread, | 253 "A", FROM_HERE, base::Bind(&ExpectNotCalledOnValidSequence, |
268 base::Unretained(&sequence_checker))); | 254 base::Unretained(&sequence_checker))); |
269 second_pool_owner.pool()->FlushForTesting(); | 255 second_pool_owner.pool()->FlushForTesting(); |
270 } | 256 } |
271 | 257 |
272 } // namespace base | 258 } // namespace base |
OLD | NEW |