Wait to notify completion until after a Lo-Fi image is reloaded.

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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/fetch/ImageResource.h"
 
+#include "core/fetch/FetchInitiatorInfo.h"
+#include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/MockResourceClients.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/UniqueIdentifier.h"
 #include "platform/SharedBuffer.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/graphics/Image.h"
 #include "platform/scheduler/test/fake_web_task_runner.h"
 #include "platform/testing/URLTestHelpers.h"
@@ skipping 112 matching lines @@
                      const Vector<unsigned char>& data) {
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setMimeType(mimeType);
   imageResource->responseReceived(response, nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(data.data()),
                             data.size());
   imageResource->finish();
 }
-}
 
 class ImageResourceTestMockFetchContext : public FetchContext {
  public:
   static ImageResourceTestMockFetchContext* create() {
     return new ImageResourceTestMockFetchContext;
   }
 
   virtual ~ImageResourceTestMockFetchContext() {}
 
   bool allowImage(bool imagesEnabled, const KURL&) const override {
@@ skipping 10 matching lines @@
   bool shouldLoadNewResource(Resource::Type) const override { return true; }
   WebTaskRunner* loadingTaskRunner() const override { return m_runner.get(); }
 
  private:
   ImageResourceTestMockFetchContext()
       : m_runner(wrapUnique(new scheduler::FakeWebTaskRunner)) {}
 
   std::unique_ptr<scheduler::FakeWebTaskRunner> m_runner;
 };
 
+// Convenience class that registers a mocked URL load on construction, and
+// unregisters it on destruction. This allows for a test to use constructs like
+// ASSERT_TRUE() without needing to worry about unregistering the mocked URL
+// load to avoid putting other tests into inconsistent states in case the
+// assertion fails.
+class ScopedRegisteredURL {
+ public:
+  ScopedRegisteredURL(const KURL& url,
+                      const String& fileName = "cancelTest.html",
+                      const String& mimeType = "text/html")
+      : m_url(url) {
+    URLTestHelpers::registerMockedURLLoad(m_url, fileName, mimeType);
+  }
+
+  ~ScopedRegisteredURL() {
+    Platform::current()->getURLLoaderMockFactory()->unregisterURL(m_url);
+  }
+
+ private:
+  KURL m_url;
+};
+
+}  // namespace
+
 TEST(ImageResourceTest, MultipartImage) {
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
-  URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
-                                        "text/html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   // Emulate starting a real load, but don't expect any "real"
   // WebURLLoaderClient callbacks.
   ImageResource* cachedImage = ImageResource::create(ResourceRequest(testURL));
   cachedImage->setIdentifier(createUniqueIdentifier());
   fetcher->startLoad(cachedImage);
-  Platform::current()->getURLLoaderMockFactory()->unregisterURL(testURL);
 
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
   EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
 
   // Send the multipart response. No image or data buffer is created. Note that
   // the response must be routed through ResourceLoader to ensure the load is
   // flagged as multipart.
   ResourceResponse multipartResponse(KURL(), "multipart/x-mixed-replace", 0,
                                      nullAtom, String());
@@ skipping 51 matching lines @@
   EXPECT_EQ(1, cachedImage->getImage()->width());
   EXPECT_EQ(1, cachedImage->getImage()->height());
   EXPECT_EQ(1, client->imageChangedCount());
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_EQ(1, client2->imageChangedCount());
   EXPECT_TRUE(client2->notifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDetach) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
-  URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
-                                        "text/html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   // Emulate starting a real load.
   ImageResource* cachedImage = ImageResource::create(ResourceRequest(testURL));
   cachedImage->setIdentifier(createUniqueIdentifier());
 
   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();
   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));
