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 "cc/resources/worker_pool.h" | 5 #include "cc/resources/worker_pool.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/memory/scoped_vector.h" | |
9 #include "cc/base/completion_event.h" | 10 #include "cc/base/completion_event.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 11 #include "testing/gtest/include/gtest/gtest.h" |
11 | 12 |
12 namespace cc { | 13 namespace cc { |
13 | 14 |
14 namespace { | 15 namespace { |
15 | 16 |
17 const int kWorkerPoolCount = 3; | |
18 | |
16 class FakeWorkerPoolTaskImpl : public internal::WorkerPoolTask { | 19 class FakeWorkerPoolTaskImpl : public internal::WorkerPoolTask { |
17 public: | 20 public: |
18 FakeWorkerPoolTaskImpl(const base::Closure& callback, | 21 FakeWorkerPoolTaskImpl(const base::Closure& callback, |
19 const base::Closure& reply) | 22 const base::Closure& reply) |
20 : callback_(callback), | 23 : callback_(callback), |
21 reply_(reply) { | 24 reply_(reply) { |
22 } | 25 } |
23 | 26 |
24 // Overridden from internal::WorkerPoolTask: | 27 // Overridden from internal::WorkerPoolTask: |
25 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { | 28 virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE { |
(...skipping 27 matching lines...) Expand all Loading... | |
53 dependent_count(dependent_count), | 56 dependent_count(dependent_count), |
54 priority(priority) { | 57 priority(priority) { |
55 } | 58 } |
56 | 59 |
57 base::Closure callback; | 60 base::Closure callback; |
58 base::Closure reply; | 61 base::Closure reply; |
59 base::Closure dependent; | 62 base::Closure dependent; |
60 unsigned dependent_count; | 63 unsigned dependent_count; |
61 unsigned priority; | 64 unsigned priority; |
62 }; | 65 }; |
63 FakeWorkerPool() : WorkerPool(1, "test") {} | 66 FakeWorkerPool() : WorkerPool() {} |
64 virtual ~FakeWorkerPool() {} | 67 virtual ~FakeWorkerPool() {} |
65 | 68 |
66 static scoped_ptr<FakeWorkerPool> Create() { | 69 static scoped_ptr<FakeWorkerPool> Create() { |
67 return make_scoped_ptr(new FakeWorkerPool); | 70 return make_scoped_ptr(new FakeWorkerPool); |
68 } | 71 } |
69 | 72 |
70 void ScheduleTasks(const std::vector<Task>& tasks) { | 73 void ScheduleTasks(const std::vector<Task>& tasks) { |
71 TaskVector new_tasks; | 74 TaskVector new_tasks; |
72 TaskVector new_dependents; | 75 TaskVector new_dependents; |
73 TaskGraph new_graph; | 76 TaskGraph new_graph; |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
137 DISALLOW_COPY_AND_ASSIGN(FakeWorkerPool); | 140 DISALLOW_COPY_AND_ASSIGN(FakeWorkerPool); |
138 }; | 141 }; |
139 | 142 |
140 class WorkerPoolTest : public testing::Test { | 143 class WorkerPoolTest : public testing::Test { |
141 public: | 144 public: |
142 WorkerPoolTest() {} | 145 WorkerPoolTest() {} |
143 virtual ~WorkerPoolTest() {} | 146 virtual ~WorkerPoolTest() {} |
144 | 147 |
145 // Overridden from testing::Test: | 148 // Overridden from testing::Test: |
146 virtual void SetUp() OVERRIDE { | 149 virtual void SetUp() OVERRIDE { |
147 worker_pool_ = FakeWorkerPool::Create(); | 150 for (int i = 0; i < kWorkerPoolCount; ++i) |
151 worker_pools_.push_back(FakeWorkerPool::Create().release()); | |
reveman
2014/01/14 07:35:44
nit: push_back(Create().release()) is awkward. Cou
sohanjg
2014/01/14 08:10:00
Done.
| |
148 } | 152 } |
149 virtual void TearDown() OVERRIDE { | 153 virtual void TearDown() OVERRIDE { |
150 worker_pool_->Shutdown(); | 154 for (int i = 0; i < kWorkerPoolCount; ++i) { |
151 worker_pool_->CheckForCompletedTasks(); | 155 worker_pools_[i]->Shutdown(); |
152 } | 156 worker_pools_[i]->CheckForCompletedTasks(); |
153 | 157 } |
154 void ResetIds() { | 158 } |
155 run_task_ids_.clear(); | 159 |
156 on_task_completed_ids_.clear(); | 160 void ResetIAllWorkerPoolds() { |
reveman
2014/01/14 07:35:44
Typo in function name: s/ResetIAllWorkerPoolds/Res
sohanjg
2014/01/14 08:10:00
Done.
| |
157 } | 161 for (int i = 0; i < kWorkerPoolCount; ++i) { |
158 | 162 run_task_ids_[i].clear(); |
159 void RunAllTasks() { | 163 on_task_completed_ids_[i].clear(); |
160 worker_pool_->WaitForTasksToComplete(); | 164 } |
161 worker_pool_->CheckForCompletedTasks(); | 165 } |
162 } | 166 |
163 | 167 void RunAllTasksforWorkerPool(int worker_pool_index) { |
164 FakeWorkerPool* worker_pool() { | 168 worker_pools_[worker_pool_index]->WaitForTasksToComplete(); |
165 return worker_pool_.get(); | 169 worker_pools_[worker_pool_index]->CheckForCompletedTasks(); |
166 } | 170 } |
167 | 171 |
168 void RunTask(unsigned id) { | 172 FakeWorkerPool* worker_pool(int worker_pool_index) { |
169 run_task_ids_.push_back(id); | 173 return worker_pools_[worker_pool_index]; |
170 } | 174 } |
171 | 175 |
172 void OnTaskCompleted(unsigned id) { | 176 void RunTask(int worker_pool_index, unsigned id) { |
173 on_task_completed_ids_.push_back(id); | 177 run_task_ids_[worker_pool_index].push_back(id); |
174 } | 178 } |
175 | 179 |
176 const std::vector<unsigned>& run_task_ids() { | 180 void OnTaskCompleted(int worker_pool_index, unsigned id) { |
177 return run_task_ids_; | 181 on_task_completed_ids_[worker_pool_index].push_back(id); |
178 } | 182 } |
179 | 183 |
180 const std::vector<unsigned>& on_task_completed_ids() { | 184 const std::vector<unsigned>& run_task_ids(int worker_pool_index) { |
181 return on_task_completed_ids_; | 185 return run_task_ids_[worker_pool_index]; |
186 } | |
187 | |
188 const std::vector<unsigned>& on_task_completed_ids(int worker_pool_index) { | |
189 return on_task_completed_ids_[worker_pool_index]; | |
182 } | 190 } |
183 | 191 |
184 private: | 192 private: |
185 scoped_ptr<FakeWorkerPool> worker_pool_; | 193 ScopedVector<FakeWorkerPool> worker_pools_; |
186 std::vector<unsigned> run_task_ids_; | 194 std::vector<unsigned> run_task_ids_[kWorkerPoolCount]; |
187 std::vector<unsigned> on_task_completed_ids_; | 195 std::vector<unsigned> on_task_completed_ids_[kWorkerPoolCount]; |
188 }; | 196 }; |
189 | 197 |
190 TEST_F(WorkerPoolTest, Basic) { | 198 TEST_F(WorkerPoolTest, Basic) { |
191 EXPECT_EQ(0u, run_task_ids().size()); | 199 for (int i = 0; i < kWorkerPoolCount; ++i) { |
192 EXPECT_EQ(0u, on_task_completed_ids().size()); | 200 EXPECT_EQ(0u, run_task_ids(i).size()); |
193 | 201 EXPECT_EQ(0u, on_task_completed_ids(i).size()); |
194 worker_pool()->ScheduleTasks( | 202 |
195 std::vector<FakeWorkerPool::Task>( | 203 worker_pool(i)->ScheduleTasks( |
196 1, | 204 std::vector<FakeWorkerPool::Task>( |
197 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 205 1, |
198 base::Unretained(this), | 206 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
199 0u), | 207 base::Unretained(this), |
200 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 208 i, |
201 base::Unretained(this), | 209 0u), |
202 0u), | 210 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
203 base::Closure(), | 211 base::Unretained(this), |
204 1u, | 212 i, |
205 0u))); | 213 0u), |
206 RunAllTasks(); | 214 base::Closure(), |
207 | 215 1u, |
208 EXPECT_EQ(1u, run_task_ids().size()); | 216 0u))); |
209 EXPECT_EQ(1u, on_task_completed_ids().size()); | 217 } |
reveman
2014/01/14 07:35:44
nit: think blank line after this would look better
sohanjg
2014/01/14 08:10:00
Done.
| |
210 | 218 for (int i = 0; i < kWorkerPoolCount; ++i) { |
211 worker_pool()->ScheduleTasks( | 219 RunAllTasksforWorkerPool(i); |
212 std::vector<FakeWorkerPool::Task>( | 220 |
213 1, | 221 EXPECT_EQ(1u, run_task_ids(i).size()); |
214 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 222 EXPECT_EQ(1u, on_task_completed_ids(i).size()); |
215 base::Unretained(this), | 223 } |
216 0u), | 224 |
217 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 225 for (int i = 0; i < kWorkerPoolCount; ++i) { |
218 base::Unretained(this), | 226 worker_pool(i)->ScheduleTasks( |
219 0u), | 227 std::vector<FakeWorkerPool::Task>( |
220 base::Bind(&WorkerPoolTest::RunTask, | 228 1, |
221 base::Unretained(this), | 229 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
222 0u), | 230 base::Unretained(this), |
223 1u, | 231 i, |
224 0u))); | 232 0u), |
225 RunAllTasks(); | 233 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
226 | 234 base::Unretained(this), |
227 EXPECT_EQ(3u, run_task_ids().size()); | 235 i, |
228 EXPECT_EQ(2u, on_task_completed_ids().size()); | 236 0u), |
229 | 237 base::Bind(&WorkerPoolTest::RunTask, |
230 worker_pool()->ScheduleTasks( | 238 base::Unretained(this), |
231 std::vector<FakeWorkerPool::Task>( | 239 i, |
232 1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 240 0u), |
233 base::Unretained(this), | 241 1u, |
234 0u), | 242 0u))); |
235 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 243 } |
reveman
2014/01/14 07:35:44
nit: and blank line here
sohanjg
2014/01/14 08:10:00
Done.
| |
236 base::Unretained(this), | 244 for (int i = 0; i < kWorkerPoolCount; ++i) { |
237 0u), | 245 RunAllTasksforWorkerPool(i); |
238 base::Bind(&WorkerPoolTest::RunTask, | 246 |
239 base::Unretained(this), | 247 EXPECT_EQ(3u, run_task_ids(i).size()); |
240 0u), | 248 EXPECT_EQ(2u, on_task_completed_ids(i).size()); |
241 2u, | 249 } |
242 0u))); | 250 |
243 RunAllTasks(); | 251 for (int i = 0; i < kWorkerPoolCount; ++i) { |
244 | 252 worker_pool(i)->ScheduleTasks( |
245 EXPECT_EQ(6u, run_task_ids().size()); | 253 std::vector<FakeWorkerPool::Task>( |
246 EXPECT_EQ(3u, on_task_completed_ids().size()); | 254 1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
255 base::Unretained(this), | |
256 i, | |
257 0u), | |
258 base::Bind(&WorkerPoolTest::OnTaskCompleted, | |
259 base::Unretained(this), | |
260 i, | |
261 0u), | |
262 base::Bind(&WorkerPoolTest::RunTask, | |
263 base::Unretained(this), | |
264 i, | |
265 0u), | |
266 2u, | |
267 0u))); | |
268 } | |
reveman
2014/01/14 07:35:44
nit: and blank line here
| |
269 for (int i = 0; i < kWorkerPoolCount; ++i) { | |
270 RunAllTasksforWorkerPool(i); | |
271 | |
272 EXPECT_EQ(6u, run_task_ids(i).size()); | |
273 EXPECT_EQ(3u, on_task_completed_ids(i).size()); | |
274 } | |
247 } | 275 } |
248 | 276 |
249 TEST_F(WorkerPoolTest, Dependencies) { | 277 TEST_F(WorkerPoolTest, Dependencies) { |
250 worker_pool()->ScheduleTasks( | 278 for (int i = 0; i < kWorkerPoolCount; ++i) { |
251 std::vector<FakeWorkerPool::Task>( | 279 worker_pool(i)->ScheduleTasks( |
252 1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 280 std::vector<FakeWorkerPool::Task>( |
253 base::Unretained(this), | 281 1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
254 0u), | 282 base::Unretained(this), |
255 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 283 i, |
256 base::Unretained(this), | 284 0u), |
257 0u), | 285 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
258 base::Bind(&WorkerPoolTest::RunTask, | 286 base::Unretained(this), |
259 base::Unretained(this), | 287 i, |
260 1u), | 288 0u), |
261 1u, | 289 base::Bind(&WorkerPoolTest::RunTask, |
262 0u))); | 290 base::Unretained(this), |
263 RunAllTasks(); | 291 i, |
264 | 292 1u), |
265 // Check if task ran before dependent. | 293 1u, |
266 ASSERT_EQ(2u, run_task_ids().size()); | 294 0u))); |
267 EXPECT_EQ(0u, run_task_ids()[0]); | 295 } |
reveman
2014/01/14 07:35:44
nit: and blank line here
sohanjg
2014/01/14 08:10:00
Done.
| |
268 EXPECT_EQ(1u, run_task_ids()[1]); | 296 for (int i = 0; i < kWorkerPoolCount; ++i) { |
269 ASSERT_EQ(1u, on_task_completed_ids().size()); | 297 RunAllTasksforWorkerPool(i); |
270 EXPECT_EQ(0u, on_task_completed_ids()[0]); | 298 |
271 | 299 // Check if task ran before dependent. |
272 worker_pool()->ScheduleTasks( | 300 ASSERT_EQ(2u, run_task_ids(i).size()); |
273 std::vector<FakeWorkerPool::Task>( | 301 EXPECT_EQ(0u, run_task_ids(i)[0]); |
274 1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 302 EXPECT_EQ(1u, run_task_ids(i)[1]); |
275 base::Unretained(this), | 303 ASSERT_EQ(1u, on_task_completed_ids(i).size()); |
276 2u), | 304 EXPECT_EQ(0u, on_task_completed_ids(i)[0]); |
277 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 305 } |
278 base::Unretained(this), | 306 |
279 2u), | 307 for (int i = 0; i < kWorkerPoolCount; ++i) { |
280 base::Bind(&WorkerPoolTest::RunTask, | 308 worker_pool(i)->ScheduleTasks( |
281 base::Unretained(this), | 309 std::vector<FakeWorkerPool::Task>( |
282 3u), | 310 1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
283 2u, | 311 base::Unretained(this), |
284 0u))); | 312 i, |
285 RunAllTasks(); | 313 2u), |
286 | 314 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
287 // Task should only run once. | 315 base::Unretained(this), |
288 ASSERT_EQ(5u, run_task_ids().size()); | 316 i, |
289 EXPECT_EQ(2u, run_task_ids()[2]); | 317 2u), |
290 EXPECT_EQ(3u, run_task_ids()[3]); | 318 base::Bind(&WorkerPoolTest::RunTask, |
291 EXPECT_EQ(3u, run_task_ids()[4]); | 319 base::Unretained(this), |
292 ASSERT_EQ(2u, on_task_completed_ids().size()); | 320 i, |
293 EXPECT_EQ(2u, on_task_completed_ids()[1]); | 321 3u), |
322 2u, | |
323 0u))); | |
324 } | |
325 | |
326 for (int i = 0; i < kWorkerPoolCount; ++i) { | |
327 RunAllTasksforWorkerPool(i); | |
328 | |
329 // Task should only run once. | |
330 ASSERT_EQ(5u, run_task_ids(i).size()); | |
331 EXPECT_EQ(2u, run_task_ids(i)[2]); | |
332 EXPECT_EQ(3u, run_task_ids(i)[3]); | |
333 EXPECT_EQ(3u, run_task_ids(i)[4]); | |
334 ASSERT_EQ(2u, on_task_completed_ids(i).size()); | |
335 EXPECT_EQ(2u, on_task_completed_ids(i)[1]); | |
336 } | |
294 } | 337 } |
295 | 338 |
296 TEST_F(WorkerPoolTest, Priority) { | 339 TEST_F(WorkerPoolTest, Priority) { |
297 { | 340 for (int i = 0; i < kWorkerPoolCount; ++i) { |
298 FakeWorkerPool::Task tasks[] = { | 341 FakeWorkerPool::Task tasks[] = { |
299 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 342 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
300 base::Unretained(this), | 343 base::Unretained(this), |
344 i, | |
301 0u), | 345 0u), |
302 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 346 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
303 base::Unretained(this), | 347 base::Unretained(this), |
348 i, | |
304 0u), | 349 0u), |
305 base::Bind(&WorkerPoolTest::RunTask, | 350 base::Bind(&WorkerPoolTest::RunTask, |
306 base::Unretained(this), | 351 base::Unretained(this), |
352 i, | |
307 2u), | 353 2u), |
308 1u, | 354 1u, |
309 1u), // Priority 1 | 355 1u), // Priority 1 |
310 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 356 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
311 base::Unretained(this), | 357 base::Unretained(this), |
358 i, | |
312 1u), | 359 1u), |
313 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 360 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
314 base::Unretained(this), | 361 base::Unretained(this), |
362 i, | |
315 1u), | 363 1u), |
316 base::Bind(&WorkerPoolTest::RunTask, | 364 base::Bind(&WorkerPoolTest::RunTask, |
317 base::Unretained(this), | 365 base::Unretained(this), |
366 i, | |
318 3u), | 367 3u), |
319 1u, | 368 1u, |
320 0u) // Priority 0 | 369 0u) // Priority 0 |
321 }; | 370 }; |
322 worker_pool()->ScheduleTasks( | 371 worker_pool(i)->ScheduleTasks( |
323 std::vector<FakeWorkerPool::Task>(tasks, tasks + arraysize(tasks))); | 372 std::vector<FakeWorkerPool::Task>(tasks, tasks + arraysize(tasks))); |
324 } | 373 } |
325 RunAllTasks(); | 374 |
326 | 375 for (int i = 0; i < kWorkerPoolCount; ++i) { |
327 // Check if tasks ran in order of priority. | 376 RunAllTasksforWorkerPool(i); |
328 ASSERT_EQ(4u, run_task_ids().size()); | 377 |
329 EXPECT_EQ(1u, run_task_ids()[0]); | 378 // Check if tasks ran in order of priority. |
330 EXPECT_EQ(3u, run_task_ids()[1]); | 379 ASSERT_EQ(4u, run_task_ids(i).size()); |
331 EXPECT_EQ(0u, run_task_ids()[2]); | 380 EXPECT_EQ(1u, run_task_ids(i)[0]); |
332 EXPECT_EQ(2u, run_task_ids()[3]); | 381 EXPECT_EQ(3u, run_task_ids(i)[1]); |
333 ASSERT_EQ(2u, on_task_completed_ids().size()); | 382 EXPECT_EQ(0u, run_task_ids(i)[2]); |
334 EXPECT_EQ(1u, on_task_completed_ids()[0]); | 383 EXPECT_EQ(2u, run_task_ids(i)[3]); |
335 EXPECT_EQ(0u, on_task_completed_ids()[1]); | 384 ASSERT_EQ(2u, on_task_completed_ids(i).size()); |
336 | 385 EXPECT_EQ(1u, on_task_completed_ids(i)[0]); |
337 ResetIds(); | 386 EXPECT_EQ(0u, on_task_completed_ids(i)[1]); |
338 { | 387 } |
388 | |
389 ResetIAllWorkerPoolds(); | |
390 for (int i = 0; i < kWorkerPoolCount; ++i) { | |
339 std::vector<FakeWorkerPool::Task> tasks; | 391 std::vector<FakeWorkerPool::Task> tasks; |
340 tasks.push_back( | 392 tasks.push_back( |
341 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 393 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
342 base::Unretained(this), | 394 base::Unretained(this), |
395 i, | |
343 0u), | 396 0u), |
344 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 397 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
345 base::Unretained(this), | 398 base::Unretained(this), |
399 i, | |
346 0u), | 400 0u), |
347 base::Bind(&WorkerPoolTest::RunTask, | 401 base::Bind(&WorkerPoolTest::RunTask, |
348 base::Unretained(this), | 402 base::Unretained(this), |
403 i, | |
349 3u), | 404 3u), |
350 1u, // 1 dependent | 405 1u, // 1 dependent |
351 1u)); // Priority 1 | 406 1u)); // Priority 1 |
352 tasks.push_back( | 407 tasks.push_back( |
353 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 408 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
354 base::Unretained(this), | 409 base::Unretained(this), |
410 i, | |
355 1u), | 411 1u), |
356 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 412 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
357 base::Unretained(this), | 413 base::Unretained(this), |
414 i, | |
358 1u), | 415 1u), |
359 base::Bind(&WorkerPoolTest::RunTask, | 416 base::Bind(&WorkerPoolTest::RunTask, |
360 base::Unretained(this), | 417 base::Unretained(this), |
418 i, | |
361 4u), | 419 4u), |
362 2u, // 2 dependents | 420 2u, // 2 dependents |
363 1u)); // Priority 1 | 421 1u)); // Priority 1 |
364 tasks.push_back( | 422 tasks.push_back( |
365 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, | 423 FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask, |
366 base::Unretained(this), | 424 base::Unretained(this), |
425 i, | |
367 2u), | 426 2u), |
368 base::Bind(&WorkerPoolTest::OnTaskCompleted, | 427 base::Bind(&WorkerPoolTest::OnTaskCompleted, |
369 base::Unretained(this), | 428 base::Unretained(this), |
429 i, | |
370 2u), | 430 2u), |
371 base::Bind(&WorkerPoolTest::RunTask, | 431 base::Bind(&WorkerPoolTest::RunTask, |
372 base::Unretained(this), | 432 base::Unretained(this), |
433 i, | |
373 5u), | 434 5u), |
374 1u, // 1 dependent | 435 1u, // 1 dependent |
375 0u)); // Priority 0 | 436 0u)); // Priority 0 |
376 worker_pool()->ScheduleTasks(tasks); | 437 worker_pool(i)->ScheduleTasks(tasks); |
377 } | 438 } |
378 RunAllTasks(); | 439 |
379 | 440 for (int i = 0; i < kWorkerPoolCount; ++i) { |
380 // Check if tasks ran in order of priority and that task with more | 441 RunAllTasksforWorkerPool(i); |
381 // dependents ran first when priority is the same. | 442 |
382 ASSERT_LE(3u, run_task_ids().size()); | 443 // Check if tasks ran in order of priority and that task with more |
383 EXPECT_EQ(2u, run_task_ids()[0]); | 444 // dependents ran first when priority is the same. |
384 EXPECT_EQ(5u, run_task_ids()[1]); | 445 ASSERT_LE(3u, run_task_ids(i).size()); |
385 EXPECT_EQ(1u, run_task_ids()[2]); | 446 EXPECT_EQ(2u, run_task_ids(i)[0]); |
386 ASSERT_EQ(3u, on_task_completed_ids().size()); | 447 EXPECT_EQ(5u, run_task_ids(i)[1]); |
387 EXPECT_EQ(2u, on_task_completed_ids()[0]); | 448 EXPECT_EQ(1u, run_task_ids(i)[2]); |
388 EXPECT_EQ(1u, on_task_completed_ids()[1]); | 449 ASSERT_EQ(3u, on_task_completed_ids(i).size()); |
389 EXPECT_EQ(0u, on_task_completed_ids()[2]); | 450 EXPECT_EQ(2u, on_task_completed_ids(i)[0]); |
451 EXPECT_EQ(1u, on_task_completed_ids(i)[1]); | |
452 EXPECT_EQ(0u, on_task_completed_ids(i)[2]); | |
453 } | |
390 } | 454 } |
391 | 455 |
392 } // namespace | 456 } // namespace |
393 | 457 |
394 } // namespace cc | 458 } // namespace cc |
OLD | NEW |