Show image placeholders on dimension decode error

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 172 matching lines @@
   image_resource->NotifyStartLoad();
   image_resource->ResponseReceived(response, nullptr);
   image_resource->AppendData(data, data_size);
   image_resource->Finish();
 }
 
 void TestThatReloadIsStartedThenServeReload(const KURL& test_url,
                                             ImageResource* image_resource,
                                             ImageResourceContent* content,
                                             MockImageResourceObserver* observer,
-                                            WebCachePolicy policy_for_reload) {
+                                            WebCachePolicy policy_for_reload,
+                                            bool placeholder_before_reload) {
   const char* data = reinterpret_cast<const char*>(kJpegImage2);
   constexpr size_t kDataLength = sizeof(kJpegImage2);
   constexpr int kImageWidth = 50;
   constexpr int kImageHeight = 50;
 
   // Checks that |imageResource| and |content| are ready for non-placeholder
   // reloading.
   EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus());
   EXPECT_FALSE(image_resource->ResourceBuffer());
-  EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
+  EXPECT_EQ(placeholder_before_reload, image_resource->ShouldShowPlaceholder());
   EXPECT_EQ(g_null_atom,
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_EQ(policy_for_reload,
             image_resource->GetResourceRequest().GetCachePolicy());
   EXPECT_EQ(content, image_resource->GetContent());
   EXPECT_FALSE(content->HasImage());
 
   // Checks |observer| before reloading.
   const int original_image_changed_count = observer->ImageChangedCount();
   const bool already_notified_finish = observer->ImageNotifyFinishedCalled();
@@ skipping 22 matching lines @@
     // response is served, then imageNotifyFinished() should be called with
     // the new image (of width |imageWidth|).
     EXPECT_EQ(kImageWidth, observer->ImageWidthOnImageNotifyFinished());
   }
 
   // Checks |content| receives the correct image.
   EXPECT_TRUE(content->HasImage());
   EXPECT_FALSE(content->GetImage()->IsNull());
   EXPECT_EQ(kImageWidth, content->GetImage()->width());
   EXPECT_EQ(kImageHeight, content->GetImage()->height());
-  EXPECT_TRUE(content->GetImage()->IsBitmapImage());
   EXPECT_FALSE(content->GetImage()->PaintImageForCurrentFrame().is_multipart());
 }
 
 AtomicString BuildContentRange(size_t range_length, size_t total_length) {
   return AtomicString(String("bytes 0-" + String::Number(range_length - 1) +
                              "/" + String::Number(total_length)));
 }
 
 void TestThatIsPlaceholderRequestAndServeResponse(
     const KURL& url,
@@ skipping 335 matching lines @@
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   EXPECT_EQ(3, observer->ImageChangedCount());
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
-      WebCachePolicy::kBypassingCache);
+      WebCachePolicy::kBypassingCache, false);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinishedWithOldHeaders) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ImageResource* image_resource = ImageResource::CreateForTest(test_url);
   image_resource->SetStatus(ResourceStatus::kPending);
   image_resource->NotifyStartLoad();
 
   std::unique_ptr<MockImageResourceObserver> observer =
@@ skipping 22 matching lines @@
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   EXPECT_EQ(3, observer->ImageChangedCount());
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
-      WebCachePolicy::kBypassingCache);
+      WebCachePolicy::kBypassingCache, false);
 }
 
 TEST(ImageResourceTest,
      ReloadIfLoFiOrPlaceholderAfterFinishedWithoutLoFiHeaders) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest request(test_url);
   request.SetPreviewsState(WebURLRequest::kServerLoFiOn);
   request.SetFetchCredentialsMode(WebURLRequest::kFetchCredentialsModeOmit);
   ImageResource* image_resource = ImageResource::Create(request);
@@ skipping 62 matching lines @@
   image_resource->Loader()->DidFinishLoading(
       0.0, sizeof(kJpegImage), sizeof(kJpegImage), sizeof(kJpegImage));
 
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(image_resource, fetcher->CachedResource(test_url));
 
   fetcher->ReloadLoFiImages();
 
   EXPECT_EQ(3, observer->ImageChangedCount());
 
-  TestThatReloadIsStartedThenServeReload(test_url, image_resource, content,
-                                         observer.get(),
-                                         WebCachePolicy::kBypassingCache);
+  TestThatReloadIsStartedThenServeReload(
+      test_url, image_resource, content, observer.get(),
+      WebCachePolicy::kBypassingCache, false);
 
   GetMemoryCache()->Remove(image_resource);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceRequest request(test_url);
   request.SetPreviewsState(WebURLRequest::kServerLoFiOn);
@@ skipping 27 matching lines @@
                                                  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(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
-      WebCachePolicy::kBypassingCache);
+      WebCachePolicy::kBypassingCache, false);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
   FetchParameters params{ResourceRequest(test_url)};
   params.SetAllowImagePlaceholder();
   ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
-      WebCachePolicy::kBypassingCache);
+      WebCachePolicy::kBypassingCache, false);
 }
 
 TEST(ImageResourceTest, SVGImage) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* image_resource = ImageResource::CreateForTest(url);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
@@ skipping 508 matching lines @@
   image_resource->Loader()->DidReceiveResponse(
       WrappedResourceResponse(bad_response));
 
   EXPECT_EQ(0, observer->ImageChangedCount());
 
   image_resource->Loader()->DidReceiveData(kBadData, sizeof(kBadData));
 
   // The dimensions could not be extracted, so the full original image should be
   // loading.
   EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
+  EXPECT_EQ(2, observer->ImageChangedCount());
+  EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
+
+  TestThatReloadIsStartedThenServeReload(
+      test_url, image_resource, image_resource->GetContent(), observer.get(),
+      WebCachePolicy::kBypassingCache, false);
+}
+
+TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessfulClientLoFi) {
+  KURL test_url(kParsedURLString, kTestURL);
+  ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
+
+  ResourceRequest request = ResourceRequest(test_url);
+  request.SetPreviewsState(WebURLRequest::kClientLoFiOn);
+  FetchParameters params{request};
+  params.SetAllowImagePlaceholder();
+  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  EXPECT_EQ(FetchParameters::kAllowPlaceholder,
+            params.GetPlaceholderImageRequestType());
+  EXPECT_EQ("bytes=0-2047",
+            image_resource->GetResourceRequest().HttpHeaderField("range"));
+  EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::Create(image_resource->GetContent());
+
+  const char kBadData[] = "notanimageresponse";
+
+  ResourceResponse bad_response(test_url, "image/jpeg", sizeof(kBadData),
+                                g_null_atom);
+  bad_response.SetHTTPStatusCode(206);
+  bad_response.SetHTTPHeaderField(
+      "content-range", BuildContentRange(sizeof(kBadData), sizeof(kJpegImage)));
+
+  image_resource->Loader()->DidReceiveResponse(
+      WrappedResourceResponse(bad_response));
+
+  EXPECT_EQ(0, observer->ImageChangedCount());
+
+  image_resource->Loader()->DidReceiveData(kBadData, sizeof(kBadData));
+
+  // The dimensions could not be extracted, so the full original image should be
+  // loading.
+  EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(2, observer->ImageChangedCount());
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
-      WebCachePolicy::kBypassingCache);
+      WebCachePolicy::kBypassingCache, true);
+
+  EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage());
+  EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
   const struct {
     WebURLRequest::PreviewsState initial_previews_state;
     WebURLRequest::PreviewsState expected_reload_previews_state;
+    bool placeholder_before_reload;
+    bool placeholder_after_reload;
   } tests[] = {
-      {WebURLRequest::kPreviewsUnspecified,
-       WebURLRequest::kPreviewsNoTransform},
-      {WebURLRequest::kClientLoFiOn, WebURLRequest::kPreviewsNoTransform |
-                                         WebURLRequest::kClientLoFiAutoReload},
+      {WebURLRequest::kPreviewsUnspecified, WebURLRequest::kPreviewsNoTransform,
+       false},
+      {WebURLRequest::kClientLoFiOn,
+       WebURLRequest::kPreviewsNoTransform |
+           WebURLRequest::kClientLoFiAutoReload,
+       true},
   };
 
   for (const auto& test : tests) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
     ResourceRequest resource_request(test_url);
     resource_request.SetPreviewsState(test.initial_previews_state);
     FetchParameters params(resource_request);
 
@@ skipping 30 matching lines @@
     image_resource->Loader()->DidFinishLoading(
         0.0, kJpegImageSubrangeWithoutDimensionsLength,
         kJpegImageSubrangeWithoutDimensionsLength,
         kJpegImageSubrangeWithoutDimensionsLength);
 
     EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
     EXPECT_EQ(2, observer->ImageChangedCount());
 
     TestThatReloadIsStartedThenServeReload(
         test_url, image_resource, image_resource->GetContent(), observer.get(),
-        WebCachePolicy::kBypassingCache);
+        WebCachePolicy::kBypassingCache, test.placeholder_before_reload);
 
     EXPECT_EQ(test.expected_reload_previews_state,
               image_resource->GetResourceRequest().GetPreviewsState());
   }
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
@@ skipping 209 matching lines @@
         WrappedResourceResponse(response));
     image_resource->Loader()->DidReceiveData(kBadImageData,
                                              sizeof(kBadImageData));
 
     EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
 
     // The dimensions could not be extracted, and the response code was a 4xx
     // error, so the full original image should be loading.
     TestThatReloadIsStartedThenServeReload(
         test_url, image_resource, image_resource->GetContent(), observer.get(),
-        WebCachePolicy::kBypassingCache);
+        WebCachePolicy::kBypassingCache, false);
   }
 }
 
 TEST(ImageResourceTest, PeriodicFlushTest) {
   ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
       platform;
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ImageResource* image_resource = ImageResource::CreateForTest(test_url);
   image_resource->SetStatus(ResourceStatus::kPending);
@@ skipping 71 matching lines @@
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height());
 
   WTF::SetTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink