OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/tiles/software_image_decode_controller.h" | 5 #include "cc/tiles/software_image_decode_controller.h" |
6 | 6 |
7 #include "cc/playback/draw_image.h" | 7 #include "cc/playback/draw_image.h" |
8 #include "testing/gtest/include/gtest/gtest.h" | 8 #include "testing/gtest/include/gtest/gtest.h" |
9 | 9 |
10 namespace cc { | 10 namespace cc { |
(...skipping 341 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
352 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) { | 352 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) { |
353 SoftwareImageDecodeController controller; | 353 SoftwareImageDecodeController controller; |
354 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 354 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
355 bool is_decomposable = true; | 355 bool is_decomposable = true; |
356 SkFilterQuality quality = kHigh_SkFilterQuality; | 356 SkFilterQuality quality = kHigh_SkFilterQuality; |
357 uint64_t prepare_tiles_id = 1; | 357 uint64_t prepare_tiles_id = 1; |
358 | 358 |
359 DrawImage draw_image( | 359 DrawImage draw_image( |
360 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 360 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
361 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 361 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
362 scoped_refptr<ImageDecodeTask> task; | 362 scoped_refptr<TileTask> task; |
363 bool need_unref = | 363 bool need_unref = |
364 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 364 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
365 EXPECT_TRUE(need_unref); | 365 EXPECT_TRUE(need_unref); |
366 EXPECT_TRUE(task); | 366 EXPECT_TRUE(task); |
367 | 367 |
368 DrawImage another_draw_image( | 368 DrawImage another_draw_image( |
369 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 369 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
370 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 370 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
371 scoped_refptr<ImageDecodeTask> another_task; | 371 scoped_refptr<TileTask> another_task; |
372 need_unref = controller.GetTaskForImageAndRef( | 372 need_unref = controller.GetTaskForImageAndRef( |
373 another_draw_image, prepare_tiles_id, &another_task); | 373 another_draw_image, prepare_tiles_id, &another_task); |
374 EXPECT_TRUE(need_unref); | 374 EXPECT_TRUE(need_unref); |
375 EXPECT_TRUE(task.get() == another_task.get()); | 375 EXPECT_TRUE(task.get() == another_task.get()); |
376 | 376 |
377 controller.UnrefImage(draw_image); | 377 controller.UnrefImage(draw_image); |
378 controller.UnrefImage(draw_image); | 378 controller.UnrefImage(draw_image); |
379 } | 379 } |
380 | 380 |
381 TEST(SoftwareImageDecodeControllerTest, | 381 TEST(SoftwareImageDecodeControllerTest, |
382 GetTaskForImageSameImageDifferentQuality) { | 382 GetTaskForImageSameImageDifferentQuality) { |
383 SoftwareImageDecodeController controller; | 383 SoftwareImageDecodeController controller; |
384 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 384 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
385 bool is_decomposable = true; | 385 bool is_decomposable = true; |
386 uint64_t prepare_tiles_id = 1; | 386 uint64_t prepare_tiles_id = 1; |
387 | 387 |
388 DrawImage high_quality_draw_image( | 388 DrawImage high_quality_draw_image( |
389 image.get(), SkIRect::MakeWH(image->width(), image->height()), | 389 image.get(), SkIRect::MakeWH(image->width(), image->height()), |
390 kHigh_SkFilterQuality, | 390 kHigh_SkFilterQuality, |
391 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 391 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
392 scoped_refptr<ImageDecodeTask> high_quality_task; | 392 scoped_refptr<TileTask> high_quality_task; |
393 bool need_unref = controller.GetTaskForImageAndRef( | 393 bool need_unref = controller.GetTaskForImageAndRef( |
394 high_quality_draw_image, prepare_tiles_id, &high_quality_task); | 394 high_quality_draw_image, prepare_tiles_id, &high_quality_task); |
395 EXPECT_TRUE(need_unref); | 395 EXPECT_TRUE(need_unref); |
396 EXPECT_TRUE(high_quality_task); | 396 EXPECT_TRUE(high_quality_task); |
397 | 397 |
398 DrawImage medium_quality_draw_image( | 398 DrawImage medium_quality_draw_image( |
399 image.get(), SkIRect::MakeWH(image->width(), image->height()), | 399 image.get(), SkIRect::MakeWH(image->width(), image->height()), |
400 kMedium_SkFilterQuality, | 400 kMedium_SkFilterQuality, |
401 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 401 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
402 scoped_refptr<ImageDecodeTask> medium_quality_task; | 402 scoped_refptr<TileTask> medium_quality_task; |
403 need_unref = controller.GetTaskForImageAndRef( | 403 need_unref = controller.GetTaskForImageAndRef( |
404 medium_quality_draw_image, prepare_tiles_id, &medium_quality_task); | 404 medium_quality_draw_image, prepare_tiles_id, &medium_quality_task); |
405 // Medium quality isn't handled by the controller, so it won't ref it. Note | 405 // Medium quality isn't handled by the controller, so it won't ref it. Note |
406 // that this will change when medium quality is handled and will need to be | 406 // that this will change when medium quality is handled and will need to be |
407 // updated. | 407 // updated. |
408 EXPECT_FALSE(need_unref); | 408 EXPECT_FALSE(need_unref); |
409 EXPECT_TRUE(medium_quality_task); | 409 EXPECT_TRUE(medium_quality_task); |
410 EXPECT_TRUE(high_quality_task.get() != medium_quality_task.get()); | 410 EXPECT_TRUE(high_quality_task.get() != medium_quality_task.get()); |
411 | 411 |
412 DrawImage low_quality_draw_image( | 412 DrawImage low_quality_draw_image( |
413 image.get(), SkIRect::MakeWH(image->width(), image->height()), | 413 image.get(), SkIRect::MakeWH(image->width(), image->height()), |
414 kLow_SkFilterQuality, | 414 kLow_SkFilterQuality, |
415 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 415 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
416 scoped_refptr<ImageDecodeTask> low_quality_task; | 416 scoped_refptr<TileTask> low_quality_task; |
417 need_unref = controller.GetTaskForImageAndRef( | 417 need_unref = controller.GetTaskForImageAndRef( |
418 low_quality_draw_image, prepare_tiles_id, &low_quality_task); | 418 low_quality_draw_image, prepare_tiles_id, &low_quality_task); |
419 EXPECT_TRUE(need_unref); | 419 EXPECT_TRUE(need_unref); |
420 EXPECT_TRUE(low_quality_task); | 420 EXPECT_TRUE(low_quality_task); |
421 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); | 421 EXPECT_TRUE(high_quality_task.get() != low_quality_task.get()); |
422 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get()); | 422 EXPECT_TRUE(medium_quality_task.get() != low_quality_task.get()); |
423 | 423 |
424 controller.UnrefImage(high_quality_draw_image); | 424 controller.UnrefImage(high_quality_draw_image); |
425 controller.UnrefImage(low_quality_draw_image); | 425 controller.UnrefImage(low_quality_draw_image); |
426 } | 426 } |
427 | 427 |
428 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { | 428 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) { |
429 SoftwareImageDecodeController controller; | 429 SoftwareImageDecodeController controller; |
430 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 430 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
431 bool is_decomposable = true; | 431 bool is_decomposable = true; |
432 uint64_t prepare_tiles_id = 1; | 432 uint64_t prepare_tiles_id = 1; |
433 SkFilterQuality quality = kHigh_SkFilterQuality; | 433 SkFilterQuality quality = kHigh_SkFilterQuality; |
434 | 434 |
435 DrawImage half_size_draw_image( | 435 DrawImage half_size_draw_image( |
436 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 436 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
437 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 437 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
438 scoped_refptr<ImageDecodeTask> half_size_task; | 438 scoped_refptr<TileTask> half_size_task; |
439 bool need_unref = controller.GetTaskForImageAndRef( | 439 bool need_unref = controller.GetTaskForImageAndRef( |
440 half_size_draw_image, prepare_tiles_id, &half_size_task); | 440 half_size_draw_image, prepare_tiles_id, &half_size_task); |
441 EXPECT_TRUE(need_unref); | 441 EXPECT_TRUE(need_unref); |
442 EXPECT_TRUE(half_size_task); | 442 EXPECT_TRUE(half_size_task); |
443 | 443 |
444 DrawImage quarter_size_draw_image( | 444 DrawImage quarter_size_draw_image( |
445 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 445 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
446 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 446 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
447 scoped_refptr<ImageDecodeTask> quarter_size_task; | 447 scoped_refptr<TileTask> quarter_size_task; |
448 need_unref = controller.GetTaskForImageAndRef( | 448 need_unref = controller.GetTaskForImageAndRef( |
449 quarter_size_draw_image, prepare_tiles_id, &quarter_size_task); | 449 quarter_size_draw_image, prepare_tiles_id, &quarter_size_task); |
450 EXPECT_TRUE(need_unref); | 450 EXPECT_TRUE(need_unref); |
451 EXPECT_TRUE(quarter_size_task); | 451 EXPECT_TRUE(quarter_size_task); |
452 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); | 452 EXPECT_TRUE(half_size_task.get() != quarter_size_task.get()); |
453 | 453 |
454 controller.UnrefImage(half_size_draw_image); | 454 controller.UnrefImage(half_size_draw_image); |
455 controller.UnrefImage(quarter_size_draw_image); | 455 controller.UnrefImage(quarter_size_draw_image); |
456 } | 456 } |
457 | 457 |
458 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { | 458 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
459 SoftwareImageDecodeController controller; | 459 SoftwareImageDecodeController controller; |
460 bool is_decomposable = true; | 460 bool is_decomposable = true; |
461 uint64_t prepare_tiles_id = 1; | 461 uint64_t prepare_tiles_id = 1; |
462 SkFilterQuality quality = kHigh_SkFilterQuality; | 462 SkFilterQuality quality = kHigh_SkFilterQuality; |
463 | 463 |
464 skia::RefPtr<SkImage> first_image = CreateImage(100, 100); | 464 skia::RefPtr<SkImage> first_image = CreateImage(100, 100); |
465 DrawImage first_draw_image( | 465 DrawImage first_draw_image( |
466 first_image.get(), | 466 first_image.get(), |
467 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, | 467 SkIRect::MakeWH(first_image->width(), first_image->height()), quality, |
468 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 468 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
469 scoped_refptr<ImageDecodeTask> first_task; | 469 scoped_refptr<TileTask> first_task; |
470 bool need_unref = controller.GetTaskForImageAndRef( | 470 bool need_unref = controller.GetTaskForImageAndRef( |
471 first_draw_image, prepare_tiles_id, &first_task); | 471 first_draw_image, prepare_tiles_id, &first_task); |
472 EXPECT_TRUE(need_unref); | 472 EXPECT_TRUE(need_unref); |
473 EXPECT_TRUE(first_task); | 473 EXPECT_TRUE(first_task); |
474 | 474 |
475 skia::RefPtr<SkImage> second_image = CreateImage(100, 100); | 475 skia::RefPtr<SkImage> second_image = CreateImage(100, 100); |
476 DrawImage second_draw_image( | 476 DrawImage second_draw_image( |
477 second_image.get(), | 477 second_image.get(), |
478 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, | 478 SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
479 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); | 479 CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
480 scoped_refptr<ImageDecodeTask> second_task; | 480 scoped_refptr<TileTask> second_task; |
481 need_unref = controller.GetTaskForImageAndRef(second_draw_image, | 481 need_unref = controller.GetTaskForImageAndRef(second_draw_image, |
482 prepare_tiles_id, &second_task); | 482 prepare_tiles_id, &second_task); |
483 EXPECT_TRUE(need_unref); | 483 EXPECT_TRUE(need_unref); |
484 EXPECT_TRUE(second_task); | 484 EXPECT_TRUE(second_task); |
485 EXPECT_TRUE(first_task.get() != second_task.get()); | 485 EXPECT_TRUE(first_task.get() != second_task.get()); |
486 | 486 |
487 controller.UnrefImage(first_draw_image); | 487 controller.UnrefImage(first_draw_image); |
488 controller.UnrefImage(second_draw_image); | 488 controller.UnrefImage(second_draw_image); |
489 } | 489 } |
490 | 490 |
491 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { | 491 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) { |
492 SoftwareImageDecodeController controller; | 492 SoftwareImageDecodeController controller; |
493 bool is_decomposable = true; | 493 bool is_decomposable = true; |
494 uint64_t prepare_tiles_id = 1; | 494 uint64_t prepare_tiles_id = 1; |
495 SkFilterQuality quality = kHigh_SkFilterQuality; | 495 SkFilterQuality quality = kHigh_SkFilterQuality; |
496 | 496 |
497 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 497 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
498 DrawImage draw_image( | 498 DrawImage draw_image( |
499 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 499 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
500 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 500 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
501 scoped_refptr<ImageDecodeTask> task; | 501 scoped_refptr<TileTask> task; |
502 bool need_unref = | 502 bool need_unref = |
503 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 503 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
504 EXPECT_TRUE(need_unref); | 504 EXPECT_TRUE(need_unref); |
505 EXPECT_TRUE(task); | 505 EXPECT_TRUE(task); |
506 | 506 |
507 task->WillSchedule(); | 507 task->WillSchedule(); |
508 task->ScheduleOnOriginThread(nullptr); | 508 task->ScheduleOnOriginThread(nullptr); |
509 task->DidSchedule(); | 509 task->DidSchedule(); |
510 task->RunOnWorkerThread(); | 510 task->RunOnWorkerThread(); |
511 | 511 |
512 scoped_refptr<ImageDecodeTask> another_task; | 512 scoped_refptr<TileTask> another_task; |
513 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 513 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
514 &another_task); | 514 &another_task); |
515 EXPECT_TRUE(need_unref); | 515 EXPECT_TRUE(need_unref); |
516 EXPECT_FALSE(another_task); | 516 EXPECT_FALSE(another_task); |
517 | 517 |
518 task->WillComplete(); | 518 task->WillComplete(); |
519 task->CompleteOnOriginThread(nullptr); | 519 task->CompleteOnOriginThread(nullptr); |
520 task->DidComplete(); | 520 task->DidComplete(); |
521 | 521 |
522 controller.UnrefImage(draw_image); | 522 controller.UnrefImage(draw_image); |
523 controller.UnrefImage(draw_image); | 523 controller.UnrefImage(draw_image); |
524 } | 524 } |
525 | 525 |
526 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { | 526 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) { |
527 SoftwareImageDecodeController controller; | 527 SoftwareImageDecodeController controller; |
528 bool is_decomposable = true; | 528 bool is_decomposable = true; |
529 uint64_t prepare_tiles_id = 1; | 529 uint64_t prepare_tiles_id = 1; |
530 SkFilterQuality quality = kLow_SkFilterQuality; | 530 SkFilterQuality quality = kLow_SkFilterQuality; |
531 | 531 |
532 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 532 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
533 DrawImage draw_image( | 533 DrawImage draw_image( |
534 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 534 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
535 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 535 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
536 scoped_refptr<ImageDecodeTask> task; | 536 scoped_refptr<TileTask> task; |
537 bool need_unref = | 537 bool need_unref = |
538 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 538 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
539 EXPECT_TRUE(need_unref); | 539 EXPECT_TRUE(need_unref); |
540 EXPECT_TRUE(task); | 540 EXPECT_TRUE(task); |
541 | 541 |
542 task->WillSchedule(); | 542 task->WillSchedule(); |
543 task->ScheduleOnOriginThread(nullptr); | 543 task->ScheduleOnOriginThread(nullptr); |
544 task->DidSchedule(); | 544 task->DidSchedule(); |
545 task->RunOnWorkerThread(); | 545 task->RunOnWorkerThread(); |
546 | 546 |
547 scoped_refptr<ImageDecodeTask> another_task; | 547 scoped_refptr<TileTask> another_task; |
548 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 548 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
549 &another_task); | 549 &another_task); |
550 EXPECT_TRUE(need_unref); | 550 EXPECT_TRUE(need_unref); |
551 EXPECT_FALSE(another_task); | 551 EXPECT_FALSE(another_task); |
552 | 552 |
553 task->WillComplete(); | 553 task->WillComplete(); |
554 task->CompleteOnOriginThread(nullptr); | 554 task->CompleteOnOriginThread(nullptr); |
555 task->DidComplete(); | 555 task->DidComplete(); |
556 | 556 |
557 scoped_refptr<ImageDecodeTask> third_task; | 557 scoped_refptr<TileTask> third_task; |
558 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 558 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
559 &third_task); | 559 &third_task); |
560 EXPECT_TRUE(need_unref); | 560 EXPECT_TRUE(need_unref); |
561 EXPECT_FALSE(third_task); | 561 EXPECT_FALSE(third_task); |
562 | 562 |
563 controller.UnrefImage(draw_image); | 563 controller.UnrefImage(draw_image); |
564 controller.UnrefImage(draw_image); | 564 controller.UnrefImage(draw_image); |
565 controller.UnrefImage(draw_image); | 565 controller.UnrefImage(draw_image); |
566 } | 566 } |
567 | 567 |
568 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { | 568 TEST(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { |
569 SoftwareImageDecodeController controller; | 569 SoftwareImageDecodeController controller; |
570 bool is_decomposable = true; | 570 bool is_decomposable = true; |
571 uint64_t prepare_tiles_id = 1; | 571 uint64_t prepare_tiles_id = 1; |
572 SkFilterQuality quality = kHigh_SkFilterQuality; | 572 SkFilterQuality quality = kHigh_SkFilterQuality; |
573 | 573 |
574 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 574 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
575 DrawImage draw_image( | 575 DrawImage draw_image( |
576 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 576 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
577 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 577 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
578 scoped_refptr<ImageDecodeTask> task; | 578 scoped_refptr<TileTask> task; |
579 bool need_unref = | 579 bool need_unref = |
580 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 580 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
581 EXPECT_TRUE(need_unref); | 581 EXPECT_TRUE(need_unref); |
582 EXPECT_TRUE(task); | 582 EXPECT_TRUE(task); |
583 | 583 |
584 task->WillSchedule(); | 584 task->WillSchedule(); |
585 task->ScheduleOnOriginThread(nullptr); | 585 task->ScheduleOnOriginThread(nullptr); |
586 task->DidSchedule(); | 586 task->DidSchedule(); |
587 | 587 |
588 scoped_refptr<ImageDecodeTask> another_task; | 588 scoped_refptr<TileTask> another_task; |
589 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 589 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
590 &another_task); | 590 &another_task); |
591 EXPECT_TRUE(need_unref); | 591 EXPECT_TRUE(need_unref); |
592 EXPECT_TRUE(another_task.get() == task.get()); | 592 EXPECT_TRUE(another_task.get() == task.get()); |
593 | 593 |
594 // Didn't run the task, complete it (it was canceled). | 594 // Didn't run the task, complete it (it was canceled). |
595 task->WillComplete(); | 595 task->WillComplete(); |
596 task->CompleteOnOriginThread(nullptr); | 596 task->CompleteOnOriginThread(nullptr); |
597 task->DidComplete(); | 597 task->DidComplete(); |
598 | 598 |
599 // Fully cancel everything (so the raster would unref things). | 599 // Fully cancel everything (so the raster would unref things). |
600 controller.UnrefImage(draw_image); | 600 controller.UnrefImage(draw_image); |
601 controller.UnrefImage(draw_image); | 601 controller.UnrefImage(draw_image); |
602 | 602 |
603 // Here a new task is created. | 603 // Here a new task is created. |
604 scoped_refptr<ImageDecodeTask> third_task; | 604 scoped_refptr<TileTask> third_task; |
605 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 605 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
606 &third_task); | 606 &third_task); |
607 EXPECT_TRUE(need_unref); | 607 EXPECT_TRUE(need_unref); |
608 EXPECT_TRUE(third_task); | 608 EXPECT_TRUE(third_task); |
609 EXPECT_FALSE(third_task.get() == task.get()); | 609 EXPECT_FALSE(third_task.get() == task.get()); |
610 | 610 |
611 controller.UnrefImage(draw_image); | 611 controller.UnrefImage(draw_image); |
612 } | 612 } |
613 | 613 |
614 TEST(SoftwareImageDecodeControllerTest, | 614 TEST(SoftwareImageDecodeControllerTest, |
615 GetTaskForImageCanceledWhileReffedGetsNewTask) { | 615 GetTaskForImageCanceledWhileReffedGetsNewTask) { |
616 SoftwareImageDecodeController controller; | 616 SoftwareImageDecodeController controller; |
617 bool is_decomposable = true; | 617 bool is_decomposable = true; |
618 uint64_t prepare_tiles_id = 1; | 618 uint64_t prepare_tiles_id = 1; |
619 SkFilterQuality quality = kHigh_SkFilterQuality; | 619 SkFilterQuality quality = kHigh_SkFilterQuality; |
620 | 620 |
621 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 621 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
622 DrawImage draw_image( | 622 DrawImage draw_image( |
623 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 623 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
624 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 624 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
625 scoped_refptr<ImageDecodeTask> task; | 625 scoped_refptr<TileTask> task; |
626 bool need_unref = | 626 bool need_unref = |
627 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 627 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
628 EXPECT_TRUE(need_unref); | 628 EXPECT_TRUE(need_unref); |
629 EXPECT_TRUE(task); | 629 EXPECT_TRUE(task); |
630 | 630 |
631 task->WillSchedule(); | 631 task->WillSchedule(); |
632 task->ScheduleOnOriginThread(nullptr); | 632 task->ScheduleOnOriginThread(nullptr); |
633 task->DidSchedule(); | 633 task->DidSchedule(); |
634 | 634 |
635 scoped_refptr<ImageDecodeTask> another_task; | 635 scoped_refptr<TileTask> another_task; |
636 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 636 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
637 &another_task); | 637 &another_task); |
638 EXPECT_TRUE(need_unref); | 638 EXPECT_TRUE(need_unref); |
639 EXPECT_TRUE(another_task.get() == task.get()); | 639 EXPECT_TRUE(another_task.get() == task.get()); |
640 | 640 |
641 // Didn't run the task, complete it (it was canceled). | 641 // Didn't run the task, complete it (it was canceled). |
642 task->WillComplete(); | 642 task->WillComplete(); |
643 task->CompleteOnOriginThread(nullptr); | 643 task->CompleteOnOriginThread(nullptr); |
644 task->DidComplete(); | 644 task->DidComplete(); |
645 | 645 |
646 // Note that here, everything is reffed, but a new task is created. This is | 646 // Note that here, everything is reffed, but a new task is created. This is |
647 // possible with repeated schedule/cancel operations. | 647 // possible with repeated schedule/cancel operations. |
648 scoped_refptr<ImageDecodeTask> third_task; | 648 scoped_refptr<TileTask> third_task; |
649 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, | 649 need_unref = controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, |
650 &third_task); | 650 &third_task); |
651 EXPECT_TRUE(need_unref); | 651 EXPECT_TRUE(need_unref); |
652 EXPECT_TRUE(third_task); | 652 EXPECT_TRUE(third_task); |
653 EXPECT_FALSE(third_task.get() == task.get()); | 653 EXPECT_FALSE(third_task.get() == task.get()); |
654 | 654 |
655 // 3 Unrefs! | 655 // 3 Unrefs! |
656 controller.UnrefImage(draw_image); | 656 controller.UnrefImage(draw_image); |
657 controller.UnrefImage(draw_image); | 657 controller.UnrefImage(draw_image); |
658 controller.UnrefImage(draw_image); | 658 controller.UnrefImage(draw_image); |
659 } | 659 } |
660 | 660 |
661 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { | 661 TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) { |
662 SoftwareImageDecodeController controller; | 662 SoftwareImageDecodeController controller; |
663 bool is_decomposable = true; | 663 bool is_decomposable = true; |
664 uint64_t prepare_tiles_id = 1; | 664 uint64_t prepare_tiles_id = 1; |
665 SkFilterQuality quality = kHigh_SkFilterQuality; | 665 SkFilterQuality quality = kHigh_SkFilterQuality; |
666 | 666 |
667 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 667 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
668 DrawImage draw_image( | 668 DrawImage draw_image( |
669 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 669 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
670 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 670 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
671 scoped_refptr<ImageDecodeTask> task; | 671 scoped_refptr<TileTask> task; |
672 bool need_unref = | 672 bool need_unref = |
673 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 673 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
674 EXPECT_TRUE(need_unref); | 674 EXPECT_TRUE(need_unref); |
675 EXPECT_TRUE(task); | 675 EXPECT_TRUE(task); |
676 | 676 |
677 task->WillSchedule(); | 677 task->WillSchedule(); |
678 task->ScheduleOnOriginThread(nullptr); | 678 task->ScheduleOnOriginThread(nullptr); |
679 task->DidSchedule(); | 679 task->DidSchedule(); |
680 | 680 |
681 task->RunOnWorkerThread(); | 681 task->RunOnWorkerThread(); |
(...skipping 21 matching lines...) Expand all Loading... |
703 GetDecodedImageForDrawWithNonContainedSrcRect) { | 703 GetDecodedImageForDrawWithNonContainedSrcRect) { |
704 SoftwareImageDecodeController controller; | 704 SoftwareImageDecodeController controller; |
705 bool is_decomposable = true; | 705 bool is_decomposable = true; |
706 uint64_t prepare_tiles_id = 1; | 706 uint64_t prepare_tiles_id = 1; |
707 SkFilterQuality quality = kHigh_SkFilterQuality; | 707 SkFilterQuality quality = kHigh_SkFilterQuality; |
708 | 708 |
709 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 709 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
710 DrawImage draw_image( | 710 DrawImage draw_image( |
711 image.get(), SkIRect::MakeXYWH(20, 30, image->width(), image->height()), | 711 image.get(), SkIRect::MakeXYWH(20, 30, image->width(), image->height()), |
712 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 712 quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
713 scoped_refptr<ImageDecodeTask> task; | 713 scoped_refptr<TileTask> task; |
714 bool need_unref = | 714 bool need_unref = |
715 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 715 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
716 EXPECT_TRUE(need_unref); | 716 EXPECT_TRUE(need_unref); |
717 EXPECT_TRUE(task); | 717 EXPECT_TRUE(task); |
718 | 718 |
719 task->WillSchedule(); | 719 task->WillSchedule(); |
720 task->ScheduleOnOriginThread(nullptr); | 720 task->ScheduleOnOriginThread(nullptr); |
721 task->DidSchedule(); | 721 task->DidSchedule(); |
722 | 722 |
723 task->RunOnWorkerThread(); | 723 task->RunOnWorkerThread(); |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
812 controller.GetDecodedImageForDraw(draw_image); | 812 controller.GetDecodedImageForDraw(draw_image); |
813 EXPECT_TRUE(decoded_draw_image.image()); | 813 EXPECT_TRUE(decoded_draw_image.image()); |
814 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 814 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
815 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 815 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
816 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 816 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
817 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 817 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
818 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 818 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
819 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 819 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
820 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 820 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
821 | 821 |
822 scoped_refptr<ImageDecodeTask> task; | 822 scoped_refptr<TileTask> task; |
823 bool need_unref = | 823 bool need_unref = |
824 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 824 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
825 EXPECT_TRUE(need_unref); | 825 EXPECT_TRUE(need_unref); |
826 EXPECT_TRUE(task); | 826 EXPECT_TRUE(task); |
827 | 827 |
828 task->WillSchedule(); | 828 task->WillSchedule(); |
829 task->ScheduleOnOriginThread(nullptr); | 829 task->ScheduleOnOriginThread(nullptr); |
830 task->DidSchedule(); | 830 task->DidSchedule(); |
831 | 831 |
832 task->RunOnWorkerThread(); | 832 task->RunOnWorkerThread(); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
866 controller.GetDecodedImageForDraw(draw_image); | 866 controller.GetDecodedImageForDraw(draw_image); |
867 EXPECT_TRUE(decoded_draw_image.image()); | 867 EXPECT_TRUE(decoded_draw_image.image()); |
868 EXPECT_EQ(50, decoded_draw_image.image()->width()); | 868 EXPECT_EQ(50, decoded_draw_image.image()->width()); |
869 EXPECT_EQ(50, decoded_draw_image.image()->height()); | 869 EXPECT_EQ(50, decoded_draw_image.image()->height()); |
870 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); | 870 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().width()); |
871 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); | 871 EXPECT_FLOAT_EQ(0.5f, decoded_draw_image.scale_adjustment().height()); |
872 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 872 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
873 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); | 873 EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity()); |
874 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); | 874 EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
875 | 875 |
876 scoped_refptr<ImageDecodeTask> task; | 876 scoped_refptr<TileTask> task; |
877 bool need_unref = | 877 bool need_unref = |
878 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 878 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
879 EXPECT_TRUE(need_unref); | 879 EXPECT_TRUE(need_unref); |
880 EXPECT_TRUE(task); | 880 EXPECT_TRUE(task); |
881 | 881 |
882 task->WillSchedule(); | 882 task->WillSchedule(); |
883 task->ScheduleOnOriginThread(nullptr); | 883 task->ScheduleOnOriginThread(nullptr); |
884 task->DidSchedule(); | 884 task->DidSchedule(); |
885 | 885 |
886 // If we finish the draw here, then we will use it for the locked decode | 886 // If we finish the draw here, then we will use it for the locked decode |
(...skipping 22 matching lines...) Expand all Loading... |
909 SoftwareImageDecodeController controller; | 909 SoftwareImageDecodeController controller; |
910 bool is_decomposable = true; | 910 bool is_decomposable = true; |
911 uint64_t prepare_tiles_id = 1; | 911 uint64_t prepare_tiles_id = 1; |
912 SkFilterQuality quality = kHigh_SkFilterQuality; | 912 SkFilterQuality quality = kHigh_SkFilterQuality; |
913 | 913 |
914 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 914 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
915 DrawImage draw_image( | 915 DrawImage draw_image( |
916 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 916 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
917 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); | 917 CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); |
918 | 918 |
919 scoped_refptr<ImageDecodeTask> task; | 919 scoped_refptr<TileTask> task; |
920 bool need_unref = | 920 bool need_unref = |
921 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 921 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
922 EXPECT_FALSE(task); | 922 EXPECT_FALSE(task); |
923 EXPECT_FALSE(need_unref); | 923 EXPECT_FALSE(need_unref); |
924 | 924 |
925 DecodedDrawImage decoded_draw_image = | 925 DecodedDrawImage decoded_draw_image = |
926 controller.GetDecodedImageForDraw(draw_image); | 926 controller.GetDecodedImageForDraw(draw_image); |
927 EXPECT_FALSE(decoded_draw_image.image()); | 927 EXPECT_FALSE(decoded_draw_image.image()); |
928 | 928 |
929 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 929 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
930 } | 930 } |
931 | 931 |
932 TEST(SoftwareImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { | 932 TEST(SoftwareImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { |
933 SoftwareImageDecodeController controller; | 933 SoftwareImageDecodeController controller; |
934 bool is_decomposable = true; | 934 bool is_decomposable = true; |
935 uint64_t prepare_tiles_id = 1; | 935 uint64_t prepare_tiles_id = 1; |
936 SkFilterQuality quality = kHigh_SkFilterQuality; | 936 SkFilterQuality quality = kHigh_SkFilterQuality; |
937 | 937 |
938 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 938 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
939 DrawImage draw_image( | 939 DrawImage draw_image( |
940 image.get(), SkIRect::MakeXYWH(150, 150, image->width(), image->height()), | 940 image.get(), SkIRect::MakeXYWH(150, 150, image->width(), image->height()), |
941 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 941 quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
942 | 942 |
943 scoped_refptr<ImageDecodeTask> task; | 943 scoped_refptr<TileTask> task; |
944 bool need_unref = | 944 bool need_unref = |
945 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 945 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
946 EXPECT_FALSE(task); | 946 EXPECT_FALSE(task); |
947 EXPECT_FALSE(need_unref); | 947 EXPECT_FALSE(need_unref); |
948 | 948 |
949 DecodedDrawImage decoded_draw_image = | 949 DecodedDrawImage decoded_draw_image = |
950 controller.GetDecodedImageForDraw(draw_image); | 950 controller.GetDecodedImageForDraw(draw_image); |
951 EXPECT_FALSE(decoded_draw_image.image()); | 951 EXPECT_FALSE(decoded_draw_image.image()); |
952 | 952 |
953 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 953 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
954 } | 954 } |
955 | 955 |
956 TEST(SoftwareImageDecodeControllerTest, LowQualityFilterIsHandled) { | 956 TEST(SoftwareImageDecodeControllerTest, LowQualityFilterIsHandled) { |
957 SoftwareImageDecodeController controller; | 957 SoftwareImageDecodeController controller; |
958 bool is_decomposable = true; | 958 bool is_decomposable = true; |
959 uint64_t prepare_tiles_id = 1; | 959 uint64_t prepare_tiles_id = 1; |
960 SkFilterQuality quality = kLow_SkFilterQuality; | 960 SkFilterQuality quality = kLow_SkFilterQuality; |
961 | 961 |
962 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 962 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
963 DrawImage draw_image( | 963 DrawImage draw_image( |
964 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, | 964 image.get(), SkIRect::MakeWH(image->width(), image->height()), quality, |
965 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); | 965 CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
966 | 966 |
967 scoped_refptr<ImageDecodeTask> task; | 967 scoped_refptr<TileTask> task; |
968 bool need_unref = | 968 bool need_unref = |
969 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 969 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
970 EXPECT_TRUE(task); | 970 EXPECT_TRUE(task); |
971 EXPECT_TRUE(need_unref); | 971 EXPECT_TRUE(need_unref); |
972 | 972 |
973 DecodedDrawImage decoded_draw_image = | 973 DecodedDrawImage decoded_draw_image = |
974 controller.GetDecodedImageForDraw(draw_image); | 974 controller.GetDecodedImageForDraw(draw_image); |
975 EXPECT_TRUE(decoded_draw_image.image()); | 975 EXPECT_TRUE(decoded_draw_image.image()); |
976 // If we decoded the image and cached it, it would be stored in a different | 976 // If we decoded the image and cached it, it would be stored in a different |
977 // SkImage object. | 977 // SkImage object. |
978 EXPECT_TRUE(decoded_draw_image.image() != image.get()); | 978 EXPECT_TRUE(decoded_draw_image.image() != image.get()); |
979 | 979 |
980 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 980 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
981 controller.UnrefImage(draw_image); | 981 controller.UnrefImage(draw_image); |
982 } | 982 } |
983 | 983 |
984 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { | 984 TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) { |
985 SoftwareImageDecodeController controller; | 985 SoftwareImageDecodeController controller; |
986 bool is_decomposable = true; | 986 bool is_decomposable = true; |
987 uint64_t prepare_tiles_id = 1; | 987 uint64_t prepare_tiles_id = 1; |
988 SkFilterQuality quality = kLow_SkFilterQuality; | 988 SkFilterQuality quality = kLow_SkFilterQuality; |
989 | 989 |
990 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 990 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
991 DrawImage draw_image(image.get(), SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 991 DrawImage draw_image(image.get(), SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
992 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 992 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
993 | 993 |
994 scoped_refptr<ImageDecodeTask> task; | 994 scoped_refptr<TileTask> task; |
995 bool need_unref = | 995 bool need_unref = |
996 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 996 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
997 EXPECT_TRUE(task); | 997 EXPECT_TRUE(task); |
998 EXPECT_TRUE(need_unref); | 998 EXPECT_TRUE(need_unref); |
999 | 999 |
1000 DecodedDrawImage decoded_draw_image = | 1000 DecodedDrawImage decoded_draw_image = |
1001 controller.GetDecodedImageForDraw(draw_image); | 1001 controller.GetDecodedImageForDraw(draw_image); |
1002 EXPECT_TRUE(decoded_draw_image.image()); | 1002 EXPECT_TRUE(decoded_draw_image.image()); |
1003 // If we decoded the image and cached it, it would be stored in a different | 1003 // If we decoded the image and cached it, it would be stored in a different |
1004 // SkImage object. | 1004 // SkImage object. |
1005 EXPECT_TRUE(decoded_draw_image.image() != image.get()); | 1005 EXPECT_TRUE(decoded_draw_image.image() != image.get()); |
1006 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); | 1006 EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality()); |
1007 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1007 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
1008 | 1008 |
1009 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1009 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
1010 controller.UnrefImage(draw_image); | 1010 controller.UnrefImage(draw_image); |
1011 } | 1011 } |
1012 | 1012 |
1013 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { | 1013 TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) { |
1014 SoftwareImageDecodeController controller; | 1014 SoftwareImageDecodeController controller; |
1015 bool is_decomposable = true; | 1015 bool is_decomposable = true; |
1016 uint64_t prepare_tiles_id = 1; | 1016 uint64_t prepare_tiles_id = 1; |
1017 SkFilterQuality quality = kNone_SkFilterQuality; | 1017 SkFilterQuality quality = kNone_SkFilterQuality; |
1018 | 1018 |
1019 skia::RefPtr<SkImage> image = CreateImage(100, 100); | 1019 skia::RefPtr<SkImage> image = CreateImage(100, 100); |
1020 DrawImage draw_image(image.get(), SkIRect::MakeXYWH(10, 10, 80, 80), quality, | 1020 DrawImage draw_image(image.get(), SkIRect::MakeXYWH(10, 10, 80, 80), quality, |
1021 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); | 1021 CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
1022 | 1022 |
1023 scoped_refptr<ImageDecodeTask> task; | 1023 scoped_refptr<TileTask> task; |
1024 bool need_unref = | 1024 bool need_unref = |
1025 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); | 1025 controller.GetTaskForImageAndRef(draw_image, prepare_tiles_id, &task); |
1026 EXPECT_TRUE(task); | 1026 EXPECT_TRUE(task); |
1027 EXPECT_TRUE(need_unref); | 1027 EXPECT_TRUE(need_unref); |
1028 | 1028 |
1029 DecodedDrawImage decoded_draw_image = | 1029 DecodedDrawImage decoded_draw_image = |
1030 controller.GetDecodedImageForDraw(draw_image); | 1030 controller.GetDecodedImageForDraw(draw_image); |
1031 EXPECT_TRUE(decoded_draw_image.image()); | 1031 EXPECT_TRUE(decoded_draw_image.image()); |
1032 // If we decoded the image and cached it, it would be stored in a different | 1032 // If we decoded the image and cached it, it would be stored in a different |
1033 // SkImage object. | 1033 // SkImage object. |
1034 EXPECT_TRUE(decoded_draw_image.image() != image.get()); | 1034 EXPECT_TRUE(decoded_draw_image.image() != image.get()); |
1035 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); | 1035 EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality()); |
1036 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); | 1036 EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity()); |
1037 | 1037 |
1038 controller.DrawWithImageFinished(draw_image, decoded_draw_image); | 1038 controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
1039 controller.UnrefImage(draw_image); | 1039 controller.UnrefImage(draw_image); |
1040 } | 1040 } |
1041 } // namespace | 1041 } // namespace |
1042 } // namespace cc | 1042 } // namespace cc |
OLD | NEW |