OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 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/resource_update_controller.h" | 5 #include "cc/resources/resource_update_controller.h" |
6 | 6 |
| 7 #include "base/test/test_simple_task_runner.h" |
7 #include "cc/resources/prioritized_resource_manager.h" | 8 #include "cc/resources/prioritized_resource_manager.h" |
8 #include "cc/test/fake_output_surface.h" | 9 #include "cc/test/fake_output_surface.h" |
9 #include "cc/test/fake_proxy.h" | 10 #include "cc/test/fake_proxy.h" |
10 #include "cc/test/scheduler_test_common.h" | 11 #include "cc/test/scheduler_test_common.h" |
11 #include "cc/test/test_web_graphics_context_3d.h" | 12 #include "cc/test/test_web_graphics_context_3d.h" |
12 #include "cc/test/tiled_layer_test_common.h" | 13 #include "cc/test/tiled_layer_test_common.h" |
13 #include "cc/trees/single_thread_proxy.h" // For DebugScopedSetImplThread | 14 #include "cc/trees/single_thread_proxy.h" // For DebugScopedSetImplThread |
14 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
15 #include "third_party/khronos/GLES2/gl2ext.h" | 16 #include "third_party/khronos/GLES2/gl2ext.h" |
16 | 17 |
(...skipping 156 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 } | 174 } |
174 | 175 |
175 void SetMaxUploadCountPerUpdate(int count) { | 176 void SetMaxUploadCountPerUpdate(int count) { |
176 max_upload_count_per_update_ = count; | 177 max_upload_count_per_update_ = count; |
177 } | 178 } |
178 | 179 |
179 void UpdateTextures() { | 180 void UpdateTextures() { |
180 DebugScopedSetImplThreadAndMainThreadBlocked | 181 DebugScopedSetImplThreadAndMainThreadBlocked |
181 impl_thread_and_main_thread_blocked(&proxy_); | 182 impl_thread_and_main_thread_blocked(&proxy_); |
182 scoped_ptr<ResourceUpdateController> update_controller = | 183 scoped_ptr<ResourceUpdateController> update_controller = |
183 ResourceUpdateController::Create( | 184 ResourceUpdateController::Create(NULL, |
184 NULL, proxy_.ImplThread(), queue_.Pass(), resource_provider_.get()); | 185 NULL, |
| 186 queue_.Pass(), |
| 187 resource_provider_.get()); |
185 update_controller->Finalize(); | 188 update_controller->Finalize(); |
186 } | 189 } |
187 | 190 |
188 void MakeQueryResultAvailable() { query_results_available_++; } | 191 void MakeQueryResultAvailable() { query_results_available_++; } |
189 | 192 |
190 protected: | 193 protected: |
191 // Classes required to interact and test the ResourceUpdateController | 194 // Classes required to interact and test the ResourceUpdateController |
192 FakeProxy proxy_; | 195 FakeProxy proxy_; |
193 scoped_ptr<OutputSurface> output_surface_; | 196 scoped_ptr<OutputSurface> output_surface_; |
194 scoped_ptr<ResourceProvider> resource_provider_; | 197 scoped_ptr<ResourceProvider> resource_provider_; |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
319 UpdateTextures(); | 322 UpdateTextures(); |
320 | 323 |
321 EXPECT_EQ(full_upload_flush_multipler + partial_upload_flush_multipler, | 324 EXPECT_EQ(full_upload_flush_multipler + partial_upload_flush_multipler, |
322 num_total_flushes_); | 325 num_total_flushes_); |
323 EXPECT_EQ(full_count + partial_count, num_total_uploads_); | 326 EXPECT_EQ(full_count + partial_count, num_total_uploads_); |
324 EXPECT_EQ(0, num_dangling_uploads_) | 327 EXPECT_EQ(0, num_dangling_uploads_) |
325 << "Last upload wasn't followed by a flush."; | 328 << "Last upload wasn't followed by a flush."; |
326 } | 329 } |
327 | 330 |
328 class FakeResourceUpdateControllerClient | 331 class FakeResourceUpdateControllerClient |
329 : public cc::ResourceUpdateControllerClient { | 332 : public ResourceUpdateControllerClient { |
330 public: | 333 public: |
331 FakeResourceUpdateControllerClient() { Reset(); } | 334 FakeResourceUpdateControllerClient() { Reset(); } |
332 void Reset() { ready_to_finalize_called_ = false; } | 335 void Reset() { ready_to_finalize_called_ = false; } |
333 bool ReadyToFinalizeCalled() const { return ready_to_finalize_called_; } | 336 bool ReadyToFinalizeCalled() const { return ready_to_finalize_called_; } |
334 | 337 |
335 virtual void ReadyToFinalizeTextureUpdates() OVERRIDE { | 338 virtual void ReadyToFinalizeTextureUpdates() OVERRIDE { |
336 ready_to_finalize_called_ = true; | 339 ready_to_finalize_called_ = true; |
337 } | 340 } |
338 | 341 |
339 protected: | 342 protected: |
340 bool ready_to_finalize_called_; | 343 bool ready_to_finalize_called_; |
341 }; | 344 }; |
342 | 345 |
343 class FakeResourceUpdateController : public cc::ResourceUpdateController { | 346 class FakeResourceUpdateController : public ResourceUpdateController { |
344 public: | 347 public: |
345 static scoped_ptr<FakeResourceUpdateController> Create( | 348 static scoped_ptr<FakeResourceUpdateController> Create( |
346 cc::ResourceUpdateControllerClient* client, cc::Thread* thread, | 349 ResourceUpdateControllerClient* client, |
| 350 base::TestSimpleTaskRunner* task_runner, |
347 scoped_ptr<ResourceUpdateQueue> queue, | 351 scoped_ptr<ResourceUpdateQueue> queue, |
348 ResourceProvider* resource_provider) { | 352 ResourceProvider* resource_provider) { |
349 return make_scoped_ptr(new FakeResourceUpdateController( | 353 return make_scoped_ptr(new FakeResourceUpdateController( |
350 client, thread, queue.Pass(), resource_provider)); | 354 client, task_runner, queue.Pass(), resource_provider)); |
351 } | 355 } |
352 | 356 |
353 void SetNow(base::TimeTicks time) { now_ = time; } | 357 void SetNow(base::TimeTicks time) { now_ = time; } |
354 virtual base::TimeTicks Now() const OVERRIDE { return now_; } | 358 virtual base::TimeTicks Now() const OVERRIDE { return now_; } |
355 void SetUpdateMoreTexturesTime(base::TimeDelta time) { | 359 void SetUpdateMoreTexturesTime(base::TimeDelta time) { |
356 update_more_textures_time_ = time; | 360 update_more_textures_time_ = time; |
357 } | 361 } |
358 virtual base::TimeDelta UpdateMoreTexturesTime() const OVERRIDE { | 362 virtual base::TimeDelta UpdateMoreTexturesTime() const OVERRIDE { |
359 return update_more_textures_time_; | 363 return update_more_textures_time_; |
360 } | 364 } |
361 void SetUpdateMoreTexturesSize(size_t size) { | 365 void SetUpdateMoreTexturesSize(size_t size) { |
362 update_more_textures_size_ = size; | 366 update_more_textures_size_ = size; |
363 } | 367 } |
364 virtual size_t UpdateMoreTexturesSize() const OVERRIDE { | 368 virtual size_t UpdateMoreTexturesSize() const OVERRIDE { |
365 return update_more_textures_size_; | 369 return update_more_textures_size_; |
366 } | 370 } |
367 | 371 |
368 protected: | 372 protected: |
369 FakeResourceUpdateController(cc::ResourceUpdateControllerClient* client, | 373 FakeResourceUpdateController(ResourceUpdateControllerClient* client, |
370 cc::Thread* thread, | 374 base::TestSimpleTaskRunner* task_runner, |
371 scoped_ptr<ResourceUpdateQueue> queue, | 375 scoped_ptr<ResourceUpdateQueue> queue, |
372 ResourceProvider* resource_provider) | 376 ResourceProvider* resource_provider) |
373 : cc::ResourceUpdateController( | 377 : ResourceUpdateController( |
374 client, thread, queue.Pass(), resource_provider), | 378 client, task_runner, queue.Pass(), resource_provider), |
375 update_more_textures_size_(0) {} | 379 update_more_textures_size_(0) {} |
376 | 380 |
377 base::TimeTicks now_; | 381 base::TimeTicks now_; |
378 base::TimeDelta update_more_textures_time_; | 382 base::TimeDelta update_more_textures_time_; |
379 size_t update_more_textures_size_; | 383 size_t update_more_textures_size_; |
380 }; | 384 }; |
381 | 385 |
382 static void RunPendingTask(FakeThread* thread, | 386 static void RunPendingTask(base::TestSimpleTaskRunner* task_runner, |
383 FakeResourceUpdateController* controller) { | 387 FakeResourceUpdateController* controller) { |
384 EXPECT_TRUE(thread->HasPendingTask()); | 388 EXPECT_TRUE(task_runner->HasPendingTask()); |
385 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds( | 389 controller->SetNow(controller->Now() + task_runner->NextPendingTaskDelay()); |
386 thread->PendingDelayMs())); | 390 task_runner->RunPendingTasks(); |
387 thread->RunPendingTask(); | |
388 } | 391 } |
389 | 392 |
390 TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures) { | 393 TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures) { |
391 FakeResourceUpdateControllerClient client; | 394 FakeResourceUpdateControllerClient client; |
392 FakeThread thread; | 395 scoped_refptr<base::TestSimpleTaskRunner> task_runner = |
| 396 new base::TestSimpleTaskRunner; |
393 | 397 |
394 SetMaxUploadCountPerUpdate(1); | 398 SetMaxUploadCountPerUpdate(1); |
395 AppendFullUploadsToUpdateQueue(3); | 399 AppendFullUploadsToUpdateQueue(3); |
396 AppendPartialUploadsToUpdateQueue(0); | 400 AppendPartialUploadsToUpdateQueue(0); |
397 | 401 |
398 DebugScopedSetImplThreadAndMainThreadBlocked | 402 DebugScopedSetImplThreadAndMainThreadBlocked |
399 impl_thread_and_main_thread_blocked(&proxy_); | 403 impl_thread_and_main_thread_blocked(&proxy_); |
400 scoped_ptr<FakeResourceUpdateController> controller( | 404 scoped_ptr<FakeResourceUpdateController> controller( |
401 FakeResourceUpdateController::Create(&client, &thread, queue_.Pass(), | 405 FakeResourceUpdateController::Create(&client, |
| 406 task_runner.get(), |
| 407 queue_.Pass(), |
402 resource_provider_.get())); | 408 resource_provider_.get())); |
403 | 409 |
404 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1)); | 410 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1)); |
405 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); | 411 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); |
406 controller->SetUpdateMoreTexturesSize(1); | 412 controller->SetUpdateMoreTexturesSize(1); |
407 // Not enough time for any updates. | 413 // Not enough time for any updates. |
408 controller->PerformMoreUpdates(controller->Now() + | 414 controller->PerformMoreUpdates(controller->Now() + |
409 base::TimeDelta::FromMilliseconds(90)); | 415 base::TimeDelta::FromMilliseconds(90)); |
410 EXPECT_FALSE(thread.HasPendingTask()); | 416 EXPECT_FALSE(task_runner->HasPendingTask()); |
411 | 417 |
412 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); | 418 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); |
413 controller->SetUpdateMoreTexturesSize(1); | 419 controller->SetUpdateMoreTexturesSize(1); |
414 // Only enough time for 1 update. | 420 // Only enough time for 1 update. |
415 controller->PerformMoreUpdates(controller->Now() + | 421 controller->PerformMoreUpdates(controller->Now() + |
416 base::TimeDelta::FromMilliseconds(120)); | 422 base::TimeDelta::FromMilliseconds(120)); |
417 EXPECT_FALSE(thread.HasPendingTask()); | 423 EXPECT_FALSE(task_runner->HasPendingTask()); |
418 EXPECT_EQ(1, num_total_uploads_); | 424 EXPECT_EQ(1, num_total_uploads_); |
419 | 425 |
420 // Complete one upload. | 426 // Complete one upload. |
421 MakeQueryResultAvailable(); | 427 MakeQueryResultAvailable(); |
422 | 428 |
423 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); | 429 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); |
424 controller->SetUpdateMoreTexturesSize(1); | 430 controller->SetUpdateMoreTexturesSize(1); |
425 // Enough time for 2 updates. | 431 // Enough time for 2 updates. |
426 controller->PerformMoreUpdates(controller->Now() + | 432 controller->PerformMoreUpdates(controller->Now() + |
427 base::TimeDelta::FromMilliseconds(220)); | 433 base::TimeDelta::FromMilliseconds(220)); |
428 RunPendingTask(&thread, controller.get()); | 434 RunPendingTask(task_runner.get(), controller.get()); |
429 EXPECT_FALSE(thread.HasPendingTask()); | 435 EXPECT_FALSE(task_runner->HasPendingTask()); |
430 EXPECT_TRUE(client.ReadyToFinalizeCalled()); | 436 EXPECT_TRUE(client.ReadyToFinalizeCalled()); |
431 EXPECT_EQ(3, num_total_uploads_); | 437 EXPECT_EQ(3, num_total_uploads_); |
432 } | 438 } |
433 | 439 |
434 TEST_F(ResourceUpdateControllerTest, NoMoreUpdates) { | 440 TEST_F(ResourceUpdateControllerTest, NoMoreUpdates) { |
435 FakeResourceUpdateControllerClient client; | 441 FakeResourceUpdateControllerClient client; |
436 FakeThread thread; | 442 scoped_refptr<base::TestSimpleTaskRunner> task_runner = |
| 443 new base::TestSimpleTaskRunner; |
437 | 444 |
438 SetMaxUploadCountPerUpdate(1); | 445 SetMaxUploadCountPerUpdate(1); |
439 AppendFullUploadsToUpdateQueue(2); | 446 AppendFullUploadsToUpdateQueue(2); |
440 AppendPartialUploadsToUpdateQueue(0); | 447 AppendPartialUploadsToUpdateQueue(0); |
441 | 448 |
442 DebugScopedSetImplThreadAndMainThreadBlocked | 449 DebugScopedSetImplThreadAndMainThreadBlocked |
443 impl_thread_and_main_thread_blocked(&proxy_); | 450 impl_thread_and_main_thread_blocked(&proxy_); |
444 scoped_ptr<FakeResourceUpdateController> controller( | 451 scoped_ptr<FakeResourceUpdateController> controller( |
445 FakeResourceUpdateController::Create(&client, &thread, queue_.Pass(), | 452 FakeResourceUpdateController::Create(&client, |
| 453 task_runner.get(), |
| 454 queue_.Pass(), |
446 resource_provider_.get())); | 455 resource_provider_.get())); |
447 | 456 |
448 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1)); | 457 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1)); |
449 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); | 458 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); |
450 controller->SetUpdateMoreTexturesSize(1); | 459 controller->SetUpdateMoreTexturesSize(1); |
451 // Enough time for 3 updates but only 2 necessary. | 460 // Enough time for 3 updates but only 2 necessary. |
452 controller->PerformMoreUpdates(controller->Now() + | 461 controller->PerformMoreUpdates(controller->Now() + |
453 base::TimeDelta::FromMilliseconds(310)); | 462 base::TimeDelta::FromMilliseconds(310)); |
454 RunPendingTask(&thread, controller.get()); | 463 RunPendingTask(task_runner.get(), controller.get()); |
455 EXPECT_FALSE(thread.HasPendingTask()); | 464 EXPECT_FALSE(task_runner->HasPendingTask()); |
456 EXPECT_TRUE(client.ReadyToFinalizeCalled()); | 465 EXPECT_TRUE(client.ReadyToFinalizeCalled()); |
457 EXPECT_EQ(2, num_total_uploads_); | 466 EXPECT_EQ(2, num_total_uploads_); |
458 | 467 |
459 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); | 468 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100)); |
460 controller->SetUpdateMoreTexturesSize(1); | 469 controller->SetUpdateMoreTexturesSize(1); |
461 // Enough time for updates but no more updates left. | 470 // Enough time for updates but no more updates left. |
462 controller->PerformMoreUpdates(controller->Now() + | 471 controller->PerformMoreUpdates(controller->Now() + |
463 base::TimeDelta::FromMilliseconds(310)); | 472 base::TimeDelta::FromMilliseconds(310)); |
464 // 0-delay task used to call ReadyToFinalizeTextureUpdates(). | 473 // 0-delay task used to call ReadyToFinalizeTextureUpdates(). |
465 RunPendingTask(&thread, controller.get()); | 474 RunPendingTask(task_runner.get(), controller.get()); |
466 EXPECT_FALSE(thread.HasPendingTask()); | 475 EXPECT_FALSE(task_runner->HasPendingTask()); |
467 EXPECT_TRUE(client.ReadyToFinalizeCalled()); | 476 EXPECT_TRUE(client.ReadyToFinalizeCalled()); |
468 EXPECT_EQ(2, num_total_uploads_); | 477 EXPECT_EQ(2, num_total_uploads_); |
469 } | 478 } |
470 | 479 |
471 TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime) { | 480 TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime) { |
472 FakeResourceUpdateControllerClient client; | 481 FakeResourceUpdateControllerClient client; |
473 FakeThread thread; | 482 scoped_refptr<base::TestSimpleTaskRunner> task_runner = |
| 483 new base::TestSimpleTaskRunner; |
474 | 484 |
475 SetMaxUploadCountPerUpdate(1); | 485 SetMaxUploadCountPerUpdate(1); |
476 AppendFullUploadsToUpdateQueue(2); | 486 AppendFullUploadsToUpdateQueue(2); |
477 AppendPartialUploadsToUpdateQueue(0); | 487 AppendPartialUploadsToUpdateQueue(0); |
478 | 488 |
479 DebugScopedSetImplThreadAndMainThreadBlocked | 489 DebugScopedSetImplThreadAndMainThreadBlocked |
480 impl_thread_and_main_thread_blocked(&proxy_); | 490 impl_thread_and_main_thread_blocked(&proxy_); |
481 scoped_ptr<FakeResourceUpdateController> controller( | 491 scoped_ptr<FakeResourceUpdateController> controller( |
482 FakeResourceUpdateController::Create(&client, &thread, queue_.Pass(), | 492 FakeResourceUpdateController::Create(&client, |
| 493 task_runner.get(), |
| 494 queue_.Pass(), |
483 resource_provider_.get())); | 495 resource_provider_.get())); |
484 | 496 |
485 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1)); | 497 controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(1)); |
486 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(500)); | 498 controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(500)); |
487 controller->SetUpdateMoreTexturesSize(1); | 499 controller->SetUpdateMoreTexturesSize(1); |
488 | 500 |
489 for (int i = 0; i < 100; i++) { | 501 for (int i = 0; i < 100; i++) { |
490 if (client.ReadyToFinalizeCalled()) | 502 if (client.ReadyToFinalizeCalled()) |
491 break; | 503 break; |
492 | 504 |
493 // Not enough time for any updates. | 505 // Not enough time for any updates. |
494 controller->PerformMoreUpdates(controller->Now() + | 506 controller->PerformMoreUpdates(controller->Now() + |
495 base::TimeDelta::FromMilliseconds(400)); | 507 base::TimeDelta::FromMilliseconds(400)); |
496 | 508 |
497 if (thread.HasPendingTask()) | 509 if (task_runner->HasPendingTask()) |
498 RunPendingTask(&thread, controller.get()); | 510 RunPendingTask(task_runner.get(), controller.get()); |
499 } | 511 } |
500 | 512 |
501 EXPECT_FALSE(thread.HasPendingTask()); | 513 EXPECT_FALSE(task_runner->HasPendingTask()); |
502 EXPECT_TRUE(client.ReadyToFinalizeCalled()); | 514 EXPECT_TRUE(client.ReadyToFinalizeCalled()); |
503 EXPECT_EQ(2, num_total_uploads_); | 515 EXPECT_EQ(2, num_total_uploads_); |
504 } | 516 } |
505 | 517 |
506 } // namespace | 518 } // namespace |
507 } // namespace cc | 519 } // namespace cc |
OLD | NEW |