Phase II Step 3: Reload LoFi/placeholder images via new ImageResource

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 157 matching lines @@
                      size_t dataSize) {
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setMimeType(mimeType);
   imageResource->responseReceived(response, nullptr);
   imageResource->appendData(data, dataSize);
   imageResource->finish();
 }
 
-void testThatReloadIsStartedThenServeReload(const KURL& testURL,
-                                            ImageResource* imageResource,
-                                            ImageResourceContent* content,
-                                            MockImageResourceObserver* observer,
-                                            WebCachePolicy policyForReload) {
+void testThatReloadIsStartedThenServeReload(
+    const KURL& testURL,
+    ImageResource* originalImageResource,
+    ImageResource* imageResource,
+    ImageResourceContent* content,
+    MockImageResourceObserver* observer,
+    WebCachePolicy policyForReload) {
   const char* data = reinterpret_cast<const char*>(kJpegImage2);
   constexpr size_t dataLength = sizeof(kJpegImage2);
   constexpr int imageWidth = 50;
   constexpr int imageHeight = 50;
 
+  // Checks that |originalImageResource| is detached.
+  EXPECT_NE(originalImageResource, imageResource);
+  EXPECT_FALSE(originalImageResource->getContent());
+
   // Checks that |imageResource| and |content| are ready for non-placeholder
   // reloading.
   EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(policyForReload, imageResource->resourceRequest().getCachePolicy());
   EXPECT_EQ(content, imageResource->getContent());
   EXPECT_FALSE(content->hasImage());
+  EXPECT_EQ(imageResource, memoryCache()->resourceForURL(testURL));
 
   // Checks |observer| before reloading.
   const int originalImageChangedCount = observer->imageChangedCount();
   const bool alreadyNotifiedFinish = observer->imageNotifyFinishedCalled();
   const int imageWidthOnImageNotifyFinished =
       observer->imageWidthOnImageNotifyFinished();
   ASSERT_NE(imageWidth, imageWidthOnImageNotifyFinished);
 
   // Does Reload.
   imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
@@ skipping 294 matching lines @@
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest request = ResourceRequest(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   ImageResource* imageResource = ImageResource::create(request);
+  ImageResourceContent* content = imageResource->getContent();
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
   ResourceFetcher* fetcher = createFetcher();
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage),
                                     nullAtom);
   resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform",
                                       "empty-image");
 
   imageResource->responseReceived(resourceResponse, nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage),
                             sizeof(kJpegImage));
   imageResource->finish();
   EXPECT_FALSE(imageResource->errorOccurred());
-  ASSERT_TRUE(imageResource->getContent()->hasImage());
-  EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_FALSE(content->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(kJpegImageWidth, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(kJpegImageHeight,
-            imageResource->getContent()->getImage()->height());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(kJpegImageWidth, content->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight, content->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
-  imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
-                                                Resource::kReloadAlways);
+  ImageResource* reloadingResource =
+      imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
+                                                    Resource::kReloadAlways);
+  EXPECT_EQ(3, observer->imageChangedCount());
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
 
-  EXPECT_EQ(3, observer->imageChangedCount());
   testThatReloadIsStartedThenServeReload(
-      testURL, imageResource, imageResource->getContent(), observer.get(),
+      testURL, imageResource, reloadingResource, content, observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
   ResourceFetcher* fetcher = createFetcher();
 
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceRequest request = ResourceRequest(testURL);
@@ skipping 18 matching lines @@
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
                                             sizeof(kJpegImage));
 
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(imageResource, fetcher->cachedResource(testURL));
 
   fetcher->reloadLoFiImages();
 
   EXPECT_EQ(3, observer->imageChangedCount());
 
-  testThatReloadIsStartedThenServeReload(testURL, imageResource, content,
-                                         observer.get(),
-                                         WebCachePolicy::BypassingCache);
+  ImageResource* reloadingResource =
+      toImageResource(fetcher->cachedResource(testURL));
+  ASSERT_TRUE(reloadingResource);
+
+  testThatReloadIsStartedThenServeReload(
+      testURL, imageResource, reloadingResource, content, observer.get(),
+      WebCachePolicy::BypassingCache);
 
   memoryCache()->remove(imageResource);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceRequest request(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   FetchRequest fetchRequest(request, FetchInitiatorInfo());
   ResourceFetcher* fetcher = createFetcher();
 
   ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher);
+  ImageResourceContent* content = imageResource->getContent();
   std::unique_ptr<MockImageResourceObserver> observer =
-      MockImageResourceObserver::create(imageResource->getContent());
+      MockImageResourceObserver::create(content);
 
   // Send the image response.
   ResourceResponse initialResourceResponse(testURL, "image/jpeg",
                                            sizeof(kJpegImage), nullAtom);
   initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(initialResourceResponse));
   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());
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_FALSE(content->getImage()->isNull());
   EXPECT_EQ(1, observer->imageChangedCount());
   EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
-  EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(kJpegImageWidth, imageResource->getContent()->getImage()->width());
-  EXPECT_EQ(kJpegImageHeight,
-            imageResource->getContent()->getImage()->height());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(kJpegImageWidth, content->getImage()->width());
+  EXPECT_EQ(kJpegImageHeight, content->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() while the image is still loading.
-  imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
-                                                Resource::kReloadAlways);
+  ImageResource* reloadingResource =
+      imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
+                                                    Resource::kReloadAlways);
 
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
   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(),
