ImageResourceTest: merge successful placeholder/non-placeholder loading

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

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 75 matching lines @@
     0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0xc4, 0x00, 0x14, 0x10, 0x01, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0xff, 0xc4, 0x00, 0x14, 0x01, 0x01, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0xff, 0xc4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
     0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f,
     0x00, 0xb2, 0xc0, 0x07, 0xff, 0xd9};
 
 constexpr int kJpegImageWidth = 1;
+constexpr int kJpegImageHeight = 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
 // fails, then the test data here probably needs to be updated.
 TEST(ImageResourceTest, DimensionsDecodableFromPartialTestImage) {
   RefPtr<Image> image = BitmapImage::create();
@@ skipping 124 matching lines @@
   EXPECT_EQ(imageWidth, content->getImage()->width());
   EXPECT_EQ(imageHeight, content->getImage()->height());
   EXPECT_TRUE(content->getImage()->isBitmapImage());
 }
 
 AtomicString buildContentRange(size_t rangeLength, size_t totalLength) {
   return AtomicString(String("bytes 0-" + String::number(rangeLength - 1) +
                              "/" + String::number(totalLength)));
 }
 
+void testThatIsPlaceholderRequestAndServeResponse(
+    const KURL& url,
+    ImageResource* imageResource,
+    MockImageResourceObserver* observer) {
+  // Checks that |imageResource| is requesting for placeholder.
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
+  EXPECT_EQ("bytes=0-2047",
+            imageResource->resourceRequest().httpHeaderField("range"));
+  EXPECT_EQ(0, observer->imageChangedCount());
+
+  // Serves partial response that is sufficient for creating a placeholder.
+  ResourceResponse response(url, "image/jpeg",
+                            kJpegImageSubrangeWithDimensionsLength, nullAtom);
+  response.setHTTPStatusCode(206);
+  response.setHTTPHeaderField(
+      "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
+                                         sizeof(kJpegImage)));
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(response));
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage),
+      kJpegImageSubrangeWithDimensionsLength);
+  imageResource->loader()->didFinishLoading(
+      0.0, kJpegImageSubrangeWithDimensionsLength,
+      kJpegImageSubrangeWithDimensionsLength);
+
+  // Checks that |imageResource| is successfully loaded, showing a placeholder.
+  EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
+  EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
+            imageResource->encodedSize());
+
+  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(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
+
+  // A placeholder image.
+  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
+  EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
+  EXPECT_FALSE(imageResource->getContent()->getImage()->isSVGImage());
+}
+
+void testThatIsNotPlaceholderRequestAndServeResponse(
+    const KURL& url,
+    ImageResource* imageResource,
+    MockImageResourceObserver* observer) {
+  // Checks that |imageResource| is NOT requesting for placeholder.
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
+  EXPECT_EQ(nullAtom,
+            imageResource->resourceRequest().httpHeaderField("range"));
+  EXPECT_EQ(0, observer->imageChangedCount());
+
+  // Serves full response.
+  imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
+      ResourceResponse(url, "image/jpeg", sizeof(kJpegImage), nullAtom)));
+  imageResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
+  imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
+                                            sizeof(kJpegImage));
+
+  // Checks that |imageResource| is successfully loaded.
+  // showing a non-placeholder image.

[sclittle, 2017/03/07 22:01:26]

nit: could you fix this comment?

[hiroshige, 2017/03/07 22:53:15]

Fixed a little bit.
Is this what you meant?

[sclittle, 2017/03/07 22:55:01]

Yep, thanks!

+  EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
+  EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
+
+  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(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
+
+  // A non-placeholder bitmap image.
+  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
+  EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
+  EXPECT_FALSE(imageResource->getContent()->getImage()->isSVGImage());
+}
+
 ResourceFetcher* createFetcher() {
   return ResourceFetcher::create(
       MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
 }
 
 TEST(ImageResourceTest, MultipartImage) {
   ResourceFetcher* fetcher = createFetcher();
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
@@ skipping 57 matching lines @@
   ASSERT_TRUE(imageResource->resourceBuffer());
   EXPECT_EQ(strlen(secondPart) - 1, imageResource->resourceBuffer()->size());
 
   // This part finishes. The image is created, callbacks are sent, and the data
   // buffer is cleared.
   imageResource->loader()->didFinishLoading(0.0, 0, 0);
   EXPECT_TRUE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
   EXPECT_EQ(1, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(1, observer2->imageChangedCount());
   EXPECT_TRUE(observer2->imageNotifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnRemoveObserver) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
@@ skipping 112 matching lines @@
   imageResource->finish();
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
   // The observer should have been notified that the image load completed.
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
                                                 Resource::kReloadAlways);
 
   EXPECT_EQ(3, observer->imageChangedCount());
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
       WebCachePolicy::BypassingCache);
 }
