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 40 matching lines @@
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLResponse.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/Base64.h"
 #include <memory>
 
 namespace blink {
 
+// TODO(hiroshige): Cleanup variable names for ImageResource.
+// TODO(hiroshige): Cleanup usage of ImageResource::fetch(), create(), and
+// URLLoaderMock.
+
 namespace {
 
 // An image of size 1x1.
 const unsigned char kJpegImage[] = {
     0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46, 0x00, 0x01,
     0x01, 0x01, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x13,
     0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68,
     0x20, 0x47, 0x49, 0x4d, 0x50, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x05, 0x03,
     0x04, 0x04, 0x04, 0x03, 0x05, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06,
     0x07, 0x0c, 0x08, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x0b, 0x0b, 0x09, 0x0c,
@@ skipping 240 matching lines @@
 
   fetcher->startLoad(cachedImage);
   memoryCache()->add(cachedImage);
 
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
   EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
 
   // The load should still be alive, but a timer should be started to cancel the
   // load inside removeClient().
-  client->removeAsClient();
+  client->removeAsClientAndObserver();
   EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
   EXPECT_TRUE(memoryCache()->resourceForURL(testURL));
 
   // Trigger the cancel timer, ensure the load was cancelled and the resource
   // was evicted from the cache.
   blink::testing::runPendingTasks();
   EXPECT_EQ(Resource::LoadError, cachedImage->getStatus());
   EXPECT_FALSE(memoryCache()->resourceForURL(testURL));
 }
 
@@ skipping 26 matching lines @@
 
   // The prune comes when the ImageResource still has clients. The image should
   // not be deleted.
   cachedImage->prune();
   EXPECT_TRUE(cachedImage->isAlive());
   ASSERT_TRUE(cachedImage->getContent()->hasImage());
   EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
 
   // The ImageResource no longer has clients. The decoded image data should be
   // deleted by prune.
-  client->removeAsClient();
+  client->removeAsClientAndObserver();
   cachedImage->prune();
   EXPECT_FALSE(cachedImage->isAlive());
   EXPECT_TRUE(cachedImage->getContent()->hasImage());
   // TODO(hajimehoshi): Should check cachedImage doesn't have decoded image
   // data.
 }
 
 TEST(ImageResourceTest, UpdateBitmapImages) {
   ImageResource* cachedImage = ImageResource::create(ResourceRequest());
   cachedImage->setStatus(Resource::Pending);
@@ skipping 16 matching lines @@
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
   ResourceRequest request = ResourceRequest(testURL);
   request.setLoFiState(WebURLRequest::LoFiOn);
   ImageResource* cachedImage = ImageResource::create(request);
+  ImageResourceContent* content = cachedImage->getContent();
   cachedImage->setStatus(Resource::Pending);
 
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage),
                                     nullAtom, String());
   resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform",
                                       "empty-image");
 
   cachedImage->responseReceived(resourceResponse, nullptr);
   cachedImage->appendData(reinterpret_cast<const char*>(kJpegImage),
                           sizeof(kJpegImage));
   cachedImage->finish();
-  EXPECT_FALSE(cachedImage->errorOccurred());
-  ASSERT_TRUE(cachedImage->getContent()->hasImage());
-  EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
+  EXPECT_FALSE(content->errorOccurred());
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_FALSE(content->getImage()->isNull());
   EXPECT_EQ(2, client->imageChangedCount());
   EXPECT_EQ(1, client->imageNotifyFinishedCount());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
   // The client should have been notified that the image load completed.
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnNotifyFinished());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
-  EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, cachedImage->getContent()->getImage()->width());
-  EXPECT_EQ(1, cachedImage->getContent()->getImage()->height());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(1, content->getImage()->width());
+  EXPECT_EQ(1, content->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
-  cachedImage->reloadIfLoFiOrPlaceholderImage(fetcher, Resource::kReloadAlways);
-  EXPECT_FALSE(cachedImage->errorOccurred());
-  EXPECT_FALSE(cachedImage->resourceBuffer());
-  EXPECT_FALSE(cachedImage->getContent()->hasImage());
+  ImageResource* reloadingResource =
+      cachedImage->reloadIfLoFiOrPlaceholderImage(fetcher,
+                                                  Resource::kReloadAlways);
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_NE(cachedImage, reloadingResource);
+  EXPECT_EQ(content, reloadingResource->getContent());
+  EXPECT_FALSE(cachedImage->getContent());
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
+  EXPECT_EQ(reloadingResource, memoryCache()->resourceForURL(testURL));
+  EXPECT_FALSE(reloadingResource->isPlaceholder());
+
+  EXPECT_FALSE(content->errorOccurred());
+  EXPECT_TRUE(content->hasImage());
+  EXPECT_EQ(2, client->imageChangedCount());
+  EXPECT_EQ(1, client->imageNotifyFinishedCount());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(1, content->getImage()->width());
+  EXPECT_EQ(1, content->getImage()->height());
+
+  reloadingResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(resourceResponse), nullptr);
+  reloadingResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
+  reloadingResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
+                                                sizeof(kJpegImage2));
+  EXPECT_FALSE(content->errorOccurred());
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_FALSE(content->getImage()->isNull());
   EXPECT_EQ(3, client->imageChangedCount());
+  EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnLastImageChanged());
+
+  // The observer should not have been notified of completion again.
   EXPECT_EQ(1, client->imageNotifyFinishedCount());
+  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
+
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(50, content->getImage()->width());
+  EXPECT_EQ(50, content->getImage()->height());
+}
+
+TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
+  ResourceFetcher* fetcher =
+      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+
+  KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
+
+  ResourceRequest request = ResourceRequest(testURL);
+  request.setLoFiState(WebURLRequest::LoFiOn);
+  FetchRequest fetchRequest(request, FetchInitiatorInfo());
+  ImageResource* cachedImage = ImageResource::fetch(fetchRequest, fetcher);
+  ImageResourceContent* content = cachedImage->getContent();
+
+  Persistent<MockImageResourceClient> client =
+      new MockImageResourceClient(cachedImage);
+
+  // Send the image response.
+  ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage),
+                                    nullAtom, String());
+  resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform",
+                                      "empty-image");
 
   cachedImage->loader()->didReceiveResponse(
-      WrappedResourceResponse(resourceResponse), nullptr);
+      WrappedResourceResponse(resourceResponse));
   cachedImage->loader()->didReceiveData(
-      reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
-  cachedImage->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
-                                          sizeof(kJpegImage2));
-  EXPECT_FALSE(cachedImage->errorOccurred());
-  ASSERT_TRUE(cachedImage->getContent()->hasImage());
-  EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
-  EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnLastImageChanged());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+      reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
+  cachedImage->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
+                                          sizeof(kJpegImage));
 
-  // The client should not have been notified of completion again.
-  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnNotifyFinished());
-  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
+  EXPECT_EQ(cachedImage, fetcher->cachedResource(testURL));
+  fetcher->reloadLoFiImages();
+  const ImageResource* reloadingResource = content->resourceForTest();
 
-  EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(50, cachedImage->getContent()->getImage()->width());
-  EXPECT_EQ(50, cachedImage->getContent()->getImage()->height());
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_NE(cachedImage, reloadingResource);
+  EXPECT_EQ(content, reloadingResource->getContent());
+  EXPECT_FALSE(cachedImage->getContent());
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
+  EXPECT_EQ(reloadingResource, memoryCache()->resourceForURL(testURL));
+  EXPECT_FALSE(reloadingResource->isPlaceholder());
+
+  reloadingResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceRequest request(testURL);
   request.setLoFiState(WebURLRequest::LoFiOn);
   FetchRequest fetchRequest(request, FetchInitiatorInfo());
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   ImageResource* cachedImage = ImageResource::fetch(fetchRequest, fetcher);
+  ImageResourceContent* content = cachedImage->getContent();
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
 
+  // To test that the old ImageResource is cancelled if it has no
+  // ResourceClient when reloading is started, we remove |client| as client
+  // here, but not as observer.
+  client->removeAsClient();
+
   // Send the image response.
   ResourceResponse initialResourceResponse(
       testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String());
   initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   cachedImage->loader()->didReceiveResponse(
       WrappedResourceResponse(initialResourceResponse));
   cachedImage->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
 
