Add more unit tests for placeholder reloading

third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp

Index: third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
diff --git a/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp b/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
index 276b3bce06467e27985b88803db4b89c949a6b24..7f8bf0e7f47b4e7e8c9954fd9f44c5813aeffb90 100644
--- a/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
+++ b/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
@@ -94,6 +94,7 @@ constexpr int kJpegImageWidth = 1;
 
 constexpr size_t kJpegImageSubrangeWithDimensionsLength =
     sizeof(kJpegImage) - 1;
+constexpr size_t kJpegImageSubrangeWithoutDimensionsLength = 3;
 
 // Ensure that the image decoder can determine the dimensions of kJpegImage from
 // just the first kJpegImageSubrangeWithDimensionsLength bytes. If this test
@@ -468,6 +469,65 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
 }
 
+TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
+  ResourceFetcher* fetcher =
+      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+
+  KURL testURL(ParsedURLString, "http://www.test.com/cancelTest2.html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+  ResourceRequest request = ResourceRequest(testURL);
+  request.setPreviewsState(WebURLRequest::ServerLoFiOn);
+  FetchRequest fetchRequest(request, FetchInitiatorInfo());
+  ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher);
+  ImageResourceContent* content = imageResource->getContent();
+
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(content);
+
+  // Send the image response.
+  ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage),
+                                    nullAtom, String());
+  resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform",
+                                      "empty-image");
+
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(resourceResponse));
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
+  imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
+                                            sizeof(kJpegImage));
+
+  EXPECT_EQ(imageResource, fetcher->cachedResource(testURL));
+
+  fetcher->reloadLoFiImages();
+
+  EXPECT_FALSE(imageResource->errorOccurred());
+  EXPECT_FALSE(imageResource->resourceBuffer());
+  EXPECT_FALSE(imageResource->getContent()->hasImage());
+  EXPECT_EQ(3, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(resourceResponse), nullptr);
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
+  imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
+                                            sizeof(kJpegImage2));
+  EXPECT_FALSE(imageResource->errorOccurred());
+  ASSERT_TRUE(imageResource->getContent()->hasImage());
+  EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
+  EXPECT_EQ(kJpegImage2Width, observer->imageWidthOnLastImageChanged());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+
+  // The observer should not have been notified of completion again.
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
+
+  EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
+  EXPECT_EQ(50, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
+}
+
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
@@ -1106,6 +1166,122 @@ TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
+TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
+  KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+  FetchRequest request(testURL, FetchInitiatorInfo());
+  request.setAllowImagePlaceholder();
+  ImageResource* imageResource = ImageResource::fetch(
+      request,
+      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  EXPECT_EQ(FetchRequest::AllowPlaceholder,
+            request.placeholderImageRequestType());
+  EXPECT_EQ("bytes=0-2047",
+            imageResource->resourceRequest().httpHeaderField("range"));
+  EXPECT_TRUE(imageResource->isPlaceholder());
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
+
+  ResourceResponse partialResponse(testURL, "image/jpeg",
+                                   kJpegImageSubrangeWithoutDimensionsLength,
+                                   nullAtom, String());
+  partialResponse.setHTTPStatusCode(206);
+  partialResponse.setHTTPHeaderField(
+      "content-range",
+      buildContentRange(kJpegImageSubrangeWithoutDimensionsLength,
+                        sizeof(kJpegImage)));
+
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(partialResponse));
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage),
+      kJpegImageSubrangeWithoutDimensionsLength);
+
+  EXPECT_EQ(0, observer->imageChangedCount());
+
+  imageResource->loader()->didFinishLoading(
+      0.0, kJpegImageSubrangeWithoutDimensionsLength,
+      kJpegImageSubrangeWithoutDimensionsLength);
+
+  // Decode error didn't occur but the dimensions could not be extracted,
+  // so the full original image should be loading.
+  EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
+  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_EQ(nullAtom,
+            imageResource->resourceRequest().httpHeaderField("range"));
+  EXPECT_EQ(
+      static_cast<int>(WebCachePolicy::BypassingCache),
+      static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(ResourceResponse(
+          testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
+  imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
+                                            sizeof(kJpegImage));
+
+  EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
+  EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
+  EXPECT_FALSE(imageResource->isPlaceholder());
+  EXPECT_LT(0, observer->imageChangedCount());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
+
+  ASSERT_TRUE(imageResource->getContent()->hasImage());
+  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
+}
+
+// Testing DecodeError that occurs in didFinishLoading().
+// This is similar to DecodeErrorWithEmptyBody, but with non-empty body.
+TEST(ImageResourceTest, PartialContentWithoutDimensions) {

[sclittle, 2017/01/27 21:56:06]

nit: Would it make sense to move this test up above, to just after
DecodeErrorWithEmptyBody? It just seems like it's more related to that test than
the placeholder tests here.

[hiroshige, 2017/02/06 22:50:45]

Done.

+  KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+  FetchRequest request(testURL, FetchInitiatorInfo());
+  ResourceFetcher* fetcher =
+      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ImageResource* imageResource = ImageResource::fetch(request, fetcher);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
+
+  ResourceResponse partialResponse(testURL, "image/jpeg",
+                                   kJpegImageSubrangeWithoutDimensionsLength,
+                                   nullAtom, String());
+  partialResponse.setHTTPStatusCode(206);
+  partialResponse.setHTTPHeaderField(
+      "content-range",
+      buildContentRange(kJpegImageSubrangeWithoutDimensionsLength,
+                        sizeof(kJpegImage)));
+
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(partialResponse));
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage),
+      kJpegImageSubrangeWithoutDimensionsLength);
+
+  EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(0, observer->imageChangedCount());
+
+  imageResource->loader()->didFinishLoading(
+      0.0, kJpegImageSubrangeWithoutDimensionsLength,
+      kJpegImageSubrangeWithoutDimensionsLength);
+
+  EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(ResourceStatus::DecodeError,
+            observer->statusOnImageNotifyFinished());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_FALSE(imageResource->isLoading());
+}
+
 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);