Don't show a placeholder if the response contains the full image.

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 188 matching lines @@
   RefPtr<WebTaskRunner> loadingTaskRunner() const override { return m_runner; }
 
  private:
   ImageResourceTestMockFetchContext()
       : m_runner(adoptRef(new scheduler::FakeWebTaskRunner)) {}
 
   RefPtr<scheduler::FakeWebTaskRunner> m_runner;
 };
 
 AtomicString buildContentRange(size_t rangeLength, size_t totalLength) {
-  return AtomicString(String("bytes 0-" + String::number(rangeLength) + "/" +
-                             String::number(totalLength)));
+  return AtomicString(String("bytes 0-" + String::number(rangeLength - 1) +
+                             "/" + String::number(totalLength)));
 }
 
 TEST(ImageResourceTest, MultipartImage) {
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   // Emulate starting a real load, but don't expect any "real"
   // WebURLLoaderClient callbacks.
@@ skipping 923 matching lines @@
   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());
 
   const char kBadData[] = "notanimageresponse";
 
-  imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
-      ResourceResponse(testURL, "image/jpeg", sizeof(kBadData), nullAtom)));
+  ResourceResponse badResponse(testURL, "image/jpeg", sizeof(kBadData),
+                               nullAtom);
+  badResponse.setHTTPStatusCode(206);
+  badResponse.setHTTPHeaderField(
+      "content-range", buildContentRange(sizeof(kBadData), sizeof(kJpegImage)));
+
+  imageResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(badResponse));
 
   EXPECT_EQ(0, observer->imageChangedCount());
 
   imageResource->loader()->didReceiveData(kBadData, sizeof(kBadData));
 
   // 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,
@@ skipping 171 matching lines @@
   EXPECT_FALSE(imageResource->isPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(
       static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
       static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
 
   imageResource->loader()->cancel();
 }
 
+TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
+  const struct {
+    int statusCode;
+    AtomicString contentRange;
+  } tests[] = {
+      {200, nullAtom},
+      {404, nullAtom},
+      {206, buildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))},
+  };
+  for (const auto& test : tests) {
+    KURL testURL(ParsedURLString, kTestURL);
+    ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
+
+    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 response(testURL, "image/jpeg", sizeof(kJpegImage),
+                              nullAtom);
+    response.setHTTPStatusCode(test.statusCode);
+    if (test.contentRange != nullAtom)
+      response.setHTTPHeaderField("content-range", test.contentRange);
+    imageResource->loader()->didReceiveResponse(
+        WrappedResourceResponse(response));
+    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());
+  }
+}
+
+TEST(ImageResourceTest,
+     FetchAllowPlaceholderFullResponseDecodeFailureNoReload) {
+  static const char kBadImageData[] = "bad image data";
+
+  const struct {
+    int statusCode;
+    AtomicString contentRange;
+    size_t dataSize;
+  } tests[] = {
+      {200, nullAtom, sizeof(kBadImageData)},
+      {206, buildContentRange(sizeof(kBadImageData), sizeof(kBadImageData)),
+       sizeof(kBadImageData)},
+      {204, nullAtom, 0},
+  };
+  for (const auto& test : tests) {
+    KURL testURL(ParsedURLString, kTestURL);
+    ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
+
+    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 response(testURL, "image/jpeg", test.dataSize, nullAtom);
+    response.setHTTPStatusCode(test.statusCode);
+    if (test.contentRange != nullAtom)
+      response.setHTTPHeaderField("content-range", test.contentRange);
+    imageResource->loader()->didReceiveResponse(
+        WrappedResourceResponse(response));
+    imageResource->loader()->didReceiveData(kBadImageData, test.dataSize);
+
+    EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
+    EXPECT_FALSE(imageResource->isPlaceholder());
+  }
+}
+
+TEST(ImageResourceTest,
+     FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
+  const int kStatusCodes[] = {404, 500};
+  for (int statusCode : kStatusCodes) {
+    KURL testURL(ParsedURLString, kTestURL);
+    ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
+
+    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());
+
+    static const char kBadImageData[] = "bad image data";
+
+    ResourceResponse response(testURL, "image/jpeg", sizeof(kBadImageData),
+                              nullAtom);
+    response.setHTTPStatusCode(statusCode);
+    imageResource->loader()->didReceiveResponse(
+        WrappedResourceResponse(response));
+    imageResource->loader()->didReceiveData(kBadImageData,
+                                            sizeof(kBadImageData));
+
+    // The dimensions could not be extracted, and the response code was a 4xx
+    // error, 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());
+
+    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->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());
+  }
+}
+
 TEST(ImageResourceTest, PeriodicFlushTest) {
   ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
       platform;
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest request = ResourceRequest(testURL);
   ImageResource* imageResource = ImageResource::create(request);
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
@@ skipping 68 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