-
-  Platform::current()->getURLLoaderMockFactory()->unregisterURL(testURL);
 }
 
 TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients) {
   ImageResource* cachedImage = ImageResource::create(ResourceRequest());
   cachedImage->setStatus(Resource::Pending);
 
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
 
   // Send the image response.
@@ skipping 47 matching lines @@
                           jpeg.size());
   cachedImage->finish();
   EXPECT_FALSE(cachedImage->errorOccurred());
   ASSERT_TRUE(cachedImage->hasImage());
   EXPECT_FALSE(cachedImage->getImage()->isNull());
   EXPECT_EQ(2, client->imageChangedCount());
   EXPECT_TRUE(client->notifyFinishedCalled());
   EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
 }
 
-TEST(ImageResourceTest, ReloadIfLoFi) {
+TEST(ImageResourceTest, ReloadIfLoFiAfterFinished) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
-  URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
-                                        "text/html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
   ResourceRequest request = ResourceRequest(testURL);
   request.setLoFiState(WebURLRequest::LoFiOn);
   ImageResource* cachedImage = ImageResource::create(request);
   cachedImage->setStatus(Resource::Pending);
 
   Persistent<MockImageResourceClient> client =
       new MockImageResourceClient(cachedImage);
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   // Send the image response.
   Vector<unsigned char> jpeg = jpegImage();
   ResourceResponse resourceResponse(KURL(), "image/jpeg", jpeg.size(), nullAtom,
                                     String());
   resourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   cachedImage->responseReceived(resourceResponse, nullptr);
   cachedImage->appendData(reinterpret_cast<const char*>(jpeg.data()),
                           jpeg.size());
   cachedImage->finish();
   EXPECT_FALSE(cachedImage->errorOccurred());
   ASSERT_TRUE(cachedImage->hasImage());
   EXPECT_FALSE(cachedImage->getImage()->isNull());
   EXPECT_EQ(2, client->imageChangedCount());
+  EXPECT_EQ(jpeg.size(), client->encodedSizeOnLastImageChanged());
+  // The client should have been notified that the image load completed.
   EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(jpeg.size(), client->encodedSizeOnNotifyFinished());
+  EXPECT_EQ(jpeg.size(), client->encodedSizeOnImageNotifyFinished());
   EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
   EXPECT_EQ(1, cachedImage->getImage()->width());
   EXPECT_EQ(1, cachedImage->getImage()->height());
 
+  // Call reloadIfLoFi() after the image has finished loading.
   cachedImage->reloadIfLoFi(fetcher);
   EXPECT_FALSE(cachedImage->errorOccurred());
   EXPECT_FALSE(cachedImage->resourceBuffer());
   EXPECT_FALSE(cachedImage->hasImage());
   EXPECT_EQ(3, client->imageChangedCount());
 
   Vector<unsigned char> jpeg2 = jpegImage2();
   cachedImage->loader()->didReceiveResponse(
       nullptr, WrappedResourceResponse(resourceResponse), nullptr);
   cachedImage->loader()->didReceiveData(
       nullptr, reinterpret_cast<const char*>(jpeg2.data()), jpeg2.size(),
       jpeg2.size(), jpeg2.size());
   cachedImage->loader()->didFinishLoading(nullptr, 0.0, jpeg2.size());
   EXPECT_FALSE(cachedImage->errorOccurred());
   ASSERT_TRUE(cachedImage->hasImage());
   EXPECT_FALSE(cachedImage->getImage()->isNull());
+  EXPECT_EQ(jpeg2.size(), client->encodedSizeOnLastImageChanged());
   EXPECT_TRUE(client->notifyFinishedCalled());
+  // The client should not have been notified of completion again.
+  EXPECT_EQ(jpeg.size(), client->encodedSizeOnNotifyFinished());
+  EXPECT_EQ(jpeg.size(), client->encodedSizeOnImageNotifyFinished());
   EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
   EXPECT_EQ(50, cachedImage->getImage()->width());
   EXPECT_EQ(50, cachedImage->getImage()->height());
+}
+
+TEST(ImageResourceTest, ReloadIfLoFiDuringFetch) {
+  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);
+  Persistent<MockImageResourceClient> client =
+      new MockImageResourceClient(cachedImage);
+
+  // Send the image response.
+  Vector<unsigned char> jpeg = jpegImage();
+
+  ResourceResponse initialResourceResponse(testURL, "image/jpeg", jpeg.size(),
+                                           nullAtom, String());
+  initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
+
+  cachedImage->loader()->didReceiveResponse(
+      nullptr, WrappedResourceResponse(initialResourceResponse));
+  cachedImage->loader()->didReceiveData(
+      nullptr, reinterpret_cast<const char*>(jpeg.data()), jpeg.size(),
+      jpeg.size(), jpeg.size());
+
+  EXPECT_FALSE(cachedImage->errorOccurred());
+  ASSERT_TRUE(cachedImage->hasImage());
+  EXPECT_FALSE(cachedImage->getImage()->isNull());
+  EXPECT_EQ(1, client->imageChangedCount());
+  EXPECT_EQ(jpeg.size(), client->encodedSizeOnLastImageChanged());
+  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
+  EXPECT_EQ(1, cachedImage->getImage()->width());
+  EXPECT_EQ(1, cachedImage->getImage()->height());
+
+  // Call reloadIfLoFi() while the image is still loading.
+  cachedImage->reloadIfLoFi(fetcher);
+  EXPECT_FALSE(cachedImage->errorOccurred());
+  EXPECT_FALSE(cachedImage->resourceBuffer());
+  EXPECT_FALSE(cachedImage->hasImage());
+  EXPECT_EQ(2, client->imageChangedCount());
+  EXPECT_EQ(0U, client->encodedSizeOnLastImageChanged());
+  // The client should not have been notified of completion yet, since the image
+  // is still loading.
+  EXPECT_FALSE(client->notifyFinishedCalled());
+
+  Vector<unsigned char> jpeg2 = jpegImage2();
+  cachedImage->loader()->didReceiveResponse(
+      nullptr, WrappedResourceResponse(ResourceResponse(
+                   testURL, "image/jpeg", jpeg.size(), nullAtom, String())),
+      nullptr);
+  cachedImage->loader()->didReceiveData(
+      nullptr, reinterpret_cast<const char*>(jpeg2.data()), jpeg2.size(),
+      jpeg2.size(), jpeg2.size());
+  cachedImage->loader()->didFinishLoading(nullptr, 0.0, jpeg2.size());
+
+  EXPECT_FALSE(cachedImage->errorOccurred());
+  ASSERT_TRUE(cachedImage->hasImage());
+  EXPECT_FALSE(cachedImage->getImage()->isNull());
+  EXPECT_EQ(jpeg2.size(), client->encodedSizeOnLastImageChanged());
+  // The client should have been notified of completion only after the reload
+  // completed.
+  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(jpeg2.size(), client->encodedSizeOnNotifyFinished());
+  EXPECT_EQ(jpeg2.size(), client->encodedSizeOnImageNotifyFinished());
+  EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
+  EXPECT_EQ(50, cachedImage->getImage()->width());
+  EXPECT_EQ(50, cachedImage->getImage()->height());
 }
 
 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", svgImage());
 
@@ skipping 225 matching lines @@
 
   ASSERT_TRUE(imageResource->hasImage());
   EXPECT_FALSE(imageResource->getImage()->isNull());
   EXPECT_EQ(1, imageResource->getImage()->width());
   EXPECT_EQ(1, imageResource->getImage()->height());
   EXPECT_TRUE(client2->notifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDecodeError) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
-  URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
-                                        "text/html");
+  ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* cachedImage = ImageResource::fetch(request, fetcher);
-  Platform::current()->getURLLoaderMockFactory()->unregisterURL(testURL);
 
   cachedImage->loader()->didReceiveResponse(
       nullptr, WrappedResourceResponse(ResourceResponse(
                    testURL, "image/jpeg", 18, nullAtom, String())),
       nullptr);
   cachedImage->loader()->didReceiveData(nullptr, "notactuallyanimage", 18, 18,
                                         18);
   EXPECT_EQ(Resource::DecodeError, cachedImage->getStatus());
   EXPECT_FALSE(cachedImage->isLoading());
 }
 
 }  // namespace blink