-  EXPECT_FALSE(cachedImage->errorOccurred());
-  ASSERT_TRUE(cachedImage->getContent()->hasImage());
-  EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
+  EXPECT_FALSE(content->errorOccurred());
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_FALSE(content->getImage()->isNull());
   EXPECT_EQ(1, client->imageChangedCount());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
-  EXPECT_FALSE(client->notifyFinishedCalled());
-  EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(1, cachedImage->getContent()->getImage()->width());
-  EXPECT_EQ(1, cachedImage->getContent()->getImage()->height());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(1, content->getImage()->width());
+  EXPECT_EQ(1, content->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() while the image is still loading.
-  cachedImage->reloadIfLoFiOrPlaceholderImage(fetcher, Resource::kReloadAlways);
-  EXPECT_FALSE(cachedImage->errorOccurred());
-  EXPECT_FALSE(cachedImage->resourceBuffer());
-  EXPECT_FALSE(cachedImage->getContent()->hasImage());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(0U, client->encodedSizeOnLastImageChanged());
+  ImageResource* reloadingResource =
+      cachedImage->reloadIfLoFiOrPlaceholderImage(fetcher,
+                                                  Resource::kReloadAlways);
+
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_NE(cachedImage, reloadingResource);
+  EXPECT_EQ(content, reloadingResource->getContent());
+  EXPECT_FALSE(cachedImage->getContent());
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
+  EXPECT_EQ(reloadingResource, memoryCache()->resourceForURL(testURL));
+  EXPECT_FALSE(reloadingResource->isPlaceholder());
+
+  EXPECT_FALSE(content->errorOccurred());
+  // ImageResourceContent is not notified of the start of LoFi reloading.
+  EXPECT_TRUE(content->hasImage());
+  EXPECT_EQ(1, client->imageChangedCount());
+  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
+  EXPECT_EQ(1, content->getImage()->width());
+  EXPECT_EQ(1, content->getImage()->height());
   // The client should not have been notified of completion yet, since the image
   // is still loading.
-  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_EQ(0, client->imageNotifyFinishedCount());
 
-  cachedImage->loader()->didReceiveResponse(
+  reloadingResource->loader()->didReceiveResponse(
       WrappedResourceResponse(ResourceResponse(
           testURL, "image/jpeg", sizeof(kJpegImage2), nullAtom, String())),
       nullptr);
-  cachedImage->loader()->didReceiveData(
+  reloadingResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
-  cachedImage->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
-                                          sizeof(kJpegImage2));
+  reloadingResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
+                                                sizeof(kJpegImage2));
 
-  EXPECT_FALSE(cachedImage->errorOccurred());
-  ASSERT_TRUE(cachedImage->getContent()->hasImage());
-  EXPECT_FALSE(cachedImage->getContent()->getImage()->isNull());
+  EXPECT_FALSE(content->errorOccurred());
+  // ImageResourceContent is notified of reloaded response.
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_EQ(1, client->imageNotifyFinishedCount());
+  EXPECT_EQ(2, client->imageChangedCount());
+  EXPECT_FALSE(content->getImage()->isNull());
   EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnLastImageChanged());
-  // The client should have been notified of completion only after the reload
+  // The observer should have been notified of completion only after the reload
   // completed.
-  EXPECT_TRUE(client->notifyFinishedCalled());
-  EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnNotifyFinished());
   EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnImageNotifyFinished());