@@ skipping 63 matching lines @@
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(1, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() while the image is still loading.
   imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
                                                 Resource::kReloadAlways);
 
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_EQ(0, observer->imageWidthOnLastImageChanged());
   // The observer should not have been notified of completion yet, since the
   // image is still loading.
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceFetcher* fetcher = createFetcher();
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
-  EXPECT_EQ("bytes=0-2047",
-            imageResource->resourceRequest().httpHeaderField("range"));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
-  ResourceResponse response(testURL, "image/jpeg",
-                            kJpegImageSubrangeWithDimensionsLength, nullAtom);
-  response.setHTTPStatusCode(206);
-  response.setHTTPHeaderField(
-      "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
-                                         sizeof(kJpegImage)));
-  imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(response));
-  imageResource->loader()->didReceiveData(
-      reinterpret_cast<const char*>(kJpegImage),
-      kJpegImageSubrangeWithDimensionsLength);
-  imageResource->loader()->didFinishLoading(
-      0.0, kJpegImageSubrangeWithDimensionsLength,
-      kJpegImageSubrangeWithDimensionsLength);
-
-  EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
-  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
-  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
+                                               observer.get());
 
   imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
                                                 Resource::kReloadAlways);
 
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
 TEST(ImageResourceTest, SVGImage) {
@@ skipping 22 matching lines @@
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(304);
 
   imageResource->responseReceived(response, nullptr);
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, SuccessfulRevalidationSvg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
@@ skipping 32 matching lines @@
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage2),
                   sizeof(kJpegImage2));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(4, observer->imageChangedCount());
@@ skipping 12 matching lines @@
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(3, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
@@ skipping 24 matching lines @@
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(3, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, FailedRevalidationSvgToSvg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
@@ skipping 31 matching lines @@
   Persistent<MockResourceClient> client1 =
       new MockResourceClient(imageResource);
 
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(client1->notifyFinishedCalled());
 
   client1->removeAsClient();
 
   EXPECT_FALSE(imageResource->isAlive());
 
   imageResource->prune();
 
   EXPECT_TRUE(imageResource->getContent()->hasImage());
 
   // Re-adds a ResourceClient but not ImageResourceObserver.
   Persistent<MockResourceClient> client2 =
       new MockResourceClient(imageResource);
 
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
+  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight,
+            imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(client2->notifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDecodeError) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceFetcher* fetcher = createFetcher();
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
@@ skipping 92 matching lines @@
 }
 
 TEST(ImageResourceTest, FetchDisallowPlaceholder) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
-  EXPECT_EQ(nullAtom,
-            imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
-  imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
-      ResourceResponse(testURL, "image/jpeg", sizeof(kJpegImage), nullAtom)));
-  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->shouldShowPlaceholder());
-  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());
+  testThatIsNotPlaceholderRequestAndServeResponse(testURL, imageResource,
+                                                  observer.get());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   KURL testURL(ParsedURLString,
                "data:image/jpeg;base64," +
                    base64Encode(reinterpret_cast<const char*>(kJpegImage),
                                 sizeof(kJpegImage)));
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
@@ skipping 40 matching lines @@
 
 TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
-  EXPECT_EQ("bytes=0-2047",
-            imageResource->resourceRequest().httpHeaderField("range"));
-  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
-  ResourceResponse response(testURL, "image/jpeg",
-                            kJpegImageSubrangeWithDimensionsLength, nullAtom);
-  response.setHTTPStatusCode(206);
-  response.setHTTPHeaderField(
-      "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
-                                         sizeof(kJpegImage)));
-  imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(response));
-  imageResource->loader()->didReceiveData(
-      reinterpret_cast<const char*>(kJpegImage),
-      kJpegImageSubrangeWithDimensionsLength);
-  imageResource->loader()->didFinishLoading(
-      0.0, kJpegImageSubrangeWithDimensionsLength,
-      kJpegImageSubrangeWithDimensionsLength);
-
-  EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
-  EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
-            imageResource->encodedSize());
-  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
-  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_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_FALSE(imageResource->getContent()->getImage()->isSVGImage());
+  testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
+                                               observer.get());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
@@ skipping 73 matching lines @@
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceFetcher* fetcher = createFetcher();
+
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImageResource =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
@@ skipping 12 matching lines @@
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceFetcher* fetcher = createFetcher();
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
-  ResourceResponse response(testURL, "image/jpeg",
-                            kJpegImageSubrangeWithDimensionsLength, nullAtom);
-  response.setHTTPStatusCode(206);
-  response.setHTTPHeaderField(
-      "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
-                                         sizeof(kJpegImage)));
-  imageResource->loader()->didReceiveResponse(
-      WrappedResourceResponse(response));
-  imageResource->loader()->didReceiveData(
-      reinterpret_cast<const char*>(kJpegImage),
-      kJpegImageSubrangeWithDimensionsLength);
-  imageResource->loader()->didFinishLoading(
-      0.0, kJpegImageSubrangeWithDimensionsLength,
-      kJpegImageSubrangeWithDimensionsLength);
-
-  EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
-  EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
-            imageResource->encodedSize());
-  EXPECT_TRUE(imageResource->shouldShowPlaceholder());
-  EXPECT_LT(0, observer->imageChangedCount());
-  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
+                                               observer.get());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImageResource =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   EXPECT_EQ(imageResource, secondImageResource);
 
   testThatReloadIsStartedThenServeReload(
       testURL, imageResource, imageResource->getContent(), observer.get(),
       WebCachePolicy::UseProtocolCachePolicy);
 }
@@ skipping 37 matching lines @@
 
     EXPECT_EQ(ResourceStatus::Cached, imageResource->getStatus());
     EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
     EXPECT_FALSE(imageResource->shouldShowPlaceholder());
     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_EQ(kJpegImageWidth,
+              imageResource->getContent()->getImage()->width());
+    EXPECT_EQ(kJpegImageHeight,
+              imageResource->getContent()->getImage()->height());
     EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   }
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderFullResponseDecodeFailureNoReload) {
   static const char kBadImageData[] = "bad image data";
 
   const struct {
     int statusCode;
@@ skipping 154 matching lines @@
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
 
   WTF::setTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink