Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(123)

Side by Side Diff: third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp

Issue 2527353002: Phase II Step 3: Reload LoFi/placeholder images via new ImageResource
Patch Set: Reflect comments and rebase Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698