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

third_party/WebKit/Source/core/fetch/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 194 matching lines @@
 
   ~ScopedRegisteredURL() {
     Platform::current()->getURLLoaderMockFactory()->unregisterURL(m_url);
   }
 
  private:
   KURL m_url;
 };
 
 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, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   // Emulate starting a real load, but don't expect any "real"
   // WebURLLoaderClient callbacks.
@@ skipping 786 matching lines @@
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047", image->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(image->isPlaceholder());
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(image);
 
   const char kBadData[] = "notanimageresponse";
 
-  image->loader()->didReceiveResponse(
-      WrappedResourceResponse(ResourceResponse(
-          testURL, "image/jpeg", sizeof(kBadData), nullAtom, String())));
+  ResourceResponse badResponse(testURL, "image/jpeg", sizeof(kBadData),
+                               nullAtom, String());
+  badResponse.setHTTPStatusCode(206);
+  badResponse.setHTTPHeaderField(
+      "content-range", buildContentRange(sizeof(kBadData), sizeof(kJpegImage)));
+
+  image->loader()->didReceiveResponse(WrappedResourceResponse(badResponse));
   image->loader()->didReceiveData(kBadData, sizeof(kBadData), sizeof(kBadData));
 
   // The dimensions could not be extracted, so the full original image should be
   // loading.
   EXPECT_EQ(Resource::Pending, image->getStatus());
   EXPECT_FALSE(image->isPlaceholder());
   EXPECT_EQ(nullAtom, image->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(static_cast<int>(WebCachePolicy::BypassingCache),
             static_cast<int>(image->resourceRequest().getCachePolicy()));
   EXPECT_FALSE(client->notifyFinishedCalled());
   EXPECT_EQ(0, client->imageNotifyFinishedCount());
 
-  image->loader()->didReceiveResponse(
-      WrappedResourceResponse(ResourceResponse(
-          testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
+  image->loader()->didReceiveResponse(WrappedResourceResponse(ResourceResponse(
+      testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
   image->loader()->didReceiveData(reinterpret_cast<const char*>(kJpegImage),
                                   sizeof(kJpegImage), sizeof(kJpegImage));
   image->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
                                     sizeof(kJpegImage));
 
   EXPECT_EQ(Resource::Cached, image->getStatus());
   EXPECT_EQ(sizeof(kJpegImage), image->encodedSize());
   EXPECT_FALSE(image->isPlaceholder());
   EXPECT_LT(0, client->imageChangedCount());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
@@ skipping 73 matching lines @@
   EXPECT_EQ(image, secondImage);
   EXPECT_EQ(Resource::Pending, image->getStatus());
   EXPECT_FALSE(image->isPlaceholder());
   EXPECT_EQ(nullAtom, image->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
             static_cast<int>(image->resourceRequest().getCachePolicy()));
 
   image->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, "http://www.test.com/cancelTest.html");
+    ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+    FetchRequest request(testURL, FetchInitiatorInfo());
+    request.setAllowImagePlaceholder();
+    ImageResource* image = ImageResource::fetch(
+        request,
+        ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+    EXPECT_EQ(FetchRequest::AllowPlaceholder,
+              request.placeholderImageRequestType());
+    EXPECT_EQ("bytes=0-2047",
+              image->resourceRequest().httpHeaderField("range"));
+    EXPECT_TRUE(image->isPlaceholder());
+    Persistent<MockImageResourceClient> client =
+        new MockImageResourceClient(image);
+
+    ResourceResponse response(testURL, "image/jpeg", sizeof(kJpegImage),
+                              nullAtom, String());
+    response.setHTTPStatusCode(test.statusCode);
+    if (test.contentRange != nullAtom)
+      response.setHTTPHeaderField("content-range", test.contentRange);
+    image->loader()->didReceiveResponse(WrappedResourceResponse(response));
+    image->loader()->didReceiveData(reinterpret_cast<const char*>(kJpegImage),
+                                    sizeof(kJpegImage), sizeof(kJpegImage));
+    image->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
+                                      sizeof(kJpegImage));
+
+    EXPECT_EQ(Resource::Cached, image->getStatus());
+    EXPECT_EQ(sizeof(kJpegImage), image->encodedSize());
+    EXPECT_FALSE(image->isPlaceholder());
+    EXPECT_LT(0, client->imageChangedCount());
+    EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
+    EXPECT_TRUE(client->notifyFinishedCalled());
+    EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnNotifyFinished());
+    EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
+
+    ASSERT_TRUE(image->hasImage());
+    EXPECT_EQ(1, image->getImage()->width());
+    EXPECT_EQ(1, image->getImage()->height());
+    EXPECT_TRUE(image->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, "http://www.test.com/cancelTest.html");
+    ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+    FetchRequest request(testURL, FetchInitiatorInfo());
+    request.setAllowImagePlaceholder();
+    ImageResource* image = ImageResource::fetch(
+        request,
+        ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+    EXPECT_EQ(FetchRequest::AllowPlaceholder,
+              request.placeholderImageRequestType());
+    EXPECT_EQ("bytes=0-2047",
+              image->resourceRequest().httpHeaderField("range"));
+    EXPECT_TRUE(image->isPlaceholder());
+    Persistent<MockImageResourceClient> client =
+        new MockImageResourceClient(image);
+
+    ResourceResponse response(testURL, "image/jpeg", test.dataSize, nullAtom,
+                              String());
+    response.setHTTPStatusCode(test.statusCode);
+    if (test.contentRange != nullAtom)
+      response.setHTTPHeaderField("content-range", test.contentRange);
+    image->loader()->didReceiveResponse(WrappedResourceResponse(response));
+    image->loader()->didReceiveData(kBadImageData, test.dataSize,
+                                    test.dataSize);
+
+    EXPECT_EQ(Resource::DecodeError, image->getStatus());
+    EXPECT_FALSE(image->isPlaceholder());
+  }
+}
+
+TEST(ImageResourceTest,
+     FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
+  const int kStatusCodes[] = {404, 500};
+  for (int statusCode : kStatusCodes) {
+    KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
+    ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+    FetchRequest request(testURL, FetchInitiatorInfo());
+    request.setAllowImagePlaceholder();
+    ImageResource* image = ImageResource::fetch(
+        request,
+        ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+    EXPECT_EQ(FetchRequest::AllowPlaceholder,
+              request.placeholderImageRequestType());
+    EXPECT_EQ("bytes=0-2047",
+              image->resourceRequest().httpHeaderField("range"));
+    EXPECT_TRUE(image->isPlaceholder());
+    Persistent<MockImageResourceClient> client =
+        new MockImageResourceClient(image);
+
+    static const char kBadImageData[] = "bad image data";
+
+    ResourceResponse response(testURL, "image/jpeg", sizeof(kBadImageData),
+                              nullAtom, String());
+    response.setHTTPStatusCode(statusCode);
+    image->loader()->didReceiveResponse(WrappedResourceResponse(response));
+    image->loader()->didReceiveData(kBadImageData, sizeof(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(Resource::Pending, image->getStatus());
+    EXPECT_FALSE(image->isPlaceholder());
+    EXPECT_EQ(nullAtom, image->resourceRequest().httpHeaderField("range"));
+    EXPECT_EQ(static_cast<int>(WebCachePolicy::BypassingCache),
+              static_cast<int>(image->resourceRequest().getCachePolicy()));
+    EXPECT_FALSE(client->notifyFinishedCalled());
+
+    image->loader()->didReceiveResponse(
+
+        WrappedResourceResponse(ResourceResponse(
+            testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
+    image->loader()->didReceiveData(reinterpret_cast<const char*>(kJpegImage),
+                                    sizeof(kJpegImage), sizeof(kJpegImage));
+    image->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
+                                      sizeof(kJpegImage));
+
+    EXPECT_EQ(Resource::Cached, image->getStatus());
+    EXPECT_EQ(sizeof(kJpegImage), image->encodedSize());
+    EXPECT_FALSE(image->isPlaceholder());
+    EXPECT_LT(0, client->imageChangedCount());
+    EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
+    EXPECT_TRUE(client->notifyFinishedCalled());
+    EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnNotifyFinished());
+    EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
+
+    ASSERT_TRUE(image->hasImage());
+    EXPECT_EQ(1, image->getImage()->width());
+    EXPECT_EQ(1, image->getImage()->height());
+    EXPECT_TRUE(image->getImage()->isBitmapImage());
+  }
+}
+
 TEST(ImageResourceTest, PeriodicFlushTest) {
   TestingPlatformSupportWithMockScheduler platform;
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
                                         "text/html");
   ResourceRequest request = ResourceRequest(testURL);
   ImageResource* cachedImage = ImageResource::create(request);
   cachedImage->setStatus(Resource::Pending);
 
   Persistent<MockImageResourceClient> client =
@@ skipping 68 matching lines @@
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
   EXPECT_EQ(50, cachedImage->getImage()->width());
   EXPECT_EQ(50, cachedImage->getImage()->height());
 
   WTF::setTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink