Replace MockImageResourceClient with MockImageResourceObserver

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 19 matching lines @@
 
 #include "core/loader/resource/ImageResource.h"
 
 #include "core/fetch/FetchInitiatorInfo.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/MockResourceClient.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/UniqueIdentifier.h"
-#include "core/loader/resource/MockImageResourceClient.h"
+#include "core/loader/resource/MockImageResourceObserver.h"
 #include "platform/SharedBuffer.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/Image.h"
 #include "platform/scheduler/test/fake_web_task_runner.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
@@ skipping 31 matching lines @@
     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0xc4, 0x00, 0x14, 0x10, 0x01, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0xff, 0xc4, 0x00, 0x14, 0x01, 0x01, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0xff, 0xc4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
     0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f,
     0x00, 0xb2, 0xc0, 0x07, 0xff, 0xd9};
 
-const size_t kJpegImageSubrangeWithDimensionsLength = sizeof(kJpegImage) - 1;
+constexpr int kJpegImageWidth = 1;
+
+constexpr size_t kJpegImageSubrangeWithDimensionsLength =
+    sizeof(kJpegImage) - 1;
 
 // Ensure that the image decoder can determine the dimensions of kJpegImage from
 // just the first kJpegImageSubrangeWithDimensionsLength bytes. If this test
 // fails, then the test data here probably needs to be updated.
 TEST(ImageResourceTest, DimensionsDecodableFromPartialTestImage) {
   RefPtr<Image> image = BitmapImage::create();
   EXPECT_EQ(
       Image::SizeAvailable,
       image->setData(SharedBuffer::create(
                          kJpegImage, kJpegImageSubrangeWithDimensionsLength),
@@ skipping 25 matching lines @@
     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc4, 0x00, 0x15, 0x01, 0x01, 0x01,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0xff, 0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03,
     0x11, 0x00, 0x3f, 0x00, 0x00, 0x94, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xd9};
 
+constexpr int kJpegImage2Width = 50;
+
 const char kSvgImage[] =
     "<svg width=\"200\" height=\"200\" xmlns=\"http://www.w3.org/2000/svg\" "
     "xmlns:xlink=\"http://www.w3.org/1999/xlink\">"
     "<rect x=\"0\" y=\"0\" width=\"100px\" height=\"100px\" fill=\"red\"/>"
     "</svg>";
 
 const char kSvgImage2[] =
     "<svg width=\"300\" height=\"300\" xmlns=\"http://www.w3.org/2000/svg\" "
     "xmlns:xlink=\"http://www.w3.org/1999/xlink\">"
     "<rect x=\"0\" y=\"0\" width=\"200px\" height=\"200px\" fill=\"green\"/>"
@@ skipping 76 matching lines @@
   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.
   ImageResource* imageResource =
       ImageResource::create(ResourceRequest(testURL));
   imageResource->setIdentifier(createUniqueIdentifier());
   fetcher->startLoad(imageResource);
 
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
   EXPECT_EQ(Resource::Pending, imageResource->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());
   multipartResponse.setMultipartBoundary("boundary", strlen("boundary"));
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(multipartResponse), nullptr);
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(0, client->imageChangedCount());
-  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_EQ(0, observer->imageChangedCount());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ("multipart/x-mixed-replace", imageResource->response().mimeType());
 
   const char firstPart[] =
       "--boundary\n"
       "Content-Type: image/svg+xml\n\n";
   imageResource->appendData(firstPart, strlen(firstPart));
   // Send the response for the first real part. No image or data buffer is
   // created.
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(0, client->imageChangedCount());
-  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_EQ(0, observer->imageChangedCount());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ("image/svg+xml", imageResource->response().mimeType());
 
   const char secondPart[] =
       "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'><rect "
       "width='1' height='1' fill='green'/></svg>\n";
   // The first bytes arrive. The data buffer is created, but no image is
   // created.
   imageResource->appendData(secondPart, strlen(secondPart));
   EXPECT_TRUE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(0, client->imageChangedCount());
-  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_EQ(0, observer->imageChangedCount());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
-  // Add a client to check an assertion error doesn't happen
+  // Add an observer to check an assertion error doesn't happen
   // (crbug.com/630983).
-  Persistent<MockImageResourceClient> client2 =
-      new MockImageResourceClient(imageResource);
-  EXPECT_EQ(0, client2->imageChangedCount());
-  EXPECT_FALSE(client2->notifyFinishedCalled());
+  std::unique_ptr<MockImageResourceObserver> observer2 =
+      MockImageResourceObserver::create(imageResource->getContent());
+  EXPECT_EQ(0, observer2->imageChangedCount());
+  EXPECT_FALSE(observer2->imageNotifyFinishedCalled());
 
   const char thirdPart[] = "--boundary";
   imageResource->appendData(thirdPart, strlen(thirdPart));
   ASSERT_TRUE(imageResource->resourceBuffer());
   EXPECT_EQ(strlen(secondPart) - 1, imageResource->resourceBuffer()->size());
 
   // This part finishes. The image is created, callbacks are sent, and the data
   // buffer is cleared.
   imageResource->loader()->didFinishLoading(0.0, 0, 0);
   EXPECT_TRUE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
-  EXPECT_EQ(1, client2->imageChangedCount());
-  EXPECT_TRUE(client2->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(1, observer2->imageChangedCount());
+  EXPECT_TRUE(observer2->imageNotifyFinishedCalled());
 }
 
-TEST(ImageResourceTest, CancelOnDetach) {
+TEST(ImageResourceTest, CancelOnRemoveObserver) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   // Emulate starting a real load.
   ImageResource* imageResource =
       ImageResource::create(ResourceRequest(testURL));
   imageResource->setIdentifier(createUniqueIdentifier());
 
   fetcher->startLoad(imageResource);
   memoryCache()->add(imageResource);
 
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
   EXPECT_EQ(Resource::Pending, imageResource->getStatus());
 
   // The load should still be alive, but a timer should be started to cancel the
   // load inside removeClient().
-  client->removeAsClient();
+  observer->removeAsObserver();
   EXPECT_EQ(Resource::Pending, imageResource->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, imageResource->getStatus());
   EXPECT_FALSE(memoryCache()->resourceForURL(testURL));
 }
 
 TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients) {
   ImageResource* imageResource = ImageResource::create(ResourceRequest());
   imageResource->setStatus(Resource::Pending);
 
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   imageResource->responseReceived(
       ResourceResponse(KURL(), "multipart/x-mixed-replace", 0, nullAtom,
                        String()),
       nullptr);
 
   imageResource->responseReceived(
       ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), nullAtom,
                        String()),
       nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage),
                             sizeof(kJpegImage));
   EXPECT_NE(0u, imageResource->encodedSizeMemoryUsageForTesting());
   imageResource->finish();
   EXPECT_EQ(0u, imageResource->encodedSizeMemoryUsageForTesting());
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
 
-  // The prune comes when the ImageResource still has clients. The image should
-  // not be deleted.
+  // The prune comes when the ImageResource still has observers. The image
+  // should not be deleted.
   imageResource->prune();
   EXPECT_TRUE(imageResource->isAlive());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
 
-  // The ImageResource no longer has clients. The decoded image data should be
+  // The ImageResource no longer has observers. The decoded image data should be
   // deleted by prune.
-  client->removeAsClient();
+  observer->removeAsObserver();
   imageResource->prune();
   EXPECT_FALSE(imageResource->isAlive());
   EXPECT_TRUE(imageResource->getContent()->hasImage());
   // TODO(hajimehoshi): Should check imageResource doesn't have decoded image
   // data.
 }
 
 TEST(ImageResourceTest, UpdateBitmapImages) {
   ImageResource* imageResource = ImageResource::create(ResourceRequest());
   imageResource->setStatus(Resource::Pending);
 
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   imageResource->responseReceived(
       ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), nullAtom,
                        String()),
       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());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
   ResourceRequest request = ResourceRequest(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   ImageResource* imageResource = ImageResource::create(request);
   imageResource->setStatus(Resource::Pending);
 
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
   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");
 
   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());
-  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_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(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
                                                 Resource::kReloadAlways);
   EXPECT_FALSE(imageResource->errorOccurred());
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(3, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
+  EXPECT_EQ(3, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(resourceResponse), nullptr);
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
                                             sizeof(kJpegImage2));
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnLastImageChanged());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(kJpegImage2Width, observer->imageWidthOnLastImageChanged());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
 