+      testURL, imageResource, reloadingResource, content, observer.get(),
       WebCachePolicy::BypassingCache);
+
+  // Trigger the cancel timer, ensure the load for the first ImageResource
+  // was cancelled because reloading is started using another ImageResource.
+  EXPECT_EQ(ResourceStatus::Pending, imageResource->getStatus());
+  blink::testing::runPendingTasks();
+  EXPECT_EQ(ResourceStatus::LoadError, imageResource->getStatus());
 }
 
 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);
+  ImageResourceContent* content = imageResource->getContent();
+  ASSERT_TRUE(content);
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
-      MockImageResourceObserver::create(imageResource->getContent());
+      MockImageResourceObserver::create(content);
 
   testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
                                                observer.get());
 
-  imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
-                                                Resource::kReloadAlways);
+  ImageResource* reloadingResource =
+      imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
+                                                    Resource::kReloadAlways);
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
 
   testThatReloadIsStartedThenServeReload(
-      testURL, imageResource, imageResource->getContent(), observer.get(),
+      testURL, imageResource, reloadingResource, content, observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
 TEST(ImageResourceTest, SVGImage) {
   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,
@@ skipping 436 matching lines @@
   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());
+  ResourceFetcher* fetcher = createFetcher();
+  ImageResource* imageResource = ImageResource::fetch(request, fetcher);
+  ImageResourceContent* content = imageResource->getContent();
   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());
 
   const char kBadData[] = "notanimageresponse";
 
   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));
 
+  ImageResource* reloadingResource =
+      toImageResource(fetcher->cachedResource(testURL));
+  ASSERT_TRUE(reloadingResource);
+
   // The dimensions could not be extracted, so the full original image should be
   // loading.
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
-  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_EQ(1, observer->imageChangedCount());
 
   testThatReloadIsStartedThenServeReload(
-      testURL, imageResource, imageResource->getContent(), observer.get(),
+      testURL, imageResource, reloadingResource, content, observer.get(),
       WebCachePolicy::BypassingCache);
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
+  ResourceFetcher* fetcher = createFetcher();
+  ImageResource* imageResource = ImageResource::fetch(request, fetcher);
+  ImageResourceContent* content = imageResource->getContent();
   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());
 
   // TODO(hiroshige): Make the range request header and partial content length
   // consistent. https://crbug.com/689760.
@@ skipping 12 matching lines @@
       reinterpret_cast<const char*>(kJpegImage),
       kJpegImageSubrangeWithoutDimensionsLength);
 
   EXPECT_EQ(0, observer->imageChangedCount());
 
   imageResource->loader()->didFinishLoading(
       0.0, kJpegImageSubrangeWithoutDimensionsLength,
       kJpegImageSubrangeWithoutDimensionsLength);
 
   EXPECT_FALSE(observer->imageNotifyFinishedCalled());
-  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_EQ(1, observer->imageChangedCount());
+
+  ImageResource* reloadingResource =
+      toImageResource(fetcher->cachedResource(testURL));
+  ASSERT_TRUE(reloadingResource);
 
   testThatReloadIsStartedThenServeReload(
-      testURL, imageResource, imageResource->getContent(), observer.get(),
+      testURL, imageResource, reloadingResource, content, 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);
+  ImageResourceContent* content = imageResource->getContent();
   std::unique_ptr<MockImageResourceObserver> observer =
-      MockImageResourceObserver::create(imageResource->getContent());
+      MockImageResourceObserver::create(content);
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* imageResource2 =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer2 =
       MockImageResourceObserver::create(imageResource2->getContent());
 
   ImageResource* imageResource3 =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer3 =
@@ skipping 28 matching lines @@
 TEST(ImageResourceTest,
      FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceFetcher* fetcher = createFetcher();
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
+  ImageResourceContent* content = imageResource->getContent();
   std::unique_ptr<MockImageResourceObserver> observer =
-      MockImageResourceObserver::create(imageResource->getContent());
+      MockImageResourceObserver::create(content);
 
   testThatIsPlaceholderRequestAndServeResponse(testURL, imageResource,
                                                observer.get());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* imageResource2 =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer2 =
       MockImageResourceObserver::create(imageResource2->getContent());
 
@@ skipping 100 matching lines @@
         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);
 
+    // Reloading does not occur and loading finishes as DecodeError.
     EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
+    EXPECT_FALSE(imageResource->isLoading());
+    EXPECT_TRUE(imageResource->getContent());
     EXPECT_FALSE(imageResource->shouldShowPlaceholder());
   }
 }
 
 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, createFetcher());
+    ResourceFetcher* fetcher = createFetcher();
+    ImageResource* imageResource = ImageResource::fetch(request, fetcher);
+    ImageResourceContent* content = imageResource->getContent();
     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());
+        MockImageResourceObserver::create(content);
 
     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));
 
     EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
+    ImageResource* reloadingResource =
+        toImageResource(fetcher->cachedResource(testURL));
+    ASSERT_TRUE(reloadingResource);
+
     // The dimensions could not be extracted, and the response code was a 4xx
     // error, so the full original image should be loading.
     testThatReloadIsStartedThenServeReload(
-        testURL, imageResource, imageResource->getContent(), observer.get(),
+        testURL, imageResource, reloadingResource, content, observer.get(),
         WebCachePolicy::BypassingCache);
   }
 }
 
 TEST(ImageResourceTest, PeriodicFlushTest) {
   ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
       platform;
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest request = ResourceRequest(testURL);
@@ skipping 72 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