-  EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
-  EXPECT_EQ(50, cachedImage->getContent()->getImage()->width());
-  EXPECT_EQ(50, cachedImage->getContent()->getImage()->height());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
+  EXPECT_EQ(50, content->getImage()->width());
+  EXPECT_EQ(50, content->getImage()->height());
+
+  // Trigger the cancel timer, ensure the load for the first ImageResource
+  // was cancelled because reloading is started using another ImageResource.
+  EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
+  blink::testing::runPendingTasks();
+  EXPECT_EQ(Resource::LoadError, cachedImage->getStatus());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* image = ImageResource::fetch(request, fetcher);
+  ImageResourceContent* content = image->getContent();
+  ASSERT_TRUE(content);
+  Persistent<MockImageResourceClient> client =
+      new MockImageResourceClient(image);
+
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047", image->resourceRequest().httpHeaderField("range"));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(image);
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom,
                             String());
   response.setHTTPStatusCode(206);
   response.setHTTPHeaderField(
       "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
                                          sizeof(kJpegImage)));
   image->loader()->didReceiveResponse(WrappedResourceResponse(response));
   image->loader()->didReceiveData(reinterpret_cast<const char*>(kJpegImage),
                                   kJpegImageSubrangeWithDimensionsLength);
   image->loader()->didFinishLoading(0.0, kJpegImageSubrangeWithDimensionsLength,
                                     kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(Resource::Cached, image->getStatus());
   EXPECT_TRUE(image->isPlaceholder());
 
-  image->reloadIfLoFiOrPlaceholderImage(fetcher, Resource::kReloadAlways);
+  ImageResource* reloadingResource =
+      image->reloadIfLoFiOrPlaceholderImage(fetcher, Resource::kReloadAlways);
 
-  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()));
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_NE(image, reloadingResource);
+  EXPECT_EQ(content, reloadingResource->getContent());
+  EXPECT_FALSE(image->getContent());
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
+  EXPECT_EQ(reloadingResource, memoryCache()->resourceForURL(testURL));
+  EXPECT_FALSE(reloadingResource->isPlaceholder());
 
-  image->loader()->cancel();
+  EXPECT_EQ(Resource::Pending, content->getStatus());
+  EXPECT_EQ(nullAtom,
+            reloadingResource->resourceRequest().httpHeaderField("range"));
+  EXPECT_EQ(
+      static_cast<int>(WebCachePolicy::BypassingCache),
+      static_cast<int>(reloadingResource->resourceRequest().getCachePolicy()));
+
+  reloadingResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, SVGImage) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(imageResource);
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
@@ skipping 414 matching lines @@
   EXPECT_FALSE(image->getContent()->getImage()->isBitmapImage());
   EXPECT_FALSE(image->getContent()->getImage()->isSVGImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   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()));
+  ResourceFetcher* fetcher =
+      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ImageResource* image = ImageResource::fetch(request, fetcher);
+  ImageResourceContent* content = image->getContent();
   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())));
   image->loader()->didReceiveData(kBadData, sizeof(kBadData));
 
+  const ImageResource* reloadingResource = content->resourceForTest();
+
+  ASSERT_TRUE(reloadingResource);
+  EXPECT_NE(image, reloadingResource);
+  EXPECT_EQ(content, reloadingResource->getContent());
+  EXPECT_FALSE(image->getContent());
+  EXPECT_EQ(reloadingResource, fetcher->cachedResource(testURL));
+  EXPECT_EQ(reloadingResource, memoryCache()->resourceForURL(testURL));
+  EXPECT_FALSE(reloadingResource->isPlaceholder());
+
   // 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(Resource::Pending, content->getStatus());
+  EXPECT_EQ(nullAtom,
+            reloadingResource->resourceRequest().httpHeaderField("range"));
+  EXPECT_EQ(
+      static_cast<int>(WebCachePolicy::BypassingCache),
+      static_cast<int>(reloadingResource->resourceRequest().getCachePolicy()));
   EXPECT_EQ(0, client->imageNotifyFinishedCount());
 