-  // The client should not have been notified of completion again.
-  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnNotifyFinished());
-  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnImageNotifyFinished());
+  // The observer should not have been notified of completion again.
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   ScopedRegisteredURL scopedRegisteredURL(testURL);
 
   ResourceRequest request(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   FetchRequest fetchRequest(request, FetchInitiatorInfo());
   ResourceFetcher* fetcher =
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
 
   ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher);
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   ResourceResponse initialResourceResponse(
       testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String());
   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());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_EQ(sizeof(kJpegImage), client->encodedSizeOnLastImageChanged());
-  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 
   // Call reloadIfLoFiOrPlaceholderImage() while the image is still loading.
   imageResource->reloadIfLoFiOrPlaceholderImage(fetcher,
                                                 Resource::kReloadAlways);
   EXPECT_FALSE(imageResource->errorOccurred());
   EXPECT_FALSE(imageResource->resourceBuffer());
   EXPECT_FALSE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(0U, client->encodedSizeOnLastImageChanged());
-  // The client should not have been notified of completion yet, since the image
+  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(client->notifyFinishedCalled());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(ResourceResponse(
           testURL, "image/jpeg", sizeof(kJpegImage2), nullAtom, String())),
       nullptr);
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage2), sizeof(kJpegImage2));
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage2),
                                             sizeof(kJpegImage2));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(sizeof(kJpegImage2), client->encodedSizeOnLastImageChanged());
-  // The client should have been notified of completion only after the reload
+  EXPECT_EQ(kJpegImage2Width, observer->imageWidthOnLastImageChanged());
+  // 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(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(kJpegImage2Width, observer->imageWidthOnImageNotifyFinished());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
 }
 
 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* imageResource = ImageResource::fetch(request, fetcher);
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom,
                             String());
   response.setHTTPStatusCode(206);
   response.setHTTPHeaderField(
       "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
                                          sizeof(kJpegImage)));
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(response));
@@ skipping 17 matching lines @@
   EXPECT_EQ(
       static_cast<int>(WebCachePolicy::BypassingCache),
       static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
 
   imageResource->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);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, SuccessfulRevalidationJpeg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(304);
 
   imageResource->responseReceived(response, nullptr);
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, SuccessfulRevalidationSvg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(304);
   imageResource->responseReceived(response, nullptr);
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, FailedRevalidationJpegToJpeg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage2),
                   sizeof(kJpegImage2));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(4, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(4, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(50, imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, FailedRevalidationJpegToSvg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(3, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(3, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, FailedRevalidationSvgToJpeg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   receiveResponse(imageResource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(3, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(3, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
 }
 
 TEST(ImageResourceTest, FailedRevalidationSvgToSvg) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(1, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(1, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(200, imageResource->getContent()->getImage()->height());
 
   imageResource->setRevalidatingRequest(ResourceRequest(url));
   receiveResponse(imageResource, url, "image/svg+xml", kSvgImage2,
                   strlen(kSvgImage2));
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(2, client->imageChangedCount());
-  EXPECT_EQ(1, client->imageNotifyFinishedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(2, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_EQ(300, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(300, imageResource->getContent()->getImage()->height());
 }
 
 // Tests for pruning.
 
 TEST(ImageResourceTest, AddClientAfterPrune) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
   ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
@@ skipping 56 matching lines @@
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(
       request,
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_FALSE(imageResource->isPlaceholder());
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(ResourceResponse(
           testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
                                             sizeof(kJpegImage));
 
   EXPECT_EQ(Resource::Cached, imageResource->getStatus());
   EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
   EXPECT_FALSE(imageResource->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());
+  EXPECT_LT(0, observer->imageChangedCount());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   KURL testURL(ParsedURLString,
                "data:image/jpeg;base64," +
@@ skipping 56 matching lines @@
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
   ImageResource* imageResource = ImageResource::fetch(
       request,
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom,
                             String());
   response.setHTTPStatusCode(206);
   response.setHTTPHeaderField(
       "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
                                          sizeof(kJpegImage)));
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(response));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage),
       kJpegImageSubrangeWithDimensionsLength);
   imageResource->loader()->didFinishLoading(
       0.0, kJpegImageSubrangeWithDimensionsLength,
       kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(Resource::Cached, imageResource->getStatus());
   EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
             imageResource->encodedSize());
   EXPECT_TRUE(imageResource->isPlaceholder());
-  EXPECT_LT(0, client->imageChangedCount());
-  EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
-            client->encodedSizeOnLastImageChanged());
-  EXPECT_TRUE(client->notifyFinishedCalled());
-  EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
-            client->encodedSizeOnNotifyFinished());
-  EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
-            client->encodedSizeOnImageNotifyFinished());
+  EXPECT_LT(0, observer->imageChangedCount());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_FALSE(imageResource->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* imageResource = ImageResource::fetch(
       request,
       ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   const char kBadData[] = "notanimageresponse";
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(ResourceResponse(
           testURL, "image/jpeg", sizeof(kBadData), nullAtom, String())));
   imageResource->loader()->didReceiveData(kBadData, sizeof(kBadData));
 
   // The dimensions could not be extracted, so the full original image should be
   // loading.
   EXPECT_EQ(Resource::Pending, imageResource->getStatus());
   EXPECT_FALSE(imageResource->isPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(
       static_cast<int>(WebCachePolicy::BypassingCache),
       static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
-  EXPECT_FALSE(client->notifyFinishedCalled());
-  EXPECT_EQ(0, client->imageNotifyFinishedCount());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(ResourceResponse(
           testURL, "image/jpeg", sizeof(kJpegImage), nullAtom, String())));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
   imageResource->loader()->didFinishLoading(0.0, sizeof(kJpegImage),
                                             sizeof(kJpegImage));
 
   EXPECT_EQ(Resource::Cached, imageResource->getStatus());
   EXPECT_EQ(sizeof(kJpegImage), imageResource->encodedSize());
   EXPECT_FALSE(imageResource->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());
+  EXPECT_LT(0, observer->imageChangedCount());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnLastImageChanged());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
+  EXPECT_EQ(kJpegImageWidth, observer->imageWidthOnImageNotifyFinished());
 
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(imageResource->getContent()->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* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImageResource =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   EXPECT_EQ(imageResource, secondImageResource);
   EXPECT_EQ(Resource::Pending, imageResource->getStatus());
   EXPECT_FALSE(imageResource->isPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(
       static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
       static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
-  EXPECT_FALSE(client->notifyFinishedCalled());
+  EXPECT_FALSE(observer->imageNotifyFinishedCalled());
 
   imageResource->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* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom,
                             String());
   response.setHTTPStatusCode(206);
   response.setHTTPHeaderField(
       "content-range", buildContentRange(kJpegImageSubrangeWithDimensionsLength,
                                          sizeof(kJpegImage)));
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(response));
   imageResource->loader()->didReceiveData(
       reinterpret_cast<const char*>(kJpegImage),
       kJpegImageSubrangeWithDimensionsLength);
   imageResource->loader()->didFinishLoading(
       0.0, kJpegImageSubrangeWithDimensionsLength,
       kJpegImageSubrangeWithDimensionsLength);
 
   EXPECT_EQ(Resource::Cached, imageResource->getStatus());
   EXPECT_EQ(kJpegImageSubrangeWithDimensionsLength,
             imageResource->encodedSize());
   EXPECT_TRUE(imageResource->isPlaceholder());
-  EXPECT_LT(0, client->imageChangedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_LT(0, observer->imageChangedCount());
+  EXPECT_TRUE(observer->imageNotifyFinishedCalled());
 
   FetchRequest nonPlaceholderRequest(testURL, FetchInitiatorInfo());
   ImageResource* secondImageResource =
       ImageResource::fetch(nonPlaceholderRequest, fetcher);
   EXPECT_EQ(imageResource, secondImageResource);
   EXPECT_EQ(Resource::Pending, imageResource->getStatus());
   EXPECT_FALSE(imageResource->isPlaceholder());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_EQ(
       static_cast<int>(WebCachePolicy::UseProtocolCachePolicy),
       static_cast<int>(imageResource->resourceRequest().getCachePolicy()));
 
   imageResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, PeriodicFlushTest) {
   ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
       platform;
   KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
   URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html",
                                         "text/html");
   ResourceRequest request = ResourceRequest(testURL);
   ImageResource* imageResource = ImageResource::create(request);
   imageResource->setStatus(Resource::Pending);
 
-  Persistent<MockImageResourceClient> client =
-      new MockImageResourceClient(imageResource);
+  std::unique_ptr<MockImageResourceObserver> observer =
+      MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage2),
                                     nullAtom, String());
   resourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
   imageResource->responseReceived(resourceResponse, nullptr);
 
   // This is number is sufficiently large amount of bytes necessary for the
   // image to be created (since the size is known). This was determined by
   // appending one byte at a time (with flushes) until the image was decoded.
   size_t meaningfulImageSize = 280;
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage2),
                             meaningfulImageSize);
   size_t bytesSent = meaningfulImageSize;
 
   EXPECT_FALSE(imageResource->errorOccurred());
   EXPECT_TRUE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(1, client->imageChangedCount());
+  EXPECT_EQ(1, observer->imageChangedCount());
 
   platform->runForPeriodSeconds(1.);
   platform->advanceClockSeconds(1.);
 
   // Sanity check that we created an image after appending |meaningfulImageSize|
   // bytes just once.
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
-  EXPECT_EQ(1, client->imageChangedCount());
+  EXPECT_EQ(1, observer->imageChangedCount());
 
   for (int flushCount = 1; flushCount <= 3; ++flushCount) {
     // For each of the iteration that appends data, we don't expect
     // |imageChangeCount()| to change, since the time is adjusted by 0.2001
     // seconds (it's greater than 0.2 to avoid double precision problems).
     // After 5 appends, we breach the flush interval and the flush count
     // increases.
     for (int i = 0; i < 5; ++i) {
       SCOPED_TRACE(i);
       imageResource->appendData(
           reinterpret_cast<const char*>(kJpegImage2) + bytesSent, 1);
 
       EXPECT_FALSE(imageResource->errorOccurred());
       ASSERT_TRUE(imageResource->getContent()->hasImage());
-      EXPECT_EQ(flushCount, client->imageChangedCount());
+      EXPECT_EQ(flushCount, observer->imageChangedCount());
 
       ++bytesSent;
       platform->runForPeriodSeconds(0.2001);
     }
   }
 
   // Increasing time by a large number only causes one extra flush.
   platform->runForPeriodSeconds(10.);
   platform->advanceClockSeconds(10.);
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(4, client->imageChangedCount());
+  EXPECT_EQ(4, observer->imageChangedCount());
 
   // Append the rest of the data and finish (which causes another flush).
   imageResource->appendData(
       reinterpret_cast<const char*>(kJpegImage2) + bytesSent,
       sizeof(kJpegImage2) - bytesSent);
   imageResource->finish();
 
   EXPECT_FALSE(imageResource->errorOccurred());
   ASSERT_TRUE(imageResource->getContent()->hasImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
-  EXPECT_EQ(5, client->imageChangedCount());
-  EXPECT_TRUE(client->notifyFinishedCalled());
+  EXPECT_EQ(5, observer->imageChangedCount());
+  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