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 157 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
168 size_t dataSize) { | 168 size_t dataSize) { |
169 ResourceResponse response; | 169 ResourceResponse response; |
170 response.setURL(url); | 170 response.setURL(url); |
171 response.setHTTPStatusCode(200); | 171 response.setHTTPStatusCode(200); |
172 response.setMimeType(mimeType); | 172 response.setMimeType(mimeType); |
173 imageResource->responseReceived(response, nullptr); | 173 imageResource->responseReceived(response, nullptr); |
174 imageResource->appendData(data, dataSize); | 174 imageResource->appendData(data, dataSize); |
175 imageResource->finish(); | 175 imageResource->finish(); |
176 } | 176 } |
177 | 177 |
178 void testThatReloadIsStartedThenServeReload(const KURL& testURL, | 178 void testThatReloadIsStartedThenServeReload( |
179 ImageResource* imageResource, | 179 const KURL& testURL, |
180 ImageResourceContent* content, | 180 ImageResource* originalImageResource, |
181 MockImageResourceObserver* observer, | 181 ImageResource* imageResource, |
182 WebCachePolicy policyForReload) { | 182 ImageResourceContent* content, |
| 183 MockImageResourceObserver* observer, |
| 184 WebCachePolicy policyForReload) { |
183 const char* data = reinterpret_cast<const char*>(kJpegImage2); | 185 const char* data = reinterpret_cast<const char*>(kJpegImage2); |
184 constexpr size_t dataLength = sizeof(kJpegImage2); | 186 constexpr size_t dataLength = sizeof(kJpegImage2); |
185 constexpr int imageWidth = 50; | 187 constexpr int imageWidth = 50; |
186 constexpr int imageHeight = 50; | 188 constexpr int imageHeight = 50; |
187 | 189 |
| 190 // Checks that |originalImageResource| is detached. |
| 191 EXPECT_NE(originalImageResource, imageResource); |
| 192 EXPECT_FALSE(originalImageResource->getContent()); |
| 193 |
188 // Checks that |imageResource| and |content| are ready for non-placeholder | 194 // Checks that |imageResource| and |content| are ready for non-placeholder |
189 // reloading. | 195 // reloading. |
190 EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus()); | 196 EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus()); |
191 EXPECT_FALSE(imageResource->resourceBuffer()); | 197 EXPECT_FALSE(imageResource->resourceBuffer()); |
192 EXPECT_FALSE(imageResource->shouldShowPlaceholder()); | 198 EXPECT_FALSE(imageResource->shouldShowPlaceholder()); |
193 EXPECT_EQ(nullAtom, | 199 EXPECT_EQ(nullAtom, |
194 imageResource->resourceRequest().httpHeaderField("range")); | 200 imageResource->resourceRequest().httpHeaderField("range")); |
195 EXPECT_EQ(policyForReload, imageResource->resourceRequest().getCachePolicy()); | 201 EXPECT_EQ(policyForReload, imageResource->resourceRequest().getCachePolicy()); |
196 EXPECT_EQ(content, imageResource->getContent()); | 202 EXPECT_EQ(content, imageResource->getContent()); |
197 EXPECT_FALSE(content->hasImage()); | 203 EXPECT_FALSE(content->hasImage()); |
| 204 EXPECT_EQ(imageResource, memoryCache()->resourceForURL(testURL)); |
198 | 205 |
199 // Checks |observer| before reloading. | 206 // Checks |observer| before reloading. |
200 const int originalImageChangedCount = observer->imageChangedCount(); | 207 const int originalImageChangedCount = observer->imageChangedCount(); |
201 const bool alreadyNotifiedFinish = observer->imageNotifyFinishedCalled(); | 208 const bool alreadyNotifiedFinish = observer->imageNotifyFinishedCalled(); |
202 const int imageWidthOnImageNotifyFinished = | 209 const int imageWidthOnImageNotifyFinished = |
203 observer->imageWidthOnImageNotifyFinished(); | 210 observer->imageWidthOnImageNotifyFinished(); |
204 ASSERT_NE(imageWidth, imageWidthOnImageNotifyFinished); | 211 ASSERT_NE(imageWidth, imageWidthOnImageNotifyFinished); |
205 | 212 |
206 // Does Reload. | 213 // Does Reload. |
207 imageResource->loader()->didReceiveResponse(WrappedResourceResponse( | 214 imageResource->loader()->didReceiveResponse(WrappedResourceResponse( |
(...skipping 294 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
502 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); | 509 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); |
503 EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage()); | 510 EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage()); |
504 } | 511 } |
505 | 512 |
506 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) { | 513 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) { |
507 KURL testURL(ParsedURLString, kTestURL); | 514 KURL testURL(ParsedURLString, kTestURL); |
508 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 515 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
509 ResourceRequest request = ResourceRequest(testURL); | 516 ResourceRequest request = ResourceRequest(testURL); |
510 request.setPreviewsState(WebURLRequest::ServerLoFiOn); | 517 request.setPreviewsState(WebURLRequest::ServerLoFiOn); |
511 ImageResource* imageResource = ImageResource::create(request); | 518 ImageResource* imageResource = ImageResource::create(request); |
| 519 ImageResourceContent* content = imageResource->getContent(); |
512 imageResource->setStatus(ResourceStatus::Pending); | 520 imageResource->setStatus(ResourceStatus::Pending); |
513 | 521 |
514 std::unique_ptr<MockImageResourceObserver> observer = | 522 std::unique_ptr<MockImageResourceObserver> observer = |
515 MockImageResourceObserver::create(imageResource->getContent()); | 523 MockImageResourceObserver::create(imageResource->getContent()); |
516 ResourceFetcher* fetcher = createFetcher(); | 524 ResourceFetcher* fetcher = createFetcher(); |
517 | 525 |
518 // Send the image response. | 526 // Send the image response. |
519 ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), | 527 ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), |
520 nullAtom); | 528 nullAtom); |
521 resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform", | 529 resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform", |
522 "empty-image"); | 530 "empty-image"); |
523 | 531 |
524 imageResource->responseReceived(resourceResponse, nullptr); | 532 imageResource->responseReceived(resourceResponse, nullptr); |
525 imageResource->appendData(reinterpret_cast<const char*>(kJpegImage), | 533 imageResource->appendData(reinterpret_cast<const char*>(kJpegImage), |
526 sizeof(kJpegImage)); | 534 sizeof(kJpegImage)); |
527 imageResource->finish(); | 535 imageResource->finish(); |
528 EXPECT_FALSE(imageResource->errorOccurred()); | 536 EXPECT_FALSE(imageResource->errorOccurred()); |
529 ASSERT_TRUE(imageResource->getContent()->hasImage()); | 537 ASSERT_TRUE(content->hasImage()); |
530 EXPECT_FALSE(imageResource->getContent()->getImage()->isNull()); | 538 EXPECT_FALSE(content->getImage()->isNull()); |
531 EXPECT_EQ(2, observer->imageChangedCount()); | 539 EXPECT_EQ(2, observer->imageChangedCount()); |
532 EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged()); | 540 EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged()); |
533 // The observer should have been notified that the image load completed. | 541 // The observer should have been notified that the image load completed. |
534 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); | 542 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); |
535 EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished()); | 543 EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished()); |
536 EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage()); | 544 EXPECT_TRUE(content->getImage()->isBitmapImage()); |
537 EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width()); | 545 EXPECT_EQ(kJpegImageWidth, content->getImage()->width()); |
538 EXPECT_EQ(kJpegImageHeight, | 546 EXPECT_EQ(kJpegImageHeight, content->getImage()->height()); |
539 imageResource->getContent()->getImage()->height()); | |
540 | 547 |
541 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. | 548 // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading. |
542 imageResource->reloadIfLoFiOrPlaceholderImage(fetcher, | 549 ImageResource* reloadingResource = |
543 Resource::kReloadAlways); | 550 imageResource->reloadIfLoFiOrPlaceholderImage(fetcher, |
| 551 Resource::kReloadAlways); |
| 552 EXPECT_EQ(3, observer->imageChangedCount()); |
| 553 ASSERT_TRUE(reloadingResource); |
| 554 EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL)); |
544 | 555 |
545 EXPECT_EQ(3, observer->imageChangedCount()); | |
546 testThatReloadIsStartedThenServeReload( | 556 testThatReloadIsStartedThenServeReload( |
547 testURL, imageResource, imageResource->getContent(), observer.get(), | 557 testURL, imageResource, reloadingResource, content, observer.get(), |
548 WebCachePolicy::BypassingCache); | 558 WebCachePolicy::BypassingCache); |
549 } | 559 } |
550 | 560 |
551 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) { | 561 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) { |
552 ResourceFetcher* fetcher = createFetcher(); | 562 ResourceFetcher* fetcher = createFetcher(); |
553 | 563 |
554 KURL testURL(ParsedURLString, kTestURL); | 564 KURL testURL(ParsedURLString, kTestURL); |
555 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 565 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
556 | 566 |
557 ResourceRequest request = ResourceRequest(testURL); | 567 ResourceRequest request = ResourceRequest(testURL); |
(...skipping 18 matching lines...) Expand all Loading... |
576 imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage), | 586 imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage), |
577 sizeof(kJpegImage)); | 587 sizeof(kJpegImage)); |
578 | 588 |
579 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); | 589 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); |
580 EXPECT_EQ(imageResource, fetcher->cachedResource(testURL)); | 590 EXPECT_EQ(imageResource, fetcher->cachedResource(testURL)); |
581 | 591 |
582 fetcher->reloadLoFiImages(); | 592 fetcher->reloadLoFiImages(); |
583 | 593 |
584 EXPECT_EQ(3, observer->imageChangedCount()); | 594 EXPECT_EQ(3, observer->imageChangedCount()); |
585 | 595 |
586 testThatReloadIsStartedThenServeReload(testURL, imageResource, content, | 596 ImageResource* reloadingResource = |
587 observer.get(), | 597 toImageResource(fetcher->cachedResource(testURL)); |
588 WebCachePolicy::BypassingCache); | 598 ASSERT_TRUE(reloadingResource); |
| 599 |
| 600 testThatReloadIsStartedThenServeReload( |
| 601 testURL, imageResource, reloadingResource, content, observer.get(), |
| 602 WebCachePolicy::BypassingCache); |
589 | 603 |
590 memoryCache()->remove(imageResource); | 604 memoryCache()->remove(imageResource); |
591 } | 605 } |
592 | 606 |
593 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) { | 607 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) { |
594 KURL testURL(ParsedURLString, kTestURL); | 608 KURL testURL(ParsedURLString, kTestURL); |
595 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 609 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
596 | 610 |
597 ResourceRequest request(testURL); | 611 ResourceRequest request(testURL); |
598 request.setPreviewsState(WebURLRequest::ServerLoFiOn); | 612 request.setPreviewsState(WebURLRequest::ServerLoFiOn); |
599 FetchRequest fetchRequest(request, FetchInitiatorInfo()); | 613 FetchRequest fetchRequest(request, FetchInitiatorInfo()); |
600 ResourceFetcher* fetcher = createFetcher(); | 614 ResourceFetcher* fetcher = createFetcher(); |
601 | 615 |
602 ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher); | 616 ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher); |
| 617 ImageResourceContent* content = imageResource->getContent(); |
603 std::unique_ptr<MockImageResourceObserver> observer = | 618 std::unique_ptr<MockImageResourceObserver> observer = |
604 MockImageResourceObserver::create(imageResource->getContent()); | 619 MockImageResourceObserver::create(content); |
605 | 620 |
606 // Send the image response. | 621 // Send the image response. |
607 ResourceResponse initialResourceResponse(testURL, "image/jpeg", | 622 ResourceResponse initialResourceResponse(testURL, "image/jpeg", |
608 sizeof(kJpegImage), nullAtom); | 623 sizeof(kJpegImage), nullAtom); |
609 initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low"); | 624 initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low"); |
610 | 625 |
611 imageResource->loader()->didReceiveResponse( | 626 imageResource->loader()->didReceiveResponse( |
612 WrappedResourceResponse(initialResourceResponse)); | 627 WrappedResourceResponse(initialResourceResponse)); |
613 imageResource->loader()->didReceiveData( | 628 imageResource->loader()->didReceiveData( |
614 reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage)); | 629 reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage)); |
615 | 630 |
616 EXPECT_FALSE(imageResource->errorOccurred()); | 631 EXPECT_FALSE(imageResource->errorOccurred()); |
617 ASSERT_TRUE(imageResource->getContent()->hasImage()); | 632 ASSERT_TRUE(content->hasImage()); |
618 EXPECT_FALSE(imageResource->getContent()->getImage()->isNull()); | 633 EXPECT_FALSE(content->getImage()->isNull()); |
619 EXPECT_EQ(1, observer->imageChangedCount()); | 634 EXPECT_EQ(1, observer->imageChangedCount()); |
620 EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged()); | 635 EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged()); |
621 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); | 636 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); |
622 EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage()); | 637 EXPECT_TRUE(content->getImage()->isBitmapImage()); |
623 EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width()); | 638 EXPECT_EQ(kJpegImageWidth, content->getImage()->width()); |
624 EXPECT_EQ(kJpegImageHeight, | 639 EXPECT_EQ(kJpegImageHeight, content->getImage()->height()); |
625 imageResource->getContent()->getImage()->height()); | |
626 | 640 |
627 // Call reloadIfLoFiOrPlaceholderImage() while the image is still loading. | 641 // Call reloadIfLoFiOrPlaceholderImage() while the image is still loading. |
628 imageResource->reloadIfLoFiOrPlaceholderImage(fetcher, | 642 ImageResource* reloadingResource = |
629 Resource::kReloadAlways); | 643 imageResource->reloadIfLoFiOrPlaceholderImage(fetcher, |
| 644 Resource::kReloadAlways); |
630 | 645 |
| 646 ASSERT_TRUE(reloadingResource); |
| 647 EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL)); |
631 EXPECT_EQ(2, observer->imageChangedCount()); | 648 EXPECT_EQ(2, observer->imageChangedCount()); |
632 EXPECT_EQ(0, observer->imageWidthOnLastImageChanged()); | 649 EXPECT_EQ(0, observer->imageWidthOnLastImageChanged()); |
633 // The observer should not have been notified of completion yet, since the | 650 // The observer should not have been notified of completion yet, since the |
634 // image is still loading. | 651 // image is still loading. |
635 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); | 652 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); |
636 | 653 |
637 testThatReloadIsStartedThenServeReload( | 654 testThatReloadIsStartedThenServeReload( |
638 testURL, imageResource, imageResource->getContent(), observer.get(), | 655 testURL, imageResource, reloadingResource, content, observer.get(), |
639 WebCachePolicy::BypassingCache); | 656 WebCachePolicy::BypassingCache); |
| 657 |
| 658 // Trigger the cancel timer, ensure the load for the first ImageResource |
| 659 // was cancelled because reloading is started using another ImageResource. |
| 660 EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus()); |
| 661 blink::testing::runPendingTasks(); |
| 662 EXPECT_EQ(ResourceStatus::LoadError, imageResource->getStatus()); |
640 } | 663 } |
641 | 664 |
642 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) { | 665 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) { |
643 KURL testURL(ParsedURLString, kTestURL); | 666 KURL testURL(ParsedURLString, kTestURL); |
644 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 667 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
645 | 668 |
646 ResourceFetcher* fetcher = createFetcher(); | 669 ResourceFetcher* fetcher = createFetcher(); |
647 FetchRequest request(testURL, FetchInitiatorInfo()); | 670 FetchRequest request(testURL, FetchInitiatorInfo()); |
648 request.setAllowImagePlaceholder(); | 671 request.setAllowImagePlaceholder(); |
649 ImageResource* imageResource = ImageResource::fetch(request, fetcher); | 672 ImageResource* imageResource = ImageResource::fetch(request, fetcher); |
| 673 ImageResourceContent* content = imageResource->getContent(); |
| 674 ASSERT_TRUE(content); |
650 EXPECT_EQ(FetchRequest::AllowPlaceholder, | 675 EXPECT_EQ(FetchRequest::AllowPlaceholder, |
651 request.placeholderImageRequestType()); | 676 request.placeholderImageRequestType()); |
652 std::unique_ptr<MockImageResourceObserver> observer = | 677 std::unique_ptr<MockImageResourceObserver> observer = |
653 MockImageResourceObserver::create(imageResource->getContent()); | 678 MockImageResourceObserver::create(content); |
654 | 679 |
655 testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource, | 680 testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource, |
656 observer.get()); | 681 observer.get()); |
657 | 682 |
658 imageResource->reloadIfLoFiOrPlaceholderImage(fetcher, | 683 ImageResource* reloadingResource = |
659 Resource::kReloadAlways); | 684 imageResource->reloadIfLoFiOrPlaceholderImage(fetcher, |
| 685 Resource::kReloadAlways); |
| 686 ASSERT_TRUE(reloadingResource); |
| 687 EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL)); |
660 | 688 |
661 testThatReloadIsStartedThenServeReload( | 689 testThatReloadIsStartedThenServeReload( |
662 testURL, imageResource, imageResource->getContent(), observer.get(), | 690 testURL, imageResource, reloadingResource, content, observer.get(), |
663 WebCachePolicy::BypassingCache); | 691 WebCachePolicy::BypassingCache); |
664 } | 692 } |
665 | 693 |
666 TEST(ImageResourceTest, SVGImage) { | 694 TEST(ImageResourceTest, SVGImage) { |
667 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo"); | 695 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo"); |
668 ImageResource* imageResource = ImageResource::create(ResourceRequest(url)); | 696 ImageResource* imageResource = ImageResource::create(ResourceRequest(url)); |
669 std::unique_ptr<MockImageResourceObserver> observer = | 697 std::unique_ptr<MockImageResourceObserver> observer = |
670 MockImageResourceObserver::create(imageResource->getContent()); | 698 MockImageResourceObserver::create(imageResource->getContent()); |
671 | 699 |
672 receiveResponse(imageResource, url, "image/svg+xml", kSvgImage, | 700 receiveResponse(imageResource, url, "image/svg+xml", kSvgImage, |
(...skipping 436 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1109 testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource, | 1137 testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource, |
1110 observer.get()); | 1138 observer.get()); |
1111 } | 1139 } |
1112 | 1140 |
1113 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) { | 1141 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) { |
1114 KURL testURL(ParsedURLString, kTestURL); | 1142 KURL testURL(ParsedURLString, kTestURL); |
1115 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 1143 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
1116 | 1144 |
1117 FetchRequest request(testURL, FetchInitiatorInfo()); | 1145 FetchRequest request(testURL, FetchInitiatorInfo()); |
1118 request.setAllowImagePlaceholder(); | 1146 request.setAllowImagePlaceholder(); |
1119 ImageResource* imageResource = ImageResource::fetch(request, createFetcher()); | 1147 ResourceFetcher* fetcher = createFetcher(); |
| 1148 ImageResource* imageResource = ImageResource::fetch(request, fetcher); |
| 1149 ImageResourceContent* content = imageResource->getContent(); |
1120 EXPECT_EQ(FetchRequest::AllowPlaceholder, | 1150 EXPECT_EQ(FetchRequest::AllowPlaceholder, |
1121 request.placeholderImageRequestType()); | 1151 request.placeholderImageRequestType()); |
1122 EXPECT_EQ("bytes=0-2047", | 1152 EXPECT_EQ("bytes=0-2047", |
1123 imageResource->resourceRequest().httpHeaderField("range")); | 1153 imageResource->resourceRequest().httpHeaderField("range")); |
1124 EXPECT_TRUE(imageResource->shouldShowPlaceholder()); | 1154 EXPECT_TRUE(imageResource->shouldShowPlaceholder()); |
1125 std::unique_ptr<MockImageResourceObserver> observer = | 1155 std::unique_ptr<MockImageResourceObserver> observer = |
1126 MockImageResourceObserver::create(imageResource->getContent()); | 1156 MockImageResourceObserver::create(imageResource->getContent()); |
1127 | 1157 |
1128 const char kBadData[] = "notanimageresponse"; | 1158 const char kBadData[] = "notanimageresponse"; |
1129 | 1159 |
1130 ResourceResponse badResponse(testURL, "image/jpeg", sizeof(kBadData), | 1160 ResourceResponse badResponse(testURL, "image/jpeg", sizeof(kBadData), |
1131 nullAtom); | 1161 nullAtom); |
1132 badResponse.setHTTPStatusCode(206); | 1162 badResponse.setHTTPStatusCode(206); |
1133 badResponse.setHTTPHeaderField( | 1163 badResponse.setHTTPHeaderField( |
1134 "content-range", buildContentRange(sizeof(kBadData), sizeof(kJpegImage))); | 1164 "content-range", buildContentRange(sizeof(kBadData), sizeof(kJpegImage))); |
1135 | 1165 |
1136 imageResource->loader()->didReceiveResponse( | 1166 imageResource->loader()->didReceiveResponse( |
1137 WrappedResourceResponse(badResponse)); | 1167 WrappedResourceResponse(badResponse)); |
1138 | 1168 |
1139 EXPECT_EQ(0, observer->imageChangedCount()); | 1169 EXPECT_EQ(0, observer->imageChangedCount()); |
1140 | 1170 |
1141 imageResource->loader()->didReceiveData(kBadData, sizeof(kBadData)); | 1171 imageResource->loader()->didReceiveData(kBadData, sizeof(kBadData)); |
1142 | 1172 |
| 1173 ImageResource* reloadingResource = |
| 1174 toImageResource(fetcher->cachedResource(testURL)); |
| 1175 ASSERT_TRUE(reloadingResource); |
| 1176 |
1143 // The dimensions could not be extracted, so the full original image should be | 1177 // The dimensions could not be extracted, so the full original image should be |
1144 // loading. | 1178 // loading. |
1145 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); | 1179 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); |
1146 EXPECT_EQ(2, observer->imageChangedCount()); | 1180 EXPECT_EQ(1, observer->imageChangedCount()); |
1147 | 1181 |
1148 testThatReloadIsStartedThenServeReload( | 1182 testThatReloadIsStartedThenServeReload( |
1149 testURL, imageResource, imageResource->getContent(), observer.get(), | 1183 testURL, imageResource, reloadingResource, content, observer.get(), |
1150 WebCachePolicy::BypassingCache); | 1184 WebCachePolicy::BypassingCache); |
1151 } | 1185 } |
1152 | 1186 |
1153 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) { | 1187 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) { |
1154 KURL testURL(ParsedURLString, kTestURL); | 1188 KURL testURL(ParsedURLString, kTestURL); |
1155 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 1189 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
1156 | 1190 |
1157 FetchRequest request(testURL, FetchInitiatorInfo()); | 1191 FetchRequest request(testURL, FetchInitiatorInfo()); |
1158 request.setAllowImagePlaceholder(); | 1192 request.setAllowImagePlaceholder(); |
1159 ImageResource* imageResource = ImageResource::fetch(request, createFetcher()); | 1193 ResourceFetcher* fetcher = createFetcher(); |
| 1194 ImageResource* imageResource = ImageResource::fetch(request, fetcher); |
| 1195 ImageResourceContent* content = imageResource->getContent(); |
1160 EXPECT_EQ(FetchRequest::AllowPlaceholder, | 1196 EXPECT_EQ(FetchRequest::AllowPlaceholder, |
1161 request.placeholderImageRequestType()); | 1197 request.placeholderImageRequestType()); |
1162 EXPECT_EQ("bytes=0-2047", | 1198 EXPECT_EQ("bytes=0-2047", |
1163 imageResource->resourceRequest().httpHeaderField("range")); | 1199 imageResource->resourceRequest().httpHeaderField("range")); |
1164 EXPECT_TRUE(imageResource->shouldShowPlaceholder()); | 1200 EXPECT_TRUE(imageResource->shouldShowPlaceholder()); |
1165 std::unique_ptr<MockImageResourceObserver> observer = | 1201 std::unique_ptr<MockImageResourceObserver> observer = |
1166 MockImageResourceObserver::create(imageResource->getContent()); | 1202 MockImageResourceObserver::create(imageResource->getContent()); |
1167 | 1203 |
1168 // TODO(hiroshige): Make the range request header and partial content length | 1204 // TODO(hiroshige): Make the range request header and partial content length |
1169 // consistent. https://crbug.com/689760. | 1205 // consistent. https://crbug.com/689760. |
(...skipping 12 matching lines...) Expand all Loading... |
1182 reinterpret_cast<const char*>(kJpegImage), | 1218 reinterpret_cast<const char*>(kJpegImage), |
1183 kJpegImageSubrangeWithoutDimensionsLength); | 1219 kJpegImageSubrangeWithoutDimensionsLength); |
1184 | 1220 |
1185 EXPECT_EQ(0, observer->imageChangedCount()); | 1221 EXPECT_EQ(0, observer->imageChangedCount()); |
1186 | 1222 |
1187 imageResource->loader()->didFinishLoading( | 1223 imageResource->loader()->didFinishLoading( |
1188 0.0, kJpegImageSubrangeWithoutDimensionsLength, | 1224 0.0, kJpegImageSubrangeWithoutDimensionsLength, |
1189 kJpegImageSubrangeWithoutDimensionsLength); | 1225 kJpegImageSubrangeWithoutDimensionsLength); |
1190 | 1226 |
1191 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); | 1227 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); |
1192 EXPECT_EQ(2, observer->imageChangedCount()); | 1228 EXPECT_EQ(1, observer->imageChangedCount()); |
| 1229 |
| 1230 ImageResource* reloadingResource = |
| 1231 toImageResource(fetcher->cachedResource(testURL)); |
| 1232 ASSERT_TRUE(reloadingResource); |
1193 | 1233 |
1194 testThatReloadIsStartedThenServeReload( | 1234 testThatReloadIsStartedThenServeReload( |
1195 testURL, imageResource, imageResource->getContent(), observer.get(), | 1235 testURL, imageResource, reloadingResource, content, observer.get(), |
1196 WebCachePolicy::BypassingCache); | 1236 WebCachePolicy::BypassingCache); |
1197 } | 1237 } |
1198 | 1238 |
1199 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) { | 1239 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) { |
1200 KURL testURL(ParsedURLString, kTestURL); | 1240 KURL testURL(ParsedURLString, kTestURL); |
1201 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 1241 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
1202 | 1242 |
1203 ResourceFetcher* fetcher = createFetcher(); | 1243 ResourceFetcher* fetcher = createFetcher(); |
1204 | 1244 |
1205 FetchRequest placeholderRequest(testURL, FetchInitiatorInfo()); | 1245 FetchRequest placeholderRequest(testURL, FetchInitiatorInfo()); |
1206 placeholderRequest.setAllowImagePlaceholder(); | 1246 placeholderRequest.setAllowImagePlaceholder(); |
1207 ImageResource* imageResource = | 1247 ImageResource* imageResource = |
1208 ImageResource::fetch(placeholderRequest, fetcher); | 1248 ImageResource::fetch(placeholderRequest, fetcher); |
| 1249 ImageResourceContent* content = imageResource->getContent(); |
1209 std::unique_ptr<MockImageResourceObserver> observer = | 1250 std::unique_ptr<MockImageResourceObserver> observer = |
1210 MockImageResourceObserver::create(imageResource->getContent()); | 1251 MockImageResourceObserver::create(content); |
1211 | 1252 |
1212 FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo()); | 1253 FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo()); |
1213 ImageResource* imageResource2 = | 1254 ImageResource* imageResource2 = |
1214 ImageResource::fetch(nonPlaceholderRequest, fetcher); | 1255 ImageResource::fetch(nonPlaceholderRequest, fetcher); |
1215 std::unique_ptr<MockImageResourceObserver> observer2 = | 1256 std::unique_ptr<MockImageResourceObserver> observer2 = |
1216 MockImageResourceObserver::create(imageResource2->getContent()); | 1257 MockImageResourceObserver::create(imageResource2->getContent()); |
1217 | 1258 |
1218 ImageResource* imageResource3 = | 1259 ImageResource* imageResource3 = |
1219 ImageResource::fetch(nonPlaceholderRequest, fetcher); | 1260 ImageResource::fetch(nonPlaceholderRequest, fetcher); |
1220 std::unique_ptr<MockImageResourceObserver> observer3 = | 1261 std::unique_ptr<MockImageResourceObserver> observer3 = |
(...skipping 28 matching lines...) Expand all Loading... |
1249 TEST(ImageResourceTest, | 1290 TEST(ImageResourceTest, |
1250 FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) { | 1291 FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) { |
1251 KURL testURL(ParsedURLString, kTestURL); | 1292 KURL testURL(ParsedURLString, kTestURL); |
1252 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 1293 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
1253 | 1294 |
1254 ResourceFetcher* fetcher = createFetcher(); | 1295 ResourceFetcher* fetcher = createFetcher(); |
1255 FetchRequest placeholderRequest(testURL, FetchInitiatorInfo()); | 1296 FetchRequest placeholderRequest(testURL, FetchInitiatorInfo()); |
1256 placeholderRequest.setAllowImagePlaceholder(); | 1297 placeholderRequest.setAllowImagePlaceholder(); |
1257 ImageResource* imageResource = | 1298 ImageResource* imageResource = |
1258 ImageResource::fetch(placeholderRequest, fetcher); | 1299 ImageResource::fetch(placeholderRequest, fetcher); |
| 1300 ImageResourceContent* content = imageResource->getContent(); |
1259 std::unique_ptr<MockImageResourceObserver> observer = | 1301 std::unique_ptr<MockImageResourceObserver> observer = |
1260 MockImageResourceObserver::create(imageResource->getContent()); | 1302 MockImageResourceObserver::create(content); |
1261 | 1303 |
1262 testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource, | 1304 testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource, |
1263 observer.get()); | 1305 observer.get()); |
1264 | 1306 |
1265 FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo()); | 1307 FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo()); |
1266 ImageResource* imageResource2 = | 1308 ImageResource* imageResource2 = |
1267 ImageResource::fetch(nonPlaceholderRequest, fetcher); | 1309 ImageResource::fetch(nonPlaceholderRequest, fetcher); |
1268 std::unique_ptr<MockImageResourceObserver> observer2 = | 1310 std::unique_ptr<MockImageResourceObserver> observer2 = |
1269 MockImageResourceObserver::create(imageResource2->getContent()); | 1311 MockImageResourceObserver::create(imageResource2->getContent()); |
1270 | 1312 |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1371 MockImageResourceObserver::create(imageResource->getContent()); | 1413 MockImageResourceObserver::create(imageResource->getContent()); |
1372 | 1414 |
1373 ResourceResponse response(testURL, "image/jpeg", test.dataSize, nullAtom); | 1415 ResourceResponse response(testURL, "image/jpeg", test.dataSize, nullAtom); |
1374 response.setHTTPStatusCode(test.statusCode); | 1416 response.setHTTPStatusCode(test.statusCode); |
1375 if (test.contentRange != nullAtom) | 1417 if (test.contentRange != nullAtom) |
1376 response.setHTTPHeaderField("content-range", test.contentRange); | 1418 response.setHTTPHeaderField("content-range", test.contentRange); |
1377 imageResource->loader()->didReceiveResponse( | 1419 imageResource->loader()->didReceiveResponse( |
1378 WrappedResourceResponse(response)); | 1420 WrappedResourceResponse(response)); |
1379 imageResource->loader()->didReceiveData(kBadImageData, test.dataSize); | 1421 imageResource->loader()->didReceiveData(kBadImageData, test.dataSize); |
1380 | 1422 |
| 1423 // Reloading does not occur and loading finishes as DecodeError. |
1381 EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus()); | 1424 EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus()); |
| 1425 EXPECT_FALSE(imageResource->isLoading()); |
| 1426 EXPECT_TRUE(imageResource->getContent()); |
1382 EXPECT_FALSE(imageResource->shouldShowPlaceholder()); | 1427 EXPECT_FALSE(imageResource->shouldShowPlaceholder()); |
1383 } | 1428 } |
1384 } | 1429 } |
1385 | 1430 |
1386 TEST(ImageResourceTest, | 1431 TEST(ImageResourceTest, |
1387 FetchAllowPlaceholderFullResponseDecodeFailureWithReload) { | 1432 FetchAllowPlaceholderFullResponseDecodeFailureWithReload) { |
1388 const int kStatusCodes[] = {404, 500}; | 1433 const int kStatusCodes[] = {404, 500}; |
1389 for (int statusCode : kStatusCodes) { | 1434 for (int statusCode : kStatusCodes) { |
1390 KURL testURL(ParsedURLString, kTestURL); | 1435 KURL testURL(ParsedURLString, kTestURL); |
1391 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 1436 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
1392 | 1437 |
1393 FetchRequest request(testURL, FetchInitiatorInfo()); | 1438 FetchRequest request(testURL, FetchInitiatorInfo()); |
1394 request.setAllowImagePlaceholder(); | 1439 request.setAllowImagePlaceholder(); |
1395 ImageResource* imageResource = | 1440 ResourceFetcher* fetcher = createFetcher(); |
1396 ImageResource::fetch(request, createFetcher()); | 1441 ImageResource* imageResource = ImageResource::fetch(request, fetcher); |
| 1442 ImageResourceContent* content = imageResource->getContent(); |
1397 EXPECT_EQ(FetchRequest::AllowPlaceholder, | 1443 EXPECT_EQ(FetchRequest::AllowPlaceholder, |
1398 request.placeholderImageRequestType()); | 1444 request.placeholderImageRequestType()); |
1399 EXPECT_EQ("bytes=0-2047", | 1445 EXPECT_EQ("bytes=0-2047", |
1400 imageResource->resourceRequest().httpHeaderField("range")); | 1446 imageResource->resourceRequest().httpHeaderField("range")); |
1401 EXPECT_TRUE(imageResource->shouldShowPlaceholder()); | 1447 EXPECT_TRUE(imageResource->shouldShowPlaceholder()); |
1402 std::unique_ptr<MockImageResourceObserver> observer = | 1448 std::unique_ptr<MockImageResourceObserver> observer = |
1403 MockImageResourceObserver::create(imageResource->getContent()); | 1449 MockImageResourceObserver::create(content); |
1404 | 1450 |
1405 static const char kBadImageData[] = "bad image data"; | 1451 static const char kBadImageData[] = "bad image data"; |
1406 | 1452 |
1407 ResourceResponse response(testURL, "image/jpeg", sizeof(kBadImageData), | 1453 ResourceResponse response(testURL, "image/jpeg", sizeof(kBadImageData), |
1408 nullAtom); | 1454 nullAtom); |
1409 response.setHTTPStatusCode(statusCode); | 1455 response.setHTTPStatusCode(statusCode); |
1410 imageResource->loader()->didReceiveResponse( | 1456 imageResource->loader()->didReceiveResponse( |
1411 WrappedResourceResponse(response)); | 1457 WrappedResourceResponse(response)); |
1412 imageResource->loader()->didReceiveData(kBadImageData, | 1458 imageResource->loader()->didReceiveData(kBadImageData, |
1413 sizeof(kBadImageData)); | 1459 sizeof(kBadImageData)); |
1414 | 1460 |
1415 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); | 1461 EXPECT_FALSE(observer->imageNotifyFinishedCalled()); |
1416 | 1462 |
| 1463 ImageResource* reloadingResource = |
| 1464 toImageResource(fetcher->cachedResource(testURL)); |
| 1465 ASSERT_TRUE(reloadingResource); |
| 1466 |
1417 // The dimensions could not be extracted, and the response code was a 4xx | 1467 // The dimensions could not be extracted, and the response code was a 4xx |
1418 // error, so the full original image should be loading. | 1468 // error, so the full original image should be loading. |
1419 testThatReloadIsStartedThenServeReload( | 1469 testThatReloadIsStartedThenServeReload( |
1420 testURL, imageResource, imageResource->getContent(), observer.get(), | 1470 testURL, imageResource, reloadingResource, content, observer.get(), |
1421 WebCachePolicy::BypassingCache); | 1471 WebCachePolicy::BypassingCache); |
1422 } | 1472 } |
1423 } | 1473 } |
1424 | 1474 |
1425 TEST(ImageResourceTest, PeriodicFlushTest) { | 1475 TEST(ImageResourceTest, PeriodicFlushTest) { |
1426 ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler> | 1476 ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler> |
1427 platform; | 1477 platform; |
1428 KURL testURL(ParsedURLString, kTestURL); | 1478 KURL testURL(ParsedURLString, kTestURL); |
1429 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); | 1479 ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath()); |
1430 ResourceRequest request = ResourceRequest(testURL); | 1480 ResourceRequest request = ResourceRequest(testURL); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1503 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); | 1553 EXPECT_TRUE(observer->imageNotifyFinishedCalled()); |
1504 EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage()); | 1554 EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage()); |
1505 EXPECT_EQ(50, imageResource->getContent()->getImage()->width()); | 1555 EXPECT_EQ(50, imageResource->getContent()->getImage()->width()); |
1506 EXPECT_EQ(50, imageResource->getContent()->getImage()->height()); | 1556 EXPECT_EQ(50, imageResource->getContent()->getImage()->height()); |
1507 | 1557 |
1508 WTF::setTimeFunctionsForTesting(nullptr); | 1558 WTF::setTimeFunctionsForTesting(nullptr); |
1509 } | 1559 } |
1510 | 1560 |
1511 } // namespace | 1561 } // namespace |
1512 } // namespace blink | 1562 } // namespace blink |
OLD | NEW |