-  image->loader()->didReceiveResponse(WrappedResourceResponse(ResourceResponse(
-      testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
-  image->loader()->didReceiveData(reinterpret_cast<const char*>(kJpegImage),
-                                  sizeof(kJpegImage));
-  image->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
-                                    sizeof(kJpegImage));
+  reloadingResource->loader()->didReceiveResponse(
+      WrappedResourceResponse(ResourceResponse(
+          testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
+  reloadingResource->loader()->didReceiveData(
+      reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
+  reloadingResource->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_EQ(Resource::Cached, content->getStatus());
+  EXPECT_EQ(sizeof(kJpegImage), reloadingResource->encodedSize());
+  EXPECT_FALSE(reloadingResource->isPlaceholder());
   EXPECT_LT(0, client->imageChangedCount());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
-  EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnNotifyFinished());
   EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
 
-  ASSERT_TRUE(image->getContent()->hasImage());
-  EXPECT_EQ(1, image->getContent()->getImage()->width());
-  EXPECT_EQ(1, image->getContent()->getImage()->height());
-  EXPECT_TRUE(image->getContent()->getImage()->isBitmapImage());
+  ASSERT_TRUE(content->hasImage());
+  EXPECT_EQ(1, content->getImage()->width());
+  EXPECT_EQ(1, content->getImage()->height());
+  EXPECT_TRUE(content->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* image = ImageResource::fetch(placeholderRequest, fetcher);
+  ImageResourceContent* content = image->getContent();
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(image);
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImage =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
-  EXPECT_EQ(image, secondImage);
-  EXPECT_EQ(Resource::Pending, image->getStatus());
-  EXPECT_FALSE(image->isPlaceholder());
-  EXPECT_EQ(nullAtom, image->resourceRequest().httpHeaderField("range"));
+  EXPECT_NE(image, secondImage);
+  ASSERT_EQ(secondImage, content->resourceForTest());
+  EXPECT_EQ(secondImage, memoryCache()->resourceForURL(testURL));
+  EXPECT_EQ(content, secondImage->getContent());
+  EXPECT_EQ(Resource::Pending, content->getStatus());
+  EXPECT_FALSE(secondImage->isPlaceholder());
+  EXPECT_EQ(nullAtom, secondImage->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
-            static_cast<int>(image->resourceRequest().getCachePolicy()));
+            static_cast<int>(secondImage->resourceRequest().getCachePolicy()));
   EXPECT_FALSE(client->notifyFinishedCalled());
 
   image->loader()->cancel();
+  secondImage->loader()->cancel();
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* image = ImageResource::fetch(placeholderRequest, fetcher);
+  ImageResourceContent* content = image->getContent();
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(image);
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom,
                             String());
   response.setHTTPStatusCode(206);
   response.setHTTPHeaderField(
       "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
                                          sizeof(kJpegImage)));
   image->loader()->didReceiveResponse(WrappedResourceResponse(response));
   image->loader()->didReceiveData(reinterpret_cast<const char*>(kJpegImage),
                                   kJpegImageSubrangeWithDimensionsLength);
   image->loader()->didFinishLoading(0.0, kJpegImageSubrangeWithDimensionsLength,
                                     kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(Resource::Cached, image->getStatus());
   EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength, image->encodedSize());
   EXPECT_TRUE(image->isPlaceholder());
   EXPECT_LT(0, client->imageChangedCount());
   EXPECT_TRUE(client->notifyFinishedCalled());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImage =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
-  EXPECT_EQ(image, secondImage);
-  EXPECT_EQ(Resource::Pending, image->getStatus());
-  EXPECT_FALSE(image->isPlaceholder());
-  EXPECT_EQ(nullAtom, image->resourceRequest().httpHeaderField("range"));
+  EXPECT_FALSE(image->getContent());
+  EXPECT_NE(image, secondImage);
+  EXPECT_EQ(secondImage, memoryCache()->resourceForURL(testURL));
+  ASSERT_EQ(secondImage, content->resourceForTest());
+  EXPECT_EQ(content, secondImage->getContent());
+  EXPECT_EQ(Resource::Pending, content->getStatus());
+  EXPECT_FALSE(secondImage->isPlaceholder());
+  EXPECT_EQ(nullAtom, secondImage->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
-            static_cast<int>(image->resourceRequest().getCachePolicy()));
+            static_cast<int>(secondImage->resourceRequest().getCachePolicy()));
 
-  image->loader()->cancel();
+  secondImage->loader()->cancel();
 }
 
 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);
@@ skipping 70 matching lines @@
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_TRUE(cachedImage->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, cachedImage->getContent()->getImage()->width());
   EXPECT_EQ(50, cachedImage->getContent()->getImage()->height());
 
   WTF::setTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink