OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013, Google Inc. All rights reserved. | 2 * Copyright (c) 2013, Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
92 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, | 92 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f, |
93 0x00, 0xb2, 0xc0, 0x07, 0xff, 0xd9}; | 93 0x00, 0xb2, 0xc0, 0x07, 0xff, 0xd9}; |
94 | 94 |
95 constexpr int kJpegImageWidth = 1; | 95 constexpr int kJpegImageWidth = 1; |
96 constexpr int kJpegImageHeight = 1; | 96 constexpr int kJpegImageHeight = 1; |
97 | 97 |
98 constexpr size_t kJpegImageSubrangeWithDimensionsLength = | 98 constexpr size_t kJpegImageSubrangeWithDimensionsLength = |
99 sizeof(kJpegImage) - 1; | 99 sizeof(kJpegImage) - 1; |
100 constexpr size_t kJpegImageSubrangeWithoutDimensionsLength = 3; | 100 constexpr size_t kJpegImageSubrangeWithoutDimensionsLength = 3; |
101 | 101 |
| 102 class ImageResourceTest : public ::testing::Test { |
| 103 protected: |
| 104 void SetUp() override { |
| 105 task_runner_ = AdoptRef(new scheduler::FakeWebTaskRunner); |
| 106 } |
| 107 |
| 108 RefPtr<scheduler::FakeWebTaskRunner> task_runner_; |
| 109 }; |
| 110 |
102 // Ensure that the image decoder can determine the dimensions of kJpegImage from | 111 // Ensure that the image decoder can determine the dimensions of kJpegImage from |
103 // just the first kJpegImageSubrangeWithDimensionsLength bytes. If this test | 112 // just the first kJpegImageSubrangeWithDimensionsLength bytes. If this test |
104 // fails, then the test data here probably needs to be updated. | 113 // fails, then the test data here probably needs to be updated. |
105 TEST(ImageResourceTest, DimensionsDecodableFromPartialTestImage) { | 114 TEST_F(ImageResourceTest, DimensionsDecodableFromPartialTestImage) { |
106 RefPtr<Image> image = BitmapImage::Create(); | 115 RefPtr<Image> image = |
| 116 BitmapImage::Create(AdoptRef(new scheduler::FakeWebTaskRunner)); |
107 EXPECT_EQ( | 117 EXPECT_EQ( |
108 Image::kSizeAvailable, | 118 Image::kSizeAvailable, |
109 image->SetData(SharedBuffer::Create( | 119 image->SetData(SharedBuffer::Create( |
110 kJpegImage, kJpegImageSubrangeWithDimensionsLength), | 120 kJpegImage, kJpegImageSubrangeWithDimensionsLength), |
111 true)); | 121 true)); |
112 EXPECT_TRUE(image->IsBitmapImage()); | 122 EXPECT_TRUE(image->IsBitmapImage()); |
113 EXPECT_EQ(1, image->width()); | 123 EXPECT_EQ(1, image->width()); |
114 EXPECT_EQ(1, image->height()); | 124 EXPECT_EQ(1, image->height()); |
115 } | 125 } |
116 | 126 |
(...skipping 204 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
321 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); | 331 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); |
322 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 332 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
323 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsSVGImage()); | 333 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsSVGImage()); |
324 } | 334 } |
325 | 335 |
326 ResourceFetcher* CreateFetcher() { | 336 ResourceFetcher* CreateFetcher() { |
327 return ResourceFetcher::Create( | 337 return ResourceFetcher::Create( |
328 MockFetchContext::Create(MockFetchContext::kShouldLoadNewResource)); | 338 MockFetchContext::Create(MockFetchContext::kShouldLoadNewResource)); |
329 } | 339 } |
330 | 340 |
331 TEST(ImageResourceTest, MultipartImage) { | 341 TEST_F(ImageResourceTest, MultipartImage) { |
332 ResourceFetcher* fetcher = CreateFetcher(); | 342 ResourceFetcher* fetcher = CreateFetcher(); |
333 KURL test_url(kParsedURLString, kTestURL); | 343 KURL test_url(kParsedURLString, kTestURL); |
334 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 344 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
335 | 345 |
336 // Emulate starting a real load, but don't expect any "real" | 346 // Emulate starting a real load, but don't expect any "real" |
337 // WebURLLoaderClient callbacks. | 347 // WebURLLoaderClient callbacks. |
338 ImageResource* image_resource = | 348 ImageResource* image_resource = |
339 ImageResource::Create(ResourceRequest(test_url)); | 349 ImageResource::Create(task_runner_, ResourceRequest(test_url)); |
340 image_resource->SetIdentifier(CreateUniqueIdentifier()); | 350 image_resource->SetIdentifier(CreateUniqueIdentifier()); |
341 fetcher->StartLoad(image_resource); | 351 fetcher->StartLoad(image_resource); |
342 | 352 |
343 std::unique_ptr<MockImageResourceObserver> observer = | 353 std::unique_ptr<MockImageResourceObserver> observer = |
344 MockImageResourceObserver::Create(image_resource->GetContent()); | 354 MockImageResourceObserver::Create(image_resource->GetContent()); |
345 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); | 355 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); |
346 | 356 |
347 // Send the multipart response. No image or data buffer is created. Note that | 357 // Send the multipart response. No image or data buffer is created. Note that |
348 // the response must be routed through ResourceLoader to ensure the load is | 358 // the response must be routed through ResourceLoader to ensure the load is |
349 // flagged as multipart. | 359 // flagged as multipart. |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
403 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 413 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
404 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); | 414 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); |
405 EXPECT_EQ(kJpegImageHeight, | 415 EXPECT_EQ(kJpegImageHeight, |
406 image_resource->GetContent()->GetImage()->height()); | 416 image_resource->GetContent()->GetImage()->height()); |
407 EXPECT_EQ(1, observer->ImageChangedCount()); | 417 EXPECT_EQ(1, observer->ImageChangedCount()); |
408 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 418 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
409 EXPECT_EQ(1, observer2->ImageChangedCount()); | 419 EXPECT_EQ(1, observer2->ImageChangedCount()); |
410 EXPECT_TRUE(observer2->ImageNotifyFinishedCalled()); | 420 EXPECT_TRUE(observer2->ImageNotifyFinishedCalled()); |
411 } | 421 } |
412 | 422 |
413 TEST(ImageResourceTest, CancelOnRemoveObserver) { | 423 TEST_F(ImageResourceTest, CancelOnRemoveObserver) { |
414 KURL test_url(kParsedURLString, kTestURL); | 424 KURL test_url(kParsedURLString, kTestURL); |
415 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 425 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
416 | 426 |
417 ResourceFetcher* fetcher = CreateFetcher(); | 427 ResourceFetcher* fetcher = CreateFetcher(); |
418 | 428 |
419 // Emulate starting a real load. | 429 // Emulate starting a real load. |
420 ImageResource* image_resource = | 430 ImageResource* image_resource = ImageResource::Create( |
421 ImageResource::Create(ResourceRequest(test_url)); | 431 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(test_url)); |
422 image_resource->SetIdentifier(CreateUniqueIdentifier()); | 432 image_resource->SetIdentifier(CreateUniqueIdentifier()); |
423 | 433 |
424 fetcher->StartLoad(image_resource); | 434 fetcher->StartLoad(image_resource); |
425 GetMemoryCache()->Add(image_resource); | 435 GetMemoryCache()->Add(image_resource); |
426 | 436 |
427 std::unique_ptr<MockImageResourceObserver> observer = | 437 std::unique_ptr<MockImageResourceObserver> observer = |
428 MockImageResourceObserver::Create(image_resource->GetContent()); | 438 MockImageResourceObserver::Create(image_resource->GetContent()); |
429 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); | 439 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); |
430 | 440 |
431 // The load should still be alive, but a timer should be started to cancel the | 441 // The load should still be alive, but a timer should be started to cancel the |
432 // load inside removeClient(). | 442 // load inside removeClient(). |
433 observer->RemoveAsObserver(); | 443 observer->RemoveAsObserver(); |
434 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); | 444 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); |
435 EXPECT_TRUE(GetMemoryCache()->ResourceForURL(test_url)); | 445 EXPECT_TRUE(GetMemoryCache()->ResourceForURL(test_url)); |
436 | 446 |
437 // Trigger the cancel timer, ensure the load was cancelled and the resource | 447 // Trigger the cancel timer, ensure the load was cancelled and the resource |
438 // was evicted from the cache. | 448 // was evicted from the cache. |
439 blink::testing::RunPendingTasks(); | 449 blink::testing::RunPendingTasks(); |
440 EXPECT_EQ(ResourceStatus::kLoadError, image_resource->GetStatus()); | 450 EXPECT_EQ(ResourceStatus::kLoadError, image_resource->GetStatus()); |
441 EXPECT_FALSE(GetMemoryCache()->ResourceForURL(test_url)); | 451 EXPECT_FALSE(GetMemoryCache()->ResourceForURL(test_url)); |
442 } | 452 } |
443 | 453 |
444 TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients) { | 454 TEST_F(ImageResourceTest, DecodedDataRemainsWhileHasClients) { |
445 ImageResource* image_resource = ImageResource::Create(ResourceRequest()); | 455 ImageResource* image_resource = ImageResource::Create( |
| 456 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest()); |
446 image_resource->SetStatus(ResourceStatus::kPending); | 457 image_resource->SetStatus(ResourceStatus::kPending); |
447 | 458 |
448 std::unique_ptr<MockImageResourceObserver> observer = | 459 std::unique_ptr<MockImageResourceObserver> observer = |
449 MockImageResourceObserver::Create(image_resource->GetContent()); | 460 MockImageResourceObserver::Create(image_resource->GetContent()); |
450 | 461 |
451 // Send the image response. | 462 // Send the image response. |
452 image_resource->ResponseReceived( | 463 image_resource->ResponseReceived( |
453 ResourceResponse(KURL(), "multipart/x-mixed-replace", 0, g_null_atom), | 464 ResourceResponse(KURL(), "multipart/x-mixed-replace", 0, g_null_atom), |
454 nullptr); | 465 nullptr); |
455 | 466 |
(...skipping 20 matching lines...) Expand all Loading... |
476 // The ImageResource no longer has observers. The decoded image data should be | 487 // The ImageResource no longer has observers. The decoded image data should be |
477 // deleted by prune. | 488 // deleted by prune. |
478 observer->RemoveAsObserver(); | 489 observer->RemoveAsObserver(); |
479 image_resource->Prune(); | 490 image_resource->Prune(); |
480 EXPECT_FALSE(image_resource->IsAlive()); | 491 EXPECT_FALSE(image_resource->IsAlive()); |
481 EXPECT_TRUE(image_resource->GetContent()->HasImage()); | 492 EXPECT_TRUE(image_resource->GetContent()->HasImage()); |
482 // TODO(hajimehoshi): Should check imageResource doesn't have decoded image | 493 // TODO(hajimehoshi): Should check imageResource doesn't have decoded image |
483 // data. | 494 // data. |
484 } | 495 } |
485 | 496 |
486 TEST(ImageResourceTest, UpdateBitmapImages) { | 497 TEST_F(ImageResourceTest, UpdateBitmapImages) { |
487 ImageResource* image_resource = ImageResource::Create(ResourceRequest()); | 498 ImageResource* image_resource = ImageResource::Create( |
| 499 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest()); |
488 image_resource->SetStatus(ResourceStatus::kPending); | 500 image_resource->SetStatus(ResourceStatus::kPending); |
489 | 501 |
490 std::unique_ptr<MockImageResourceObserver> observer = | 502 std::unique_ptr<MockImageResourceObserver> observer = |
491 MockImageResourceObserver::Create(image_resource->GetContent()); | 503 MockImageResourceObserver::Create(image_resource->GetContent()); |
492 | 504 |
493 // Send the image response. | 505 // Send the image response. |
494 image_resource->ResponseReceived( | 506 image_resource->ResponseReceived( |
495 ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), g_null_atom), | 507 ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), g_null_atom), |
496 nullptr); | 508 nullptr); |
497 image_resource->AppendData(reinterpret_cast<const char*>(kJpegImage), | 509 image_resource->AppendData(reinterpret_cast<const char*>(kJpegImage), |
498 sizeof(kJpegImage)); | 510 sizeof(kJpegImage)); |
499 image_resource->Finish(); | 511 image_resource->Finish(); |
500 EXPECT_FALSE(image_resource->ErrorOccurred()); | 512 EXPECT_FALSE(image_resource->ErrorOccurred()); |
501 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 513 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
502 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 514 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
503 EXPECT_EQ(2, observer->ImageChangedCount()); | 515 EXPECT_EQ(2, observer->ImageChangedCount()); |
504 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 516 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
505 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 517 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
506 } | 518 } |
507 | 519 |
508 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) { | 520 TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) { |
509 KURL test_url(kParsedURLString, kTestURL); | 521 KURL test_url(kParsedURLString, kTestURL); |
510 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 522 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
511 ResourceRequest request = ResourceRequest(test_url); | 523 ResourceRequest request = ResourceRequest(test_url); |
512 ImageResource* image_resource = ImageResource::Create(request); | 524 ImageResource* image_resource = ImageResource::Create( |
| 525 AdoptRef(new scheduler::FakeWebTaskRunner), request); |
513 image_resource->SetStatus(ResourceStatus::kPending); | 526 image_resource->SetStatus(ResourceStatus::kPending); |
514 | 527 |
515 std::unique_ptr<MockImageResourceObserver> observer = | 528 std::unique_ptr<MockImageResourceObserver> observer = |
516 MockImageResourceObserver::Create(image_resource->GetContent()); | 529 MockImageResourceObserver::Create(image_resource->GetContent()); |
517 ResourceFetcher* fetcher = CreateFetcher(); | 530 ResourceFetcher* fetcher = CreateFetcher(); |
518 | 531 |
519 // Send the image response. | 532 // Send the image response. |
520 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage), | 533 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage), |
521 g_null_atom); | 534 g_null_atom); |
522 resource_response.AddHTTPHeaderField("chrome-proxy-content-transform", | 535 resource_response.AddHTTPHeaderField("chrome-proxy-content-transform", |
(...skipping 19 matching lines...) Expand all Loading... |
542 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. | 555 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. |
543 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, | 556 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, |
544 Resource::kReloadAlways); | 557 Resource::kReloadAlways); |
545 | 558 |
546 EXPECT_EQ(3, observer->ImageChangedCount()); | 559 EXPECT_EQ(3, observer->ImageChangedCount()); |
547 TestThatReloadIsStartedThenServeReload( | 560 TestThatReloadIsStartedThenServeReload( |
548 test_url, image_resource, image_resource->GetContent(), observer.get(), | 561 test_url, image_resource, image_resource->GetContent(), observer.get(), |
549 WebCachePolicy::kBypassingCache); | 562 WebCachePolicy::kBypassingCache); |
550 } | 563 } |
551 | 564 |
552 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinishedWithOldHeaders) { | 565 TEST_F(ImageResourceTest, |
| 566 ReloadIfLoFiOrPlaceholderAfterFinishedWithOldHeaders) { |
553 KURL test_url(kParsedURLString, kTestURL); | 567 KURL test_url(kParsedURLString, kTestURL); |
554 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 568 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
555 ResourceRequest request = ResourceRequest(test_url); | 569 ResourceRequest request = ResourceRequest(test_url); |
556 ImageResource* image_resource = ImageResource::Create(request); | 570 ImageResource* image_resource = ImageResource::Create( |
| 571 AdoptRef(new scheduler::FakeWebTaskRunner), request); |
557 image_resource->SetStatus(ResourceStatus::kPending); | 572 image_resource->SetStatus(ResourceStatus::kPending); |
558 | 573 |
559 std::unique_ptr<MockImageResourceObserver> observer = | 574 std::unique_ptr<MockImageResourceObserver> observer = |
560 MockImageResourceObserver::Create(image_resource->GetContent()); | 575 MockImageResourceObserver::Create(image_resource->GetContent()); |
561 ResourceFetcher* fetcher = CreateFetcher(); | 576 ResourceFetcher* fetcher = CreateFetcher(); |
562 | 577 |
563 // Send the image response. | 578 // Send the image response. |
564 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage), | 579 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage), |
565 g_null_atom); | 580 g_null_atom); |
566 resource_response.AddHTTPHeaderField("chrome-proxy", "q=low"); | 581 resource_response.AddHTTPHeaderField("chrome-proxy", "q=low"); |
(...skipping 18 matching lines...) Expand all Loading... |
585 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. | 600 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. |
586 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, | 601 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, |
587 Resource::kReloadAlways); | 602 Resource::kReloadAlways); |
588 | 603 |
589 EXPECT_EQ(3, observer->ImageChangedCount()); | 604 EXPECT_EQ(3, observer->ImageChangedCount()); |
590 TestThatReloadIsStartedThenServeReload( | 605 TestThatReloadIsStartedThenServeReload( |
591 test_url, image_resource, image_resource->GetContent(), observer.get(), | 606 test_url, image_resource, image_resource->GetContent(), observer.get(), |
592 WebCachePolicy::kBypassingCache); | 607 WebCachePolicy::kBypassingCache); |
593 } | 608 } |
594 | 609 |
595 TEST(ImageResourceTest, | 610 TEST_F(ImageResourceTest, |
596 ReloadIfLoFiOrPlaceholderAfterFinishedWithoutLoFiHeaders) { | 611 ReloadIfLoFiOrPlaceholderAfterFinishedWithoutLoFiHeaders) { |
597 KURL test_url(kParsedURLString, kTestURL); | 612 KURL test_url(kParsedURLString, kTestURL); |
598 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 613 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
599 ResourceRequest request = ResourceRequest(test_url); | 614 ResourceRequest request = ResourceRequest(test_url); |
600 request.SetPreviewsState(WebURLRequest::kServerLoFiOn); | 615 request.SetPreviewsState(WebURLRequest::kServerLoFiOn); |
601 ImageResource* image_resource = ImageResource::Create(request); | 616 ImageResource* image_resource = ImageResource::Create( |
| 617 AdoptRef(new scheduler::FakeWebTaskRunner), request); |
602 image_resource->SetStatus(ResourceStatus::kPending); | 618 image_resource->SetStatus(ResourceStatus::kPending); |
603 | 619 |
604 std::unique_ptr<MockImageResourceObserver> observer = | 620 std::unique_ptr<MockImageResourceObserver> observer = |
605 MockImageResourceObserver::Create(image_resource->GetContent()); | 621 MockImageResourceObserver::Create(image_resource->GetContent()); |
606 ResourceFetcher* fetcher = CreateFetcher(); | 622 ResourceFetcher* fetcher = CreateFetcher(); |
607 | 623 |
608 // Send the image response, without any LoFi image response headers. | 624 // Send the image response, without any LoFi image response headers. |
609 image_resource->ResponseReceived( | 625 image_resource->ResponseReceived( |
610 ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), g_null_atom), | 626 ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), g_null_atom), |
611 nullptr); | 627 nullptr); |
(...skipping 16 matching lines...) Expand all Loading... |
628 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. | 644 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. |
629 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, | 645 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, |
630 Resource::kReloadAlways); | 646 Resource::kReloadAlways); |
631 | 647 |
632 // The image should not have been reloaded, since it didn't have the LoFi | 648 // The image should not have been reloaded, since it didn't have the LoFi |
633 // image response headers. | 649 // image response headers. |
634 EXPECT_EQ(2, observer->ImageChangedCount()); | 650 EXPECT_EQ(2, observer->ImageChangedCount()); |
635 EXPECT_TRUE(image_resource->IsLoaded()); | 651 EXPECT_TRUE(image_resource->IsLoaded()); |
636 } | 652 } |
637 | 653 |
638 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) { | 654 TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) { |
639 ResourceFetcher* fetcher = CreateFetcher(); | 655 ResourceFetcher* fetcher = CreateFetcher(); |
640 | 656 |
641 KURL test_url(kParsedURLString, kTestURL); | 657 KURL test_url(kParsedURLString, kTestURL); |
642 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 658 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
643 | 659 |
644 ResourceRequest request = ResourceRequest(test_url); | 660 ResourceRequest request = ResourceRequest(test_url); |
645 request.SetPreviewsState(WebURLRequest::kServerLoFiOn); | 661 request.SetPreviewsState(WebURLRequest::kServerLoFiOn); |
646 FetchParameters fetch_params(request, FetchInitiatorInfo()); | 662 FetchParameters fetch_params(request, FetchInitiatorInfo()); |
647 ImageResource* image_resource = ImageResource::Fetch(fetch_params, fetcher); | 663 ImageResource* image_resource = ImageResource::Fetch( |
| 664 AdoptRef(new scheduler::FakeWebTaskRunner), fetch_params, fetcher); |
648 ImageResourceContent* content = image_resource->GetContent(); | 665 ImageResourceContent* content = image_resource->GetContent(); |
649 | 666 |
650 std::unique_ptr<MockImageResourceObserver> observer = | 667 std::unique_ptr<MockImageResourceObserver> observer = |
651 MockImageResourceObserver::Create(content); | 668 MockImageResourceObserver::Create(content); |
652 | 669 |
653 // Send the image response. | 670 // Send the image response. |
654 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage), | 671 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage), |
655 g_null_atom); | 672 g_null_atom); |
656 resource_response.AddHTTPHeaderField("chrome-proxy-content-transform", | 673 resource_response.AddHTTPHeaderField("chrome-proxy-content-transform", |
657 "empty-image"); | 674 "empty-image"); |
(...skipping 12 matching lines...) Expand all Loading... |
670 | 687 |
671 EXPECT_EQ(3, observer->ImageChangedCount()); | 688 EXPECT_EQ(3, observer->ImageChangedCount()); |
672 | 689 |
673 TestThatReloadIsStartedThenServeReload(test_url, image_resource, content, | 690 TestThatReloadIsStartedThenServeReload(test_url, image_resource, content, |
674 observer.get(), | 691 observer.get(), |
675 WebCachePolicy::kBypassingCache); | 692 WebCachePolicy::kBypassingCache); |
676 | 693 |
677 GetMemoryCache()->Remove(image_resource); | 694 GetMemoryCache()->Remove(image_resource); |
678 } | 695 } |
679 | 696 |
680 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) { | 697 TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) { |
681 KURL test_url(kParsedURLString, kTestURL); | 698 KURL test_url(kParsedURLString, kTestURL); |
682 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 699 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
683 | 700 |
684 ResourceRequest request(test_url); | 701 ResourceRequest request(test_url); |
685 request.SetPreviewsState(WebURLRequest::kServerLoFiOn); | 702 request.SetPreviewsState(WebURLRequest::kServerLoFiOn); |
686 FetchParameters fetch_params(request, FetchInitiatorInfo()); | 703 FetchParameters fetch_params(request, FetchInitiatorInfo()); |
687 ResourceFetcher* fetcher = CreateFetcher(); | 704 ResourceFetcher* fetcher = CreateFetcher(); |
688 | 705 |
689 ImageResource* image_resource = ImageResource::Fetch(fetch_params, fetcher); | 706 ImageResource* image_resource = ImageResource::Fetch( |
| 707 AdoptRef(new scheduler::FakeWebTaskRunner), fetch_params, fetcher); |
690 std::unique_ptr<MockImageResourceObserver> observer = | 708 std::unique_ptr<MockImageResourceObserver> observer = |
691 MockImageResourceObserver::Create(image_resource->GetContent()); | 709 MockImageResourceObserver::Create(image_resource->GetContent()); |
692 | 710 |
693 // Send the image response. | 711 // Send the image response. |
694 image_resource->Loader()->DidReceiveResponse( | 712 image_resource->Loader()->DidReceiveResponse( |
695 WrappedResourceResponse(ResourceResponse( | 713 WrappedResourceResponse(ResourceResponse( |
696 test_url, "image/jpeg", sizeof(kJpegImage), g_null_atom))); | 714 test_url, "image/jpeg", sizeof(kJpegImage), g_null_atom))); |
697 image_resource->Loader()->DidReceiveData( | 715 image_resource->Loader()->DidReceiveData( |
698 reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage)); | 716 reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage)); |
699 | 717 |
(...skipping 16 matching lines...) Expand all Loading... |
716 EXPECT_EQ(0, observer->ImageWidthOnLastImageChanged()); | 734 EXPECT_EQ(0, observer->ImageWidthOnLastImageChanged()); |
717 // The observer should not have been notified of completion yet, since the | 735 // The observer should not have been notified of completion yet, since the |
718 // image is still loading. | 736 // image is still loading. |
719 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); | 737 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); |
720 | 738 |
721 TestThatReloadIsStartedThenServeReload( | 739 TestThatReloadIsStartedThenServeReload( |
722 test_url, image_resource, image_resource->GetContent(), observer.get(), | 740 test_url, image_resource, image_resource->GetContent(), observer.get(), |
723 WebCachePolicy::kBypassingCache); | 741 WebCachePolicy::kBypassingCache); |
724 } | 742 } |
725 | 743 |
726 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) { | 744 TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) { |
727 KURL test_url(kParsedURLString, kTestURL); | 745 KURL test_url(kParsedURLString, kTestURL); |
728 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 746 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
729 | 747 |
730 ResourceFetcher* fetcher = CreateFetcher(); | 748 ResourceFetcher* fetcher = CreateFetcher(); |
731 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 749 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
732 params.SetAllowImagePlaceholder(); | 750 params.SetAllowImagePlaceholder(); |
733 ImageResource* image_resource = ImageResource::Fetch(params, fetcher); | 751 ImageResource* image_resource = ImageResource::Fetch( |
| 752 AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher); |
734 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 753 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
735 params.GetPlaceholderImageRequestType()); | 754 params.GetPlaceholderImageRequestType()); |
736 std::unique_ptr<MockImageResourceObserver> observer = | 755 std::unique_ptr<MockImageResourceObserver> observer = |
737 MockImageResourceObserver::Create(image_resource->GetContent()); | 756 MockImageResourceObserver::Create(image_resource->GetContent()); |
738 | 757 |
739 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, | 758 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, |
740 observer.get()); | 759 observer.get()); |
741 | 760 |
742 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, | 761 image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher, |
743 Resource::kReloadAlways); | 762 Resource::kReloadAlways); |
744 | 763 |
745 TestThatReloadIsStartedThenServeReload( | 764 TestThatReloadIsStartedThenServeReload( |
746 test_url, image_resource, image_resource->GetContent(), observer.get(), | 765 test_url, image_resource, image_resource->GetContent(), observer.get(), |
747 WebCachePolicy::kBypassingCache); | 766 WebCachePolicy::kBypassingCache); |
748 } | 767 } |
749 | 768 |
750 TEST(ImageResourceTest, SVGImage) { | 769 TEST_F(ImageResourceTest, SVGImage) { |
751 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 770 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
752 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 771 ImageResource* image_resource = ImageResource::Create( |
| 772 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
753 std::unique_ptr<MockImageResourceObserver> observer = | 773 std::unique_ptr<MockImageResourceObserver> observer = |
754 MockImageResourceObserver::Create(image_resource->GetContent()); | 774 MockImageResourceObserver::Create(image_resource->GetContent()); |
755 | 775 |
756 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, | 776 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, |
757 strlen(kSvgImage)); | 777 strlen(kSvgImage)); |
758 | 778 |
759 EXPECT_FALSE(image_resource->ErrorOccurred()); | 779 EXPECT_FALSE(image_resource->ErrorOccurred()); |
760 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 780 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
761 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 781 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
762 EXPECT_EQ(1, observer->ImageChangedCount()); | 782 EXPECT_EQ(1, observer->ImageChangedCount()); |
763 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 783 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
764 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 784 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
765 } | 785 } |
766 | 786 |
767 TEST(ImageResourceTest, SuccessfulRevalidationJpeg) { | 787 TEST_F(ImageResourceTest, SuccessfulRevalidationJpeg) { |
768 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 788 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
769 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 789 ImageResource* image_resource = ImageResource::Create( |
| 790 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
770 std::unique_ptr<MockImageResourceObserver> observer = | 791 std::unique_ptr<MockImageResourceObserver> observer = |
771 MockImageResourceObserver::Create(image_resource->GetContent()); | 792 MockImageResourceObserver::Create(image_resource->GetContent()); |
772 | 793 |
773 ReceiveResponse(image_resource, url, "image/jpeg", | 794 ReceiveResponse(image_resource, url, "image/jpeg", |
774 reinterpret_cast<const char*>(kJpegImage), | 795 reinterpret_cast<const char*>(kJpegImage), |
775 sizeof(kJpegImage)); | 796 sizeof(kJpegImage)); |
776 | 797 |
777 EXPECT_FALSE(image_resource->ErrorOccurred()); | 798 EXPECT_FALSE(image_resource->ErrorOccurred()); |
778 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 799 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
779 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 800 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
(...skipping 15 matching lines...) Expand all Loading... |
795 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 816 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
796 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 817 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
797 EXPECT_EQ(2, observer->ImageChangedCount()); | 818 EXPECT_EQ(2, observer->ImageChangedCount()); |
798 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 819 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
799 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 820 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
800 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); | 821 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); |
801 EXPECT_EQ(kJpegImageHeight, | 822 EXPECT_EQ(kJpegImageHeight, |
802 image_resource->GetContent()->GetImage()->height()); | 823 image_resource->GetContent()->GetImage()->height()); |
803 } | 824 } |
804 | 825 |
805 TEST(ImageResourceTest, SuccessfulRevalidationSvg) { | 826 TEST_F(ImageResourceTest, SuccessfulRevalidationSvg) { |
806 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 827 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
807 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 828 ImageResource* image_resource = ImageResource::Create( |
| 829 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
808 std::unique_ptr<MockImageResourceObserver> observer = | 830 std::unique_ptr<MockImageResourceObserver> observer = |
809 MockImageResourceObserver::Create(image_resource->GetContent()); | 831 MockImageResourceObserver::Create(image_resource->GetContent()); |
810 | 832 |
811 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, | 833 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, |
812 strlen(kSvgImage)); | 834 strlen(kSvgImage)); |
813 | 835 |
814 EXPECT_FALSE(image_resource->ErrorOccurred()); | 836 EXPECT_FALSE(image_resource->ErrorOccurred()); |
815 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 837 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
816 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 838 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
817 EXPECT_EQ(1, observer->ImageChangedCount()); | 839 EXPECT_EQ(1, observer->ImageChangedCount()); |
(...skipping 11 matching lines...) Expand all Loading... |
829 EXPECT_FALSE(image_resource->ErrorOccurred()); | 851 EXPECT_FALSE(image_resource->ErrorOccurred()); |
830 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 852 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
831 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 853 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
832 EXPECT_EQ(1, observer->ImageChangedCount()); | 854 EXPECT_EQ(1, observer->ImageChangedCount()); |
833 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 855 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
834 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 856 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
835 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->width()); | 857 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->width()); |
836 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->height()); | 858 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->height()); |
837 } | 859 } |
838 | 860 |
839 TEST(ImageResourceTest, FailedRevalidationJpegToJpeg) { | 861 TEST_F(ImageResourceTest, FailedRevalidationJpegToJpeg) { |
840 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 862 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
841 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 863 ImageResource* image_resource = ImageResource::Create( |
| 864 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
842 std::unique_ptr<MockImageResourceObserver> observer = | 865 std::unique_ptr<MockImageResourceObserver> observer = |
843 MockImageResourceObserver::Create(image_resource->GetContent()); | 866 MockImageResourceObserver::Create(image_resource->GetContent()); |
844 | 867 |
845 ReceiveResponse(image_resource, url, "image/jpeg", | 868 ReceiveResponse(image_resource, url, "image/jpeg", |
846 reinterpret_cast<const char*>(kJpegImage), | 869 reinterpret_cast<const char*>(kJpegImage), |
847 sizeof(kJpegImage)); | 870 sizeof(kJpegImage)); |
848 | 871 |
849 EXPECT_FALSE(image_resource->ErrorOccurred()); | 872 EXPECT_FALSE(image_resource->ErrorOccurred()); |
850 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 873 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
851 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 874 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
(...skipping 12 matching lines...) Expand all Loading... |
864 EXPECT_FALSE(image_resource->ErrorOccurred()); | 887 EXPECT_FALSE(image_resource->ErrorOccurred()); |
865 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 888 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
866 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 889 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
867 EXPECT_EQ(4, observer->ImageChangedCount()); | 890 EXPECT_EQ(4, observer->ImageChangedCount()); |
868 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 891 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
869 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 892 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
870 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width()); | 893 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width()); |
871 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height()); | 894 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height()); |
872 } | 895 } |
873 | 896 |
874 TEST(ImageResourceTest, FailedRevalidationJpegToSvg) { | 897 TEST_F(ImageResourceTest, FailedRevalidationJpegToSvg) { |
875 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 898 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
876 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 899 ImageResource* image_resource = ImageResource::Create( |
| 900 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
877 std::unique_ptr<MockImageResourceObserver> observer = | 901 std::unique_ptr<MockImageResourceObserver> observer = |
878 MockImageResourceObserver::Create(image_resource->GetContent()); | 902 MockImageResourceObserver::Create(image_resource->GetContent()); |
879 | 903 |
880 ReceiveResponse(image_resource, url, "image/jpeg", | 904 ReceiveResponse(image_resource, url, "image/jpeg", |
881 reinterpret_cast<const char*>(kJpegImage), | 905 reinterpret_cast<const char*>(kJpegImage), |
882 sizeof(kJpegImage)); | 906 sizeof(kJpegImage)); |
883 | 907 |
884 EXPECT_FALSE(image_resource->ErrorOccurred()); | 908 EXPECT_FALSE(image_resource->ErrorOccurred()); |
885 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 909 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
886 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 910 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
(...skipping 11 matching lines...) Expand all Loading... |
898 EXPECT_FALSE(image_resource->ErrorOccurred()); | 922 EXPECT_FALSE(image_resource->ErrorOccurred()); |
899 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 923 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
900 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 924 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
901 EXPECT_EQ(3, observer->ImageChangedCount()); | 925 EXPECT_EQ(3, observer->ImageChangedCount()); |
902 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 926 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
903 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 927 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
904 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->width()); | 928 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->width()); |
905 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->height()); | 929 EXPECT_EQ(200, image_resource->GetContent()->GetImage()->height()); |
906 } | 930 } |
907 | 931 |
908 TEST(ImageResourceTest, FailedRevalidationSvgToJpeg) { | 932 TEST_F(ImageResourceTest, FailedRevalidationSvgToJpeg) { |
909 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 933 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
910 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 934 ImageResource* image_resource = ImageResource::Create( |
| 935 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
911 std::unique_ptr<MockImageResourceObserver> observer = | 936 std::unique_ptr<MockImageResourceObserver> observer = |
912 MockImageResourceObserver::Create(image_resource->GetContent()); | 937 MockImageResourceObserver::Create(image_resource->GetContent()); |
913 | 938 |
914 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, | 939 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, |
915 strlen(kSvgImage)); | 940 strlen(kSvgImage)); |
916 | 941 |
917 EXPECT_FALSE(image_resource->ErrorOccurred()); | 942 EXPECT_FALSE(image_resource->ErrorOccurred()); |
918 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 943 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
919 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 944 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
920 EXPECT_EQ(1, observer->ImageChangedCount()); | 945 EXPECT_EQ(1, observer->ImageChangedCount()); |
(...skipping 11 matching lines...) Expand all Loading... |
932 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 957 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
933 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 958 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
934 EXPECT_EQ(3, observer->ImageChangedCount()); | 959 EXPECT_EQ(3, observer->ImageChangedCount()); |
935 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 960 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
936 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 961 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
937 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); | 962 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); |
938 EXPECT_EQ(kJpegImageHeight, | 963 EXPECT_EQ(kJpegImageHeight, |
939 image_resource->GetContent()->GetImage()->height()); | 964 image_resource->GetContent()->GetImage()->height()); |
940 } | 965 } |
941 | 966 |
942 TEST(ImageResourceTest, FailedRevalidationSvgToSvg) { | 967 TEST_F(ImageResourceTest, FailedRevalidationSvgToSvg) { |
943 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 968 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
944 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 969 ImageResource* image_resource = ImageResource::Create( |
| 970 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
945 std::unique_ptr<MockImageResourceObserver> observer = | 971 std::unique_ptr<MockImageResourceObserver> observer = |
946 MockImageResourceObserver::Create(image_resource->GetContent()); | 972 MockImageResourceObserver::Create(image_resource->GetContent()); |
947 | 973 |
948 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, | 974 ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage, |
949 strlen(kSvgImage)); | 975 strlen(kSvgImage)); |
950 | 976 |
951 EXPECT_FALSE(image_resource->ErrorOccurred()); | 977 EXPECT_FALSE(image_resource->ErrorOccurred()); |
952 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 978 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
953 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 979 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
954 EXPECT_EQ(1, observer->ImageChangedCount()); | 980 EXPECT_EQ(1, observer->ImageChangedCount()); |
(...skipping 11 matching lines...) Expand all Loading... |
966 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 992 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
967 EXPECT_EQ(2, observer->ImageChangedCount()); | 993 EXPECT_EQ(2, observer->ImageChangedCount()); |
968 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 994 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
969 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 995 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
970 EXPECT_EQ(300, image_resource->GetContent()->GetImage()->width()); | 996 EXPECT_EQ(300, image_resource->GetContent()->GetImage()->width()); |
971 EXPECT_EQ(300, image_resource->GetContent()->GetImage()->height()); | 997 EXPECT_EQ(300, image_resource->GetContent()->GetImage()->height()); |
972 } | 998 } |
973 | 999 |
974 // Tests for pruning. | 1000 // Tests for pruning. |
975 | 1001 |
976 TEST(ImageResourceTest, AddClientAfterPrune) { | 1002 TEST_F(ImageResourceTest, AddClientAfterPrune) { |
977 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); | 1003 KURL url(kParsedURLString, "http://127.0.0.1:8000/foo"); |
978 ImageResource* image_resource = ImageResource::Create(ResourceRequest(url)); | 1004 ImageResource* image_resource = ImageResource::Create( |
| 1005 AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url)); |
979 | 1006 |
980 // Adds a ResourceClient but not ImageResourceObserver. | 1007 // Adds a ResourceClient but not ImageResourceObserver. |
981 Persistent<MockResourceClient> client1 = | 1008 Persistent<MockResourceClient> client1 = |
982 new MockResourceClient(image_resource); | 1009 new MockResourceClient(image_resource); |
983 | 1010 |
984 ReceiveResponse(image_resource, url, "image/jpeg", | 1011 ReceiveResponse(image_resource, url, "image/jpeg", |
985 reinterpret_cast<const char*>(kJpegImage), | 1012 reinterpret_cast<const char*>(kJpegImage), |
986 sizeof(kJpegImage)); | 1013 sizeof(kJpegImage)); |
987 | 1014 |
988 EXPECT_FALSE(image_resource->ErrorOccurred()); | 1015 EXPECT_FALSE(image_resource->ErrorOccurred()); |
(...skipping 17 matching lines...) Expand all Loading... |
1006 new MockResourceClient(image_resource); | 1033 new MockResourceClient(image_resource); |
1007 | 1034 |
1008 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 1035 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
1009 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); | 1036 EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull()); |
1010 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); | 1037 EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width()); |
1011 EXPECT_EQ(kJpegImageHeight, | 1038 EXPECT_EQ(kJpegImageHeight, |
1012 image_resource->GetContent()->GetImage()->height()); | 1039 image_resource->GetContent()->GetImage()->height()); |
1013 EXPECT_TRUE(client2->NotifyFinishedCalled()); | 1040 EXPECT_TRUE(client2->NotifyFinishedCalled()); |
1014 } | 1041 } |
1015 | 1042 |
1016 TEST(ImageResourceTest, CancelOnDecodeError) { | 1043 TEST_F(ImageResourceTest, CancelOnDecodeError) { |
1017 KURL test_url(kParsedURLString, kTestURL); | 1044 KURL test_url(kParsedURLString, kTestURL); |
1018 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1045 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1019 | 1046 |
1020 ResourceFetcher* fetcher = CreateFetcher(); | 1047 ResourceFetcher* fetcher = CreateFetcher(); |
1021 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1048 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1022 ImageResource* image_resource = ImageResource::Fetch(params, fetcher); | 1049 ImageResource* image_resource = ImageResource::Fetch( |
| 1050 AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher); |
1023 std::unique_ptr<MockImageResourceObserver> observer = | 1051 std::unique_ptr<MockImageResourceObserver> observer = |
1024 MockImageResourceObserver::Create(image_resource->GetContent()); | 1052 MockImageResourceObserver::Create(image_resource->GetContent()); |
1025 | 1053 |
1026 image_resource->Loader()->DidReceiveResponse( | 1054 image_resource->Loader()->DidReceiveResponse( |
1027 WrappedResourceResponse( | 1055 WrappedResourceResponse( |
1028 ResourceResponse(test_url, "image/jpeg", 18, g_null_atom)), | 1056 ResourceResponse(test_url, "image/jpeg", 18, g_null_atom)), |
1029 nullptr); | 1057 nullptr); |
1030 | 1058 |
1031 EXPECT_EQ(0, observer->ImageChangedCount()); | 1059 EXPECT_EQ(0, observer->ImageChangedCount()); |
1032 | 1060 |
1033 image_resource->Loader()->DidReceiveData("notactuallyanimage", 18); | 1061 image_resource->Loader()->DidReceiveData("notactuallyanimage", 18); |
1034 | 1062 |
1035 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); | 1063 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); |
1036 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 1064 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
1037 EXPECT_EQ(ResourceStatus::kDecodeError, | 1065 EXPECT_EQ(ResourceStatus::kDecodeError, |
1038 observer->StatusOnImageNotifyFinished()); | 1066 observer->StatusOnImageNotifyFinished()); |
1039 EXPECT_EQ(1, observer->ImageChangedCount()); | 1067 EXPECT_EQ(1, observer->ImageChangedCount()); |
1040 EXPECT_FALSE(image_resource->IsLoading()); | 1068 EXPECT_FALSE(image_resource->IsLoading()); |
1041 } | 1069 } |
1042 | 1070 |
1043 TEST(ImageResourceTest, DecodeErrorWithEmptyBody) { | 1071 TEST_F(ImageResourceTest, DecodeErrorWithEmptyBody) { |
1044 KURL test_url(kParsedURLString, kTestURL); | 1072 KURL test_url(kParsedURLString, kTestURL); |
1045 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1073 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1046 | 1074 |
1047 ResourceFetcher* fetcher = CreateFetcher(); | 1075 ResourceFetcher* fetcher = CreateFetcher(); |
1048 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1076 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1049 ImageResource* image_resource = ImageResource::Fetch(params, fetcher); | 1077 ImageResource* image_resource = ImageResource::Fetch( |
| 1078 AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher); |
1050 std::unique_ptr<MockImageResourceObserver> observer = | 1079 std::unique_ptr<MockImageResourceObserver> observer = |
1051 MockImageResourceObserver::Create(image_resource->GetContent()); | 1080 MockImageResourceObserver::Create(image_resource->GetContent()); |
1052 | 1081 |
1053 image_resource->Loader()->DidReceiveResponse( | 1082 image_resource->Loader()->DidReceiveResponse( |
1054 WrappedResourceResponse( | 1083 WrappedResourceResponse( |
1055 ResourceResponse(test_url, "image/jpeg", 0, g_null_atom)), | 1084 ResourceResponse(test_url, "image/jpeg", 0, g_null_atom)), |
1056 nullptr); | 1085 nullptr); |
1057 | 1086 |
1058 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); | 1087 EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus()); |
1059 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); | 1088 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); |
1060 EXPECT_EQ(0, observer->ImageChangedCount()); | 1089 EXPECT_EQ(0, observer->ImageChangedCount()); |
1061 | 1090 |
1062 image_resource->Loader()->DidFinishLoading(0.0, 0, 0); | 1091 image_resource->Loader()->DidFinishLoading(0.0, 0, 0); |
1063 | 1092 |
1064 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); | 1093 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); |
1065 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 1094 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
1066 EXPECT_EQ(ResourceStatus::kDecodeError, | 1095 EXPECT_EQ(ResourceStatus::kDecodeError, |
1067 observer->StatusOnImageNotifyFinished()); | 1096 observer->StatusOnImageNotifyFinished()); |
1068 EXPECT_EQ(1, observer->ImageChangedCount()); | 1097 EXPECT_EQ(1, observer->ImageChangedCount()); |
1069 EXPECT_FALSE(image_resource->IsLoading()); | 1098 EXPECT_FALSE(image_resource->IsLoading()); |
1070 } | 1099 } |
1071 | 1100 |
1072 // Testing DecodeError that occurs in didFinishLoading(). | 1101 // Testing DecodeError that occurs in didFinishLoading(). |
1073 // This is similar to DecodeErrorWithEmptyBody, but with non-empty body. | 1102 // This is similar to DecodeErrorWithEmptyBody, but with non-empty body. |
1074 TEST(ImageResourceTest, PartialContentWithoutDimensions) { | 1103 TEST_F(ImageResourceTest, PartialContentWithoutDimensions) { |
1075 KURL test_url(kParsedURLString, kTestURL); | 1104 KURL test_url(kParsedURLString, kTestURL); |
1076 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1105 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1077 | 1106 |
1078 ResourceRequest resource_request(test_url); | 1107 ResourceRequest resource_request(test_url); |
1079 resource_request.SetHTTPHeaderField("range", "bytes=0-2"); | 1108 resource_request.SetHTTPHeaderField("range", "bytes=0-2"); |
1080 FetchParameters params(resource_request, FetchInitiatorInfo()); | 1109 FetchParameters params(resource_request, FetchInitiatorInfo()); |
1081 ResourceFetcher* fetcher = CreateFetcher(); | 1110 ResourceFetcher* fetcher = CreateFetcher(); |
1082 ImageResource* image_resource = ImageResource::Fetch(params, fetcher); | 1111 ImageResource* image_resource = ImageResource::Fetch( |
| 1112 AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher); |
1083 std::unique_ptr<MockImageResourceObserver> observer = | 1113 std::unique_ptr<MockImageResourceObserver> observer = |
1084 MockImageResourceObserver::Create(image_resource->GetContent()); | 1114 MockImageResourceObserver::Create(image_resource->GetContent()); |
1085 | 1115 |
1086 ResourceResponse partial_response(test_url, "image/jpeg", | 1116 ResourceResponse partial_response(test_url, "image/jpeg", |
1087 kJpegImageSubrangeWithoutDimensionsLength, | 1117 kJpegImageSubrangeWithoutDimensionsLength, |
1088 g_null_atom); | 1118 g_null_atom); |
1089 partial_response.SetHTTPStatusCode(206); | 1119 partial_response.SetHTTPStatusCode(206); |
1090 partial_response.SetHTTPHeaderField( | 1120 partial_response.SetHTTPHeaderField( |
1091 "content-range", | 1121 "content-range", |
1092 BuildContentRange(kJpegImageSubrangeWithoutDimensionsLength, | 1122 BuildContentRange(kJpegImageSubrangeWithoutDimensionsLength, |
(...skipping 14 matching lines...) Expand all Loading... |
1107 kJpegImageSubrangeWithoutDimensionsLength); | 1137 kJpegImageSubrangeWithoutDimensionsLength); |
1108 | 1138 |
1109 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); | 1139 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); |
1110 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 1140 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
1111 EXPECT_EQ(ResourceStatus::kDecodeError, | 1141 EXPECT_EQ(ResourceStatus::kDecodeError, |
1112 observer->StatusOnImageNotifyFinished()); | 1142 observer->StatusOnImageNotifyFinished()); |
1113 EXPECT_EQ(1, observer->ImageChangedCount()); | 1143 EXPECT_EQ(1, observer->ImageChangedCount()); |
1114 EXPECT_FALSE(image_resource->IsLoading()); | 1144 EXPECT_FALSE(image_resource->IsLoading()); |
1115 } | 1145 } |
1116 | 1146 |
1117 TEST(ImageResourceTest, FetchDisallowPlaceholder) { | 1147 TEST_F(ImageResourceTest, FetchDisallowPlaceholder) { |
1118 KURL test_url(kParsedURLString, kTestURL); | 1148 KURL test_url(kParsedURLString, kTestURL); |
1119 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1149 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1120 | 1150 |
1121 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1151 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1122 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1152 ImageResource* image_resource = ImageResource::Fetch( |
| 1153 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1123 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, | 1154 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, |
1124 params.GetPlaceholderImageRequestType()); | 1155 params.GetPlaceholderImageRequestType()); |
1125 std::unique_ptr<MockImageResourceObserver> observer = | 1156 std::unique_ptr<MockImageResourceObserver> observer = |
1126 MockImageResourceObserver::Create(image_resource->GetContent()); | 1157 MockImageResourceObserver::Create(image_resource->GetContent()); |
1127 | 1158 |
1128 TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource, | 1159 TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource, |
1129 observer.get()); | 1160 observer.get()); |
1130 } | 1161 } |
1131 | 1162 |
1132 TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) { | 1163 TEST_F(ImageResourceTest, FetchAllowPlaceholderDataURL) { |
1133 KURL test_url(kParsedURLString, | 1164 KURL test_url(kParsedURLString, |
1134 "data:image/jpeg;base64," + | 1165 "data:image/jpeg;base64," + |
1135 Base64Encode(reinterpret_cast<const char*>(kJpegImage), | 1166 Base64Encode(reinterpret_cast<const char*>(kJpegImage), |
1136 sizeof(kJpegImage))); | 1167 sizeof(kJpegImage))); |
1137 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1168 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1138 params.SetAllowImagePlaceholder(); | 1169 params.SetAllowImagePlaceholder(); |
1139 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1170 ImageResource* image_resource = ImageResource::Fetch( |
| 1171 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1140 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, | 1172 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, |
1141 params.GetPlaceholderImageRequestType()); | 1173 params.GetPlaceholderImageRequestType()); |
1142 EXPECT_EQ(g_null_atom, | 1174 EXPECT_EQ(g_null_atom, |
1143 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1175 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1144 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); | 1176 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); |
1145 } | 1177 } |
1146 | 1178 |
1147 TEST(ImageResourceTest, FetchAllowPlaceholderPostRequest) { | 1179 TEST_F(ImageResourceTest, FetchAllowPlaceholderPostRequest) { |
1148 KURL test_url(kParsedURLString, kTestURL); | 1180 KURL test_url(kParsedURLString, kTestURL); |
1149 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1181 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1150 ResourceRequest resource_request(test_url); | 1182 ResourceRequest resource_request(test_url); |
1151 resource_request.SetHTTPMethod("POST"); | 1183 resource_request.SetHTTPMethod("POST"); |
1152 FetchParameters params(resource_request, FetchInitiatorInfo()); | 1184 FetchParameters params(resource_request, FetchInitiatorInfo()); |
1153 params.SetAllowImagePlaceholder(); | 1185 params.SetAllowImagePlaceholder(); |
1154 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1186 ImageResource* image_resource = ImageResource::Fetch( |
| 1187 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1155 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, | 1188 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, |
1156 params.GetPlaceholderImageRequestType()); | 1189 params.GetPlaceholderImageRequestType()); |
1157 EXPECT_EQ(g_null_atom, | 1190 EXPECT_EQ(g_null_atom, |
1158 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1191 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1159 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); | 1192 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); |
1160 | 1193 |
1161 image_resource->Loader()->Cancel(); | 1194 image_resource->Loader()->Cancel(); |
1162 } | 1195 } |
1163 | 1196 |
1164 TEST(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) { | 1197 TEST_F(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) { |
1165 KURL test_url(kParsedURLString, kTestURL); | 1198 KURL test_url(kParsedURLString, kTestURL); |
1166 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1199 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1167 ResourceRequest resource_request(test_url); | 1200 ResourceRequest resource_request(test_url); |
1168 resource_request.SetHTTPHeaderField("range", "bytes=128-255"); | 1201 resource_request.SetHTTPHeaderField("range", "bytes=128-255"); |
1169 FetchParameters params(resource_request, FetchInitiatorInfo()); | 1202 FetchParameters params(resource_request, FetchInitiatorInfo()); |
1170 params.SetAllowImagePlaceholder(); | 1203 params.SetAllowImagePlaceholder(); |
1171 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1204 ImageResource* image_resource = ImageResource::Fetch( |
| 1205 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1172 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, | 1206 EXPECT_EQ(FetchParameters::kDisallowPlaceholder, |
1173 params.GetPlaceholderImageRequestType()); | 1207 params.GetPlaceholderImageRequestType()); |
1174 EXPECT_EQ("bytes=128-255", | 1208 EXPECT_EQ("bytes=128-255", |
1175 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1209 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1176 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); | 1210 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); |
1177 | 1211 |
1178 image_resource->Loader()->Cancel(); | 1212 image_resource->Loader()->Cancel(); |
1179 } | 1213 } |
1180 | 1214 |
1181 TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) { | 1215 TEST_F(ImageResourceTest, FetchAllowPlaceholderSuccessful) { |
1182 KURL test_url(kParsedURLString, kTestURL); | 1216 KURL test_url(kParsedURLString, kTestURL); |
1183 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1217 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1184 | 1218 |
1185 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1219 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1186 params.SetAllowImagePlaceholder(); | 1220 params.SetAllowImagePlaceholder(); |
1187 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1221 ImageResource* image_resource = ImageResource::Fetch( |
| 1222 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1188 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 1223 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
1189 params.GetPlaceholderImageRequestType()); | 1224 params.GetPlaceholderImageRequestType()); |
1190 std::unique_ptr<MockImageResourceObserver> observer = | 1225 std::unique_ptr<MockImageResourceObserver> observer = |
1191 MockImageResourceObserver::Create(image_resource->GetContent()); | 1226 MockImageResourceObserver::Create(image_resource->GetContent()); |
1192 | 1227 |
1193 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, | 1228 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, |
1194 observer.get()); | 1229 observer.get()); |
1195 } | 1230 } |
1196 | 1231 |
1197 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) { | 1232 TEST_F(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) { |
1198 KURL test_url(kParsedURLString, kTestURL); | 1233 KURL test_url(kParsedURLString, kTestURL); |
1199 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1234 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1200 | 1235 |
1201 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1236 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1202 params.SetAllowImagePlaceholder(); | 1237 params.SetAllowImagePlaceholder(); |
1203 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1238 ImageResource* image_resource = ImageResource::Fetch( |
| 1239 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1204 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 1240 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
1205 params.GetPlaceholderImageRequestType()); | 1241 params.GetPlaceholderImageRequestType()); |
1206 EXPECT_EQ("bytes=0-2047", | 1242 EXPECT_EQ("bytes=0-2047", |
1207 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1243 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1208 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); | 1244 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); |
1209 std::unique_ptr<MockImageResourceObserver> observer = | 1245 std::unique_ptr<MockImageResourceObserver> observer = |
1210 MockImageResourceObserver::Create(image_resource->GetContent()); | 1246 MockImageResourceObserver::Create(image_resource->GetContent()); |
1211 | 1247 |
1212 const char kBadData[] = "notanimageresponse"; | 1248 const char kBadData[] = "notanimageresponse"; |
1213 | 1249 |
(...skipping 13 matching lines...) Expand all Loading... |
1227 // The dimensions could not be extracted, so the full original image should be | 1263 // The dimensions could not be extracted, so the full original image should be |
1228 // loading. | 1264 // loading. |
1229 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); | 1265 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); |
1230 EXPECT_EQ(2, observer->ImageChangedCount()); | 1266 EXPECT_EQ(2, observer->ImageChangedCount()); |
1231 | 1267 |
1232 TestThatReloadIsStartedThenServeReload( | 1268 TestThatReloadIsStartedThenServeReload( |
1233 test_url, image_resource, image_resource->GetContent(), observer.get(), | 1269 test_url, image_resource, image_resource->GetContent(), observer.get(), |
1234 WebCachePolicy::kBypassingCache); | 1270 WebCachePolicy::kBypassingCache); |
1235 } | 1271 } |
1236 | 1272 |
1237 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) { | 1273 TEST_F(ImageResourceTest, |
| 1274 FetchAllowPlaceholderPartialContentWithoutDimensions) { |
1238 KURL test_url(kParsedURLString, kTestURL); | 1275 KURL test_url(kParsedURLString, kTestURL); |
1239 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1276 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1240 | 1277 |
1241 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1278 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1242 params.SetAllowImagePlaceholder(); | 1279 params.SetAllowImagePlaceholder(); |
1243 ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher()); | 1280 ImageResource* image_resource = ImageResource::Fetch( |
| 1281 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1244 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 1282 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
1245 params.GetPlaceholderImageRequestType()); | 1283 params.GetPlaceholderImageRequestType()); |
1246 EXPECT_EQ("bytes=0-2047", | 1284 EXPECT_EQ("bytes=0-2047", |
1247 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1285 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1248 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); | 1286 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); |
1249 std::unique_ptr<MockImageResourceObserver> observer = | 1287 std::unique_ptr<MockImageResourceObserver> observer = |
1250 MockImageResourceObserver::Create(image_resource->GetContent()); | 1288 MockImageResourceObserver::Create(image_resource->GetContent()); |
1251 | 1289 |
1252 // TODO(hiroshige): Make the range request header and partial content length | 1290 // TODO(hiroshige): Make the range request header and partial content length |
1253 // consistent. https://crbug.com/689760. | 1291 // consistent. https://crbug.com/689760. |
(...skipping 19 matching lines...) Expand all Loading... |
1273 kJpegImageSubrangeWithoutDimensionsLength); | 1311 kJpegImageSubrangeWithoutDimensionsLength); |
1274 | 1312 |
1275 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); | 1313 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); |
1276 EXPECT_EQ(2, observer->ImageChangedCount()); | 1314 EXPECT_EQ(2, observer->ImageChangedCount()); |
1277 | 1315 |
1278 TestThatReloadIsStartedThenServeReload( | 1316 TestThatReloadIsStartedThenServeReload( |
1279 test_url, image_resource, image_resource->GetContent(), observer.get(), | 1317 test_url, image_resource, image_resource->GetContent(), observer.get(), |
1280 WebCachePolicy::kBypassingCache); | 1318 WebCachePolicy::kBypassingCache); |
1281 } | 1319 } |
1282 | 1320 |
1283 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) { | 1321 TEST_F(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) { |
1284 KURL test_url(kParsedURLString, kTestURL); | 1322 KURL test_url(kParsedURLString, kTestURL); |
1285 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1323 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1286 | 1324 |
1287 ResourceFetcher* fetcher = CreateFetcher(); | 1325 ResourceFetcher* fetcher = CreateFetcher(); |
1288 | 1326 |
1289 FetchParameters placeholder_params{ResourceRequest(test_url), | 1327 FetchParameters placeholder_params{ResourceRequest(test_url), |
1290 FetchInitiatorInfo()}; | 1328 FetchInitiatorInfo()}; |
1291 placeholder_params.SetAllowImagePlaceholder(); | 1329 placeholder_params.SetAllowImagePlaceholder(); |
1292 ImageResource* image_resource = | 1330 ImageResource* image_resource = ImageResource::Fetch( |
1293 ImageResource::Fetch(placeholder_params, fetcher); | 1331 AdoptRef(new scheduler::FakeWebTaskRunner), placeholder_params, fetcher); |
1294 std::unique_ptr<MockImageResourceObserver> observer = | 1332 std::unique_ptr<MockImageResourceObserver> observer = |
1295 MockImageResourceObserver::Create(image_resource->GetContent()); | 1333 MockImageResourceObserver::Create(image_resource->GetContent()); |
1296 | 1334 |
1297 FetchParameters non_placeholder_params{ResourceRequest(test_url), | 1335 FetchParameters non_placeholder_params{ResourceRequest(test_url), |
1298 FetchInitiatorInfo()}; | 1336 FetchInitiatorInfo()}; |
1299 ImageResource* image_resource2 = | 1337 ImageResource* image_resource2 = |
1300 ImageResource::Fetch(non_placeholder_params, fetcher); | 1338 ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner), |
| 1339 non_placeholder_params, fetcher); |
1301 std::unique_ptr<MockImageResourceObserver> observer2 = | 1340 std::unique_ptr<MockImageResourceObserver> observer2 = |
1302 MockImageResourceObserver::Create(image_resource2->GetContent()); | 1341 MockImageResourceObserver::Create(image_resource2->GetContent()); |
1303 | 1342 |
1304 ImageResource* image_resource3 = | 1343 ImageResource* image_resource3 = |
1305 ImageResource::Fetch(non_placeholder_params, fetcher); | 1344 ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner), |
| 1345 non_placeholder_params, fetcher); |
1306 std::unique_ptr<MockImageResourceObserver> observer3 = | 1346 std::unique_ptr<MockImageResourceObserver> observer3 = |
1307 MockImageResourceObserver::Create(image_resource3->GetContent()); | 1347 MockImageResourceObserver::Create(image_resource3->GetContent()); |
1308 | 1348 |
1309 // |imageResource| remains a placeholder, while following non-placeholder | 1349 // |imageResource| remains a placeholder, while following non-placeholder |
1310 // requests start non-placeholder loading with a separate ImageResource. | 1350 // requests start non-placeholder loading with a separate ImageResource. |
1311 ASSERT_NE(image_resource, image_resource2); | 1351 ASSERT_NE(image_resource, image_resource2); |
1312 ASSERT_NE(image_resource->Loader(), image_resource2->Loader()); | 1352 ASSERT_NE(image_resource->Loader(), image_resource2->Loader()); |
1313 ASSERT_NE(image_resource->GetContent(), image_resource2->GetContent()); | 1353 ASSERT_NE(image_resource->GetContent(), image_resource2->GetContent()); |
1314 ASSERT_EQ(image_resource2, image_resource3); | 1354 ASSERT_EQ(image_resource2, image_resource3); |
1315 | 1355 |
1316 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); | 1356 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); |
1317 EXPECT_FALSE(observer2->ImageNotifyFinishedCalled()); | 1357 EXPECT_FALSE(observer2->ImageNotifyFinishedCalled()); |
1318 EXPECT_FALSE(observer3->ImageNotifyFinishedCalled()); | 1358 EXPECT_FALSE(observer3->ImageNotifyFinishedCalled()); |
1319 | 1359 |
1320 // Checks that |imageResource2| (and |imageResource3|) loads a | 1360 // Checks that |imageResource2| (and |imageResource3|) loads a |
1321 // non-placeholder image. | 1361 // non-placeholder image. |
1322 TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource2, | 1362 TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource2, |
1323 observer2.get()); | 1363 observer2.get()); |
1324 EXPECT_TRUE(observer3->ImageNotifyFinishedCalled()); | 1364 EXPECT_TRUE(observer3->ImageNotifyFinishedCalled()); |
1325 | 1365 |
1326 // Checks that |imageResource| will loads a placeholder image. | 1366 // Checks that |imageResource| will loads a placeholder image. |
1327 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, | 1367 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, |
1328 observer.get()); | 1368 observer.get()); |
1329 | 1369 |
1330 // |imageResource2| is still a non-placeholder image. | 1370 // |imageResource2| is still a non-placeholder image. |
1331 EXPECT_FALSE(image_resource2->ShouldShowPlaceholder()); | 1371 EXPECT_FALSE(image_resource2->ShouldShowPlaceholder()); |
1332 EXPECT_TRUE(image_resource2->GetContent()->GetImage()->IsBitmapImage()); | 1372 EXPECT_TRUE(image_resource2->GetContent()->GetImage()->IsBitmapImage()); |
1333 } | 1373 } |
1334 | 1374 |
1335 TEST(ImageResourceTest, | 1375 TEST_F(ImageResourceTest, |
1336 FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) { | 1376 FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) { |
1337 KURL test_url(kParsedURLString, kTestURL); | 1377 KURL test_url(kParsedURLString, kTestURL); |
1338 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1378 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1339 | 1379 |
1340 ResourceFetcher* fetcher = CreateFetcher(); | 1380 ResourceFetcher* fetcher = CreateFetcher(); |
1341 FetchParameters placeholder_params{ResourceRequest(test_url), | 1381 FetchParameters placeholder_params{ResourceRequest(test_url), |
1342 FetchInitiatorInfo()}; | 1382 FetchInitiatorInfo()}; |
1343 placeholder_params.SetAllowImagePlaceholder(); | 1383 placeholder_params.SetAllowImagePlaceholder(); |
1344 ImageResource* image_resource = | 1384 ImageResource* image_resource = ImageResource::Fetch( |
1345 ImageResource::Fetch(placeholder_params, fetcher); | 1385 AdoptRef(new scheduler::FakeWebTaskRunner), placeholder_params, fetcher); |
1346 std::unique_ptr<MockImageResourceObserver> observer = | 1386 std::unique_ptr<MockImageResourceObserver> observer = |
1347 MockImageResourceObserver::Create(image_resource->GetContent()); | 1387 MockImageResourceObserver::Create(image_resource->GetContent()); |
1348 | 1388 |
1349 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, | 1389 TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource, |
1350 observer.get()); | 1390 observer.get()); |
1351 | 1391 |
1352 FetchParameters non_placeholder_params{ResourceRequest(test_url), | 1392 FetchParameters non_placeholder_params{ResourceRequest(test_url), |
1353 FetchInitiatorInfo()}; | 1393 FetchInitiatorInfo()}; |
1354 ImageResource* image_resource2 = | 1394 ImageResource* image_resource2 = |
1355 ImageResource::Fetch(non_placeholder_params, fetcher); | 1395 ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner), |
| 1396 non_placeholder_params, fetcher); |
1356 std::unique_ptr<MockImageResourceObserver> observer2 = | 1397 std::unique_ptr<MockImageResourceObserver> observer2 = |
1357 MockImageResourceObserver::Create(image_resource2->GetContent()); | 1398 MockImageResourceObserver::Create(image_resource2->GetContent()); |
1358 | 1399 |
1359 ImageResource* image_resource3 = | 1400 ImageResource* image_resource3 = |
1360 ImageResource::Fetch(non_placeholder_params, fetcher); | 1401 ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner), |
| 1402 non_placeholder_params, fetcher); |
1361 std::unique_ptr<MockImageResourceObserver> observer3 = | 1403 std::unique_ptr<MockImageResourceObserver> observer3 = |
1362 MockImageResourceObserver::Create(image_resource3->GetContent()); | 1404 MockImageResourceObserver::Create(image_resource3->GetContent()); |
1363 | 1405 |
1364 EXPECT_FALSE(observer2->ImageNotifyFinishedCalled()); | 1406 EXPECT_FALSE(observer2->ImageNotifyFinishedCalled()); |
1365 EXPECT_FALSE(observer3->ImageNotifyFinishedCalled()); | 1407 EXPECT_FALSE(observer3->ImageNotifyFinishedCalled()); |
1366 | 1408 |
1367 // |imageResource| remains a placeholder, while following non-placeholder | 1409 // |imageResource| remains a placeholder, while following non-placeholder |
1368 // requests start non-placeholder loading with a separate ImageResource. | 1410 // requests start non-placeholder loading with a separate ImageResource. |
1369 ASSERT_NE(image_resource, image_resource2); | 1411 ASSERT_NE(image_resource, image_resource2); |
1370 ASSERT_EQ(image_resource2, image_resource3); | 1412 ASSERT_EQ(image_resource2, image_resource3); |
1371 | 1413 |
1372 TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource2, | 1414 TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource2, |
1373 observer2.get()); | 1415 observer2.get()); |
1374 EXPECT_TRUE(observer3->ImageNotifyFinishedCalled()); | 1416 EXPECT_TRUE(observer3->ImageNotifyFinishedCalled()); |
1375 } | 1417 } |
1376 | 1418 |
1377 TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) { | 1419 TEST_F(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) { |
1378 const struct { | 1420 const struct { |
1379 int status_code; | 1421 int status_code; |
1380 AtomicString content_range; | 1422 AtomicString content_range; |
1381 } tests[] = { | 1423 } tests[] = { |
1382 {200, g_null_atom}, | 1424 {200, g_null_atom}, |
1383 {404, g_null_atom}, | 1425 {404, g_null_atom}, |
1384 {206, BuildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))}, | 1426 {206, BuildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))}, |
1385 }; | 1427 }; |
1386 for (const auto& test : tests) { | 1428 for (const auto& test : tests) { |
1387 KURL test_url(kParsedURLString, kTestURL); | 1429 KURL test_url(kParsedURLString, kTestURL); |
1388 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1430 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1389 | 1431 |
1390 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1432 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1391 params.SetAllowImagePlaceholder(); | 1433 params.SetAllowImagePlaceholder(); |
1392 ImageResource* image_resource = | 1434 ImageResource* image_resource = ImageResource::Fetch( |
1393 ImageResource::Fetch(params, CreateFetcher()); | 1435 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1394 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 1436 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
1395 params.GetPlaceholderImageRequestType()); | 1437 params.GetPlaceholderImageRequestType()); |
1396 EXPECT_EQ("bytes=0-2047", | 1438 EXPECT_EQ("bytes=0-2047", |
1397 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1439 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1398 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); | 1440 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); |
1399 std::unique_ptr<MockImageResourceObserver> observer = | 1441 std::unique_ptr<MockImageResourceObserver> observer = |
1400 MockImageResourceObserver::Create(image_resource->GetContent()); | 1442 MockImageResourceObserver::Create(image_resource->GetContent()); |
1401 | 1443 |
1402 ResourceResponse response(test_url, "image/jpeg", sizeof(kJpegImage), | 1444 ResourceResponse response(test_url, "image/jpeg", sizeof(kJpegImage), |
1403 g_null_atom); | 1445 g_null_atom); |
(...skipping 17 matching lines...) Expand all Loading... |
1421 | 1463 |
1422 ASSERT_TRUE(image_resource->GetContent()->HasImage()); | 1464 ASSERT_TRUE(image_resource->GetContent()->HasImage()); |
1423 EXPECT_EQ(kJpegImageWidth, | 1465 EXPECT_EQ(kJpegImageWidth, |
1424 image_resource->GetContent()->GetImage()->width()); | 1466 image_resource->GetContent()->GetImage()->width()); |
1425 EXPECT_EQ(kJpegImageHeight, | 1467 EXPECT_EQ(kJpegImageHeight, |
1426 image_resource->GetContent()->GetImage()->height()); | 1468 image_resource->GetContent()->GetImage()->height()); |
1427 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 1469 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
1428 } | 1470 } |
1429 } | 1471 } |
1430 | 1472 |
1431 TEST(ImageResourceTest, | 1473 TEST_F(ImageResourceTest, |
1432 FetchAllowPlaceholderFullResponseDecodeFailureNoReload) { | 1474 FetchAllowPlaceholderFullResponseDecodeFailureNoReload) { |
1433 static const char kBadImageData[] = "bad image data"; | 1475 static const char kBadImageData[] = "bad image data"; |
1434 | 1476 |
1435 const struct { | 1477 const struct { |
1436 int status_code; | 1478 int status_code; |
1437 AtomicString content_range; | 1479 AtomicString content_range; |
1438 size_t data_size; | 1480 size_t data_size; |
1439 } tests[] = { | 1481 } tests[] = { |
1440 {200, g_null_atom, sizeof(kBadImageData)}, | 1482 {200, g_null_atom, sizeof(kBadImageData)}, |
1441 {206, BuildContentRange(sizeof(kBadImageData), sizeof(kBadImageData)), | 1483 {206, BuildContentRange(sizeof(kBadImageData), sizeof(kBadImageData)), |
1442 sizeof(kBadImageData)}, | 1484 sizeof(kBadImageData)}, |
1443 {204, g_null_atom, 0}, | 1485 {204, g_null_atom, 0}, |
1444 }; | 1486 }; |
1445 for (const auto& test : tests) { | 1487 for (const auto& test : tests) { |
1446 KURL test_url(kParsedURLString, kTestURL); | 1488 KURL test_url(kParsedURLString, kTestURL); |
1447 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1489 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1448 | 1490 |
1449 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1491 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1450 params.SetAllowImagePlaceholder(); | 1492 params.SetAllowImagePlaceholder(); |
1451 ImageResource* image_resource = | 1493 ImageResource* image_resource = ImageResource::Fetch( |
1452 ImageResource::Fetch(params, CreateFetcher()); | 1494 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1453 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 1495 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
1454 params.GetPlaceholderImageRequestType()); | 1496 params.GetPlaceholderImageRequestType()); |
1455 EXPECT_EQ("bytes=0-2047", | 1497 EXPECT_EQ("bytes=0-2047", |
1456 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1498 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1457 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); | 1499 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); |
1458 std::unique_ptr<MockImageResourceObserver> observer = | 1500 std::unique_ptr<MockImageResourceObserver> observer = |
1459 MockImageResourceObserver::Create(image_resource->GetContent()); | 1501 MockImageResourceObserver::Create(image_resource->GetContent()); |
1460 | 1502 |
1461 ResourceResponse response(test_url, "image/jpeg", test.data_size, | 1503 ResourceResponse response(test_url, "image/jpeg", test.data_size, |
1462 g_null_atom); | 1504 g_null_atom); |
1463 response.SetHTTPStatusCode(test.status_code); | 1505 response.SetHTTPStatusCode(test.status_code); |
1464 if (test.content_range != g_null_atom) | 1506 if (test.content_range != g_null_atom) |
1465 response.SetHTTPHeaderField("content-range", test.content_range); | 1507 response.SetHTTPHeaderField("content-range", test.content_range); |
1466 image_resource->Loader()->DidReceiveResponse( | 1508 image_resource->Loader()->DidReceiveResponse( |
1467 WrappedResourceResponse(response)); | 1509 WrappedResourceResponse(response)); |
1468 image_resource->Loader()->DidReceiveData(kBadImageData, test.data_size); | 1510 image_resource->Loader()->DidReceiveData(kBadImageData, test.data_size); |
1469 | 1511 |
1470 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); | 1512 EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus()); |
1471 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); | 1513 EXPECT_FALSE(image_resource->ShouldShowPlaceholder()); |
1472 } | 1514 } |
1473 } | 1515 } |
1474 | 1516 |
1475 TEST(ImageResourceTest, | 1517 TEST_F(ImageResourceTest, |
1476 FetchAllowPlaceholderFullResponseDecodeFailureWithReload) { | 1518 FetchAllowPlaceholderFullResponseDecodeFailureWithReload) { |
1477 const int kStatusCodes[] = {404, 500}; | 1519 const int kStatusCodes[] = {404, 500}; |
1478 for (int status_code : kStatusCodes) { | 1520 for (int status_code : kStatusCodes) { |
1479 KURL test_url(kParsedURLString, kTestURL); | 1521 KURL test_url(kParsedURLString, kTestURL); |
1480 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1522 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1481 | 1523 |
1482 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; | 1524 FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()}; |
1483 params.SetAllowImagePlaceholder(); | 1525 params.SetAllowImagePlaceholder(); |
1484 ImageResource* image_resource = | 1526 ImageResource* image_resource = ImageResource::Fetch( |
1485 ImageResource::Fetch(params, CreateFetcher()); | 1527 AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher()); |
1486 EXPECT_EQ(FetchParameters::kAllowPlaceholder, | 1528 EXPECT_EQ(FetchParameters::kAllowPlaceholder, |
1487 params.GetPlaceholderImageRequestType()); | 1529 params.GetPlaceholderImageRequestType()); |
1488 EXPECT_EQ("bytes=0-2047", | 1530 EXPECT_EQ("bytes=0-2047", |
1489 image_resource->GetResourceRequest().HttpHeaderField("range")); | 1531 image_resource->GetResourceRequest().HttpHeaderField("range")); |
1490 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); | 1532 EXPECT_TRUE(image_resource->ShouldShowPlaceholder()); |
1491 std::unique_ptr<MockImageResourceObserver> observer = | 1533 std::unique_ptr<MockImageResourceObserver> observer = |
1492 MockImageResourceObserver::Create(image_resource->GetContent()); | 1534 MockImageResourceObserver::Create(image_resource->GetContent()); |
1493 | 1535 |
1494 static const char kBadImageData[] = "bad image data"; | 1536 static const char kBadImageData[] = "bad image data"; |
1495 | 1537 |
1496 ResourceResponse response(test_url, "image/jpeg", sizeof(kBadImageData), | 1538 ResourceResponse response(test_url, "image/jpeg", sizeof(kBadImageData), |
1497 g_null_atom); | 1539 g_null_atom); |
1498 response.SetHTTPStatusCode(status_code); | 1540 response.SetHTTPStatusCode(status_code); |
1499 image_resource->Loader()->DidReceiveResponse( | 1541 image_resource->Loader()->DidReceiveResponse( |
1500 WrappedResourceResponse(response)); | 1542 WrappedResourceResponse(response)); |
1501 image_resource->Loader()->DidReceiveData(kBadImageData, | 1543 image_resource->Loader()->DidReceiveData(kBadImageData, |
1502 sizeof(kBadImageData)); | 1544 sizeof(kBadImageData)); |
1503 | 1545 |
1504 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); | 1546 EXPECT_FALSE(observer->ImageNotifyFinishedCalled()); |
1505 | 1547 |
1506 // The dimensions could not be extracted, and the response code was a 4xx | 1548 // The dimensions could not be extracted, and the response code was a 4xx |
1507 // error, so the full original image should be loading. | 1549 // error, so the full original image should be loading. |
1508 TestThatReloadIsStartedThenServeReload( | 1550 TestThatReloadIsStartedThenServeReload( |
1509 test_url, image_resource, image_resource->GetContent(), observer.get(), | 1551 test_url, image_resource, image_resource->GetContent(), observer.get(), |
1510 WebCachePolicy::kBypassingCache); | 1552 WebCachePolicy::kBypassingCache); |
1511 } | 1553 } |
1512 } | 1554 } |
1513 | 1555 |
1514 TEST(ImageResourceTest, PeriodicFlushTest) { | 1556 TEST_F(ImageResourceTest, PeriodicFlushTest) { |
1515 ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler> | 1557 ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler> |
1516 platform; | 1558 platform; |
1517 KURL test_url(kParsedURLString, kTestURL); | 1559 KURL test_url(kParsedURLString, kTestURL); |
1518 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); | 1560 ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath()); |
1519 ResourceRequest request = ResourceRequest(test_url); | 1561 ResourceRequest request = ResourceRequest(test_url); |
1520 ImageResource* image_resource = ImageResource::Create(request); | 1562 ImageResource* image_resource = ImageResource::Create( |
| 1563 AdoptRef(new scheduler::FakeWebTaskRunner), request); |
1521 image_resource->SetStatus(ResourceStatus::kPending); | 1564 image_resource->SetStatus(ResourceStatus::kPending); |
1522 | 1565 |
1523 std::unique_ptr<MockImageResourceObserver> observer = | 1566 std::unique_ptr<MockImageResourceObserver> observer = |
1524 MockImageResourceObserver::Create(image_resource->GetContent()); | 1567 MockImageResourceObserver::Create(image_resource->GetContent()); |
1525 | 1568 |
1526 // Send the image response. | 1569 // Send the image response. |
1527 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage2), | 1570 ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage2), |
1528 g_null_atom); | 1571 g_null_atom); |
1529 resource_response.AddHTTPHeaderField("chrome-proxy", "q=low"); | 1572 resource_response.AddHTTPHeaderField("chrome-proxy", "q=low"); |
1530 | 1573 |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1592 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); | 1635 EXPECT_TRUE(observer->ImageNotifyFinishedCalled()); |
1593 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); | 1636 EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage()); |
1594 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width()); | 1637 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width()); |
1595 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height()); | 1638 EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height()); |
1596 | 1639 |
1597 WTF::SetTimeFunctionsForTesting(nullptr); | 1640 WTF::SetTimeFunctionsForTesting(nullptr); |
1598 } | 1641 } |
1599 | 1642 |
1600 } // namespace | 1643 } // namespace |
1601 } // namespace blink | 1644 } // namespace blink |
OLD | NEW |