Schedule bitmap animation timers on the compositor task runner.

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 81 matching lines @@
     0xda, 0x00, 0x0c, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3f,
     0x00, 0xb2, 0xc0, 0x07, 0xff, 0xd9};
 
 constexpr int kJpegImageWidth = 1;
 constexpr int kJpegImageHeight = 1;
 
 constexpr size_t kJpegImageSubrangeWithDimensionsLength =
     sizeof(kJpegImage) - 1;
 constexpr size_t kJpegImageSubrangeWithoutDimensionsLength = 3;
 
+class ImageResourceTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    task_runner_ = AdoptRef(new scheduler::FakeWebTaskRunner);
+  }
+
+  RefPtr<scheduler::FakeWebTaskRunner> task_runner_;
+};
+
 // 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();
+TEST_F(ImageResourceTest, DimensionsDecodableFromPartialTestImage) {
+  RefPtr<Image> image =
+      BitmapImage::Create(AdoptRef(new scheduler::FakeWebTaskRunner));
   EXPECT_EQ(
       Image::kSizeAvailable,
       image->SetData(SharedBuffer::Create(
                          kJpegImage, kJpegImageSubrangeWithDimensionsLength),
                      true));
   EXPECT_TRUE(image->IsBitmapImage());
   EXPECT_EQ(1, image->width());
   EXPECT_EQ(1, image->height());
 }
 
@@ skipping 204 matching lines @@
   EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsSVGImage());
 }
 
 ResourceFetcher* CreateFetcher() {
   return ResourceFetcher::Create(
       MockFetchContext::Create(MockFetchContext::kShouldLoadNewResource));
 }
 
-TEST(ImageResourceTest, MultipartImage) {
+TEST_F(ImageResourceTest, MultipartImage) {
   ResourceFetcher* fetcher = CreateFetcher();
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   // Emulate starting a real load, but don't expect any "real"
   // WebURLLoaderClient callbacks.
   ImageResource* image_resource =
-      ImageResource::Create(ResourceRequest(test_url));
+      ImageResource::Create(task_runner_, ResourceRequest(test_url));
   image_resource->SetIdentifier(CreateUniqueIdentifier());
   fetcher->StartLoad(image_resource);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
   EXPECT_EQ(ResourceStatus::kPending, image_resource->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.
@@ skipping 53 matching lines @@
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(1, observer2->ImageChangedCount());
   EXPECT_TRUE(observer2->ImageNotifyFinishedCalled());
 }
 
-TEST(ImageResourceTest, CancelOnRemoveObserver) {
+TEST_F(ImageResourceTest, CancelOnRemoveObserver) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
 
   // Emulate starting a real load.
-  ImageResource* image_resource =
-      ImageResource::Create(ResourceRequest(test_url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(test_url));
   image_resource->SetIdentifier(CreateUniqueIdentifier());
 
   fetcher->StartLoad(image_resource);
   GetMemoryCache()->Add(image_resource);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
   EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus());
 
   // The load should still be alive, but a timer should be started to cancel the
   // load inside removeClient().
   observer->RemoveAsObserver();
   EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus());
   EXPECT_TRUE(GetMemoryCache()->ResourceForURL(test_url));
 
   // Trigger the cancel timer, ensure the load was cancelled and the resource
   // was evicted from the cache.
   blink::testing::RunPendingTasks();
   EXPECT_EQ(ResourceStatus::kLoadError, image_resource->GetStatus());
   EXPECT_FALSE(GetMemoryCache()->ResourceForURL(test_url));
 }
 
-TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients) {
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest());
+TEST_F(ImageResourceTest, DecodedDataRemainsWhileHasClients) {
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest());
   image_resource->SetStatus(ResourceStatus::kPending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   // Send the image response.
   image_resource->ResponseReceived(
       ResourceResponse(KURL(), "multipart/x-mixed-replace", 0, g_null_atom),
       nullptr);
 
@@ skipping 20 matching lines @@
   // The ImageResource no longer has observers. The decoded image data should be
   // deleted by prune.
   observer->RemoveAsObserver();
   image_resource->Prune();
   EXPECT_FALSE(image_resource->IsAlive());
   EXPECT_TRUE(image_resource->GetContent()->HasImage());
   // TODO(hajimehoshi): Should check imageResource doesn't have decoded image
   // data.
 }
 
-TEST(ImageResourceTest, UpdateBitmapImages) {
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest());
+TEST_F(ImageResourceTest, UpdateBitmapImages) {
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest());
   image_resource->SetStatus(ResourceStatus::kPending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   // Send the image response.
   image_resource->ResponseReceived(
       ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), g_null_atom),
       nullptr);
   image_resource->AppendData(reinterpret_cast<const char*>(kJpegImage),
                              sizeof(kJpegImage));
   image_resource->Finish();
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(2, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
+TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest request = ResourceRequest(test_url);
-  ImageResource* image_resource = ImageResource::Create(request);
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), request);
   image_resource->SetStatus(ResourceStatus::kPending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
   ResourceFetcher* fetcher = CreateFetcher();
 
   // Send the image response.
   ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage),
                                      g_null_atom);
   resource_response.AddHTTPHeaderField("chrome-proxy-content-transform",
@@ skipping 19 matching lines @@
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   EXPECT_EQ(3, observer->ImageChangedCount());
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinishedWithOldHeaders) {
+TEST_F(ImageResourceTest,
+       ReloadIfLoFiOrPlaceholderAfterFinishedWithOldHeaders) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest request = ResourceRequest(test_url);
-  ImageResource* image_resource = ImageResource::Create(request);
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), request);
   image_resource->SetStatus(ResourceStatus::kPending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
   ResourceFetcher* fetcher = CreateFetcher();
 
   // Send the image response.
   ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage),
                                      g_null_atom);
   resource_response.AddHTTPHeaderField("chrome-proxy", "q=low");
@@ skipping 18 matching lines @@
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   EXPECT_EQ(3, observer->ImageChangedCount());
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest,
-     ReloadIfLoFiOrPlaceholderAfterFinishedWithoutLoFiHeaders) {
+TEST_F(ImageResourceTest,
+       ReloadIfLoFiOrPlaceholderAfterFinishedWithoutLoFiHeaders) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest request = ResourceRequest(test_url);
   request.SetPreviewsState(WebURLRequest::kServerLoFiOn);
-  ImageResource* image_resource = ImageResource::Create(request);
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), request);
   image_resource->SetStatus(ResourceStatus::kPending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
   ResourceFetcher* fetcher = CreateFetcher();
 
   // Send the image response, without any LoFi image response headers.
   image_resource->ResponseReceived(
       ResourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage), g_null_atom),
       nullptr);
@@ skipping 16 matching lines @@
   // Call reloadIfLoFiOrPlaceholderImage() after the image has finished loading.
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   // The image should not have been reloaded, since it didn't have the LoFi
   // image response headers.
   EXPECT_EQ(2, observer->ImageChangedCount());
   EXPECT_TRUE(image_resource->IsLoaded());
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
+TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
   ResourceFetcher* fetcher = CreateFetcher();
 
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceRequest request = ResourceRequest(test_url);
   request.SetPreviewsState(WebURLRequest::kServerLoFiOn);
   FetchParameters fetch_params(request, FetchInitiatorInfo());
-  ImageResource* image_resource = ImageResource::Fetch(fetch_params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), fetch_params, fetcher);
   ImageResourceContent* content = image_resource->GetContent();
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(content);
 
   // Send the image response.
   ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage),
                                      g_null_atom);
   resource_response.AddHTTPHeaderField("chrome-proxy-content-transform",
                                        "empty-image");
@@ skipping 12 matching lines @@
 
   EXPECT_EQ(3, observer->ImageChangedCount());
 
   TestThatReloadIsStartedThenServeReload(test_url, image_resource, content,
                                          observer.get(),
                                          WebCachePolicy::kBypassingCache);
 
   GetMemoryCache()->Remove(image_resource);
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
+TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceRequest request(test_url);
   request.SetPreviewsState(WebURLRequest::kServerLoFiOn);
   FetchParameters fetch_params(request, FetchInitiatorInfo());
   ResourceFetcher* fetcher = CreateFetcher();
 
-  ImageResource* image_resource = ImageResource::Fetch(fetch_params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), fetch_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   // Send the image response.
   image_resource->Loader()->DidReceiveResponse(
       WrappedResourceResponse(ResourceResponse(
           test_url, "image/jpeg", sizeof(kJpegImage), g_null_atom)));
   image_resource->Loader()->DidReceiveData(
       reinterpret_cast<const char*>(kJpegImage), sizeof(kJpegImage));
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(0, observer->ImageWidthOnLastImageChanged());
   // The observer should not have been notified of completion yet, since the
   // image is still loading.
   EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
+TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher);
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 
   image_resource->ReloadIfLoFiOrPlaceholderImage(fetcher,
                                                  Resource::kReloadAlways);
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest, SVGImage) {
+TEST_F(ImageResourceTest, SVGImage) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage());
 }
 
-TEST(ImageResourceTest, SuccessfulRevalidationJpeg) {
+TEST_F(ImageResourceTest, SuccessfulRevalidationJpeg) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
@@ skipping 15 matching lines @@
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(2, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
 }
 
-TEST(ImageResourceTest, SuccessfulRevalidationSvg) {
+TEST_F(ImageResourceTest, SuccessfulRevalidationSvg) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(1, observer->ImageChangedCount());
@@ skipping 11 matching lines @@
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(200, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(200, image_resource->GetContent()->GetImage()->height());
 }
 
-TEST(ImageResourceTest, FailedRevalidationJpegToJpeg) {
+TEST_F(ImageResourceTest, FailedRevalidationJpegToJpeg) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
@@ skipping 12 matching lines @@
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(4, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height());
 }
 
-TEST(ImageResourceTest, FailedRevalidationJpegToSvg) {
+TEST_F(ImageResourceTest, FailedRevalidationJpegToSvg) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
@@ skipping 11 matching lines @@
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(3, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(200, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(200, image_resource->GetContent()->GetImage()->height());
 }
 
-TEST(ImageResourceTest, FailedRevalidationSvgToJpeg) {
+TEST_F(ImageResourceTest, FailedRevalidationSvgToJpeg) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(1, observer->ImageChangedCount());
@@ skipping 11 matching lines @@
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(3, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
 }
 
-TEST(ImageResourceTest, FailedRevalidationSvgToSvg) {
+TEST_F(ImageResourceTest, FailedRevalidationSvgToSvg) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ReceiveResponse(image_resource, url, "image/svg+xml", kSvgImage,
                   strlen(kSvgImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(1, observer->ImageChangedCount());
@@ skipping 11 matching lines @@
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(2, observer->ImageChangedCount());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(300, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(300, image_resource->GetContent()->GetImage()->height());
 }
 
 // Tests for pruning.
 
-TEST(ImageResourceTest, AddClientAfterPrune) {
+TEST_F(ImageResourceTest, AddClientAfterPrune) {
   KURL url(kParsedURLString, "http://127.0.0.1:8000/foo");
-  ImageResource* image_resource = ImageResource::Create(ResourceRequest(url));
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), ResourceRequest(url));
 
   // Adds a ResourceClient but not ImageResourceObserver.
   Persistent<MockResourceClient> client1 =
       new MockResourceClient(image_resource);
 
   ReceiveResponse(image_resource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
 
   EXPECT_FALSE(image_resource->ErrorOccurred());
@@ skipping 17 matching lines @@
       new MockResourceClient(image_resource);
 
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
   EXPECT_TRUE(client2->NotifyFinishedCalled());
 }
 
-TEST(ImageResourceTest, CancelOnDecodeError) {
+TEST_F(ImageResourceTest, CancelOnDecodeError) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
-  ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   image_resource->Loader()->DidReceiveResponse(
       WrappedResourceResponse(
           ResourceResponse(test_url, "image/jpeg", 18, g_null_atom)),
       nullptr);
 
   EXPECT_EQ(0, observer->ImageChangedCount());
 
   image_resource->Loader()->DidReceiveData("notactuallyanimage", 18);
 
   EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(ResourceStatus::kDecodeError,
             observer->StatusOnImageNotifyFinished());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_FALSE(image_resource->IsLoading());
 }
 
-TEST(ImageResourceTest, DecodeErrorWithEmptyBody) {
+TEST_F(ImageResourceTest, DecodeErrorWithEmptyBody) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
-  ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   image_resource->Loader()->DidReceiveResponse(
       WrappedResourceResponse(
           ResourceResponse(test_url, "image/jpeg", 0, g_null_atom)),
       nullptr);
 
   EXPECT_EQ(ResourceStatus::kPending, image_resource->GetStatus());
   EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(0, observer->ImageChangedCount());
 
   image_resource->Loader()->DidFinishLoading(0.0, 0, 0);
 
   EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(ResourceStatus::kDecodeError,
             observer->StatusOnImageNotifyFinished());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_FALSE(image_resource->IsLoading());
 }
 
 // Testing DecodeError that occurs in didFinishLoading().
 // This is similar to DecodeErrorWithEmptyBody, but with non-empty body.
-TEST(ImageResourceTest, PartialContentWithoutDimensions) {
+TEST_F(ImageResourceTest, PartialContentWithoutDimensions) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceRequest resource_request(test_url);
   resource_request.SetHTTPHeaderField("range", "bytes=0-2");
   FetchParameters params(resource_request, FetchInitiatorInfo());
   ResourceFetcher* fetcher = CreateFetcher();
-  ImageResource* image_resource = ImageResource::Fetch(params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   ResourceResponse partial_response(test_url, "image/jpeg",
                                     kJpegImageSubrangeWithoutDimensionsLength,
                                     g_null_atom);
   partial_response.SetHTTPStatusCode(206);
   partial_response.SetHTTPHeaderField(
       "content-range",
       BuildContentRange(kJpegImageSubrangeWithoutDimensionsLength,
@@ skipping 14 matching lines @@
       kJpegImageSubrangeWithoutDimensionsLength);
 
   EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus());
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(ResourceStatus::kDecodeError,
             observer->StatusOnImageNotifyFinished());
   EXPECT_EQ(1, observer->ImageChangedCount());
   EXPECT_FALSE(image_resource->IsLoading());
 }
 
-TEST(ImageResourceTest, FetchDisallowPlaceholder) {
+TEST_F(ImageResourceTest, FetchDisallowPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kDisallowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                   observer.get());
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   KURL test_url(kParsedURLString,
                 "data:image/jpeg;base64," +
                     Base64Encode(reinterpret_cast<const char*>(kJpegImage),
                                  sizeof(kJpegImage)));
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kDisallowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ(g_null_atom,
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderPostRequest) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderPostRequest) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest resource_request(test_url);
   resource_request.SetHTTPMethod("POST");
   FetchParameters params(resource_request, FetchInitiatorInfo());
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kDisallowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ(g_null_atom,
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
 
   image_resource->Loader()->Cancel();
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest resource_request(test_url);
   resource_request.SetHTTPHeaderField("range", "bytes=128-255");
   FetchParameters params(resource_request, FetchInitiatorInfo());
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kDisallowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ("bytes=128-255",
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
 
   image_resource->Loader()->Cancel();
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   const char kBadData[] = "notanimageresponse";
 
@@ skipping 13 matching lines @@
   // The dimensions could not be extracted, so the full original image should be
   // loading.
   EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(2, observer->ImageChangedCount());
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
+TEST_F(ImageResourceTest,
+       FetchAllowPlaceholderPartialContentWithoutDimensions) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
   params.SetAllowImagePlaceholder();
-  ImageResource* image_resource = ImageResource::Fetch(params, CreateFetcher());
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
   EXPECT_EQ(FetchParameters::kAllowPlaceholder,
             params.GetPlaceholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             image_resource->GetResourceRequest().HttpHeaderField("range"));
   EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   // TODO(hiroshige): Make the range request header and partial content length
   // consistent. https://crbug.com/689760.
@@ skipping 19 matching lines @@
       kJpegImageSubrangeWithoutDimensionsLength);
 
   EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
   EXPECT_EQ(2, observer->ImageChangedCount());
 
   TestThatReloadIsStartedThenServeReload(
       test_url, image_resource, image_resource->GetContent(), observer.get(),
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
 
   FetchParameters placeholder_params{ResourceRequest(test_url),
                                      FetchInitiatorInfo()};
   placeholder_params.SetAllowImagePlaceholder();
-  ImageResource* image_resource =
-      ImageResource::Fetch(placeholder_params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   FetchParameters non_placeholder_params{ResourceRequest(test_url),
                                          FetchInitiatorInfo()};
   ImageResource* image_resource2 =
-      ImageResource::Fetch(non_placeholder_params, fetcher);
+      ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner),
+                           non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer2 =
       MockImageResourceObserver::Create(image_resource2->GetContent());
 
   ImageResource* image_resource3 =
-      ImageResource::Fetch(non_placeholder_params, fetcher);
+      ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner),
+                           non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer3 =
       MockImageResourceObserver::Create(image_resource3->GetContent());
 
   // |imageResource| remains a placeholder, while following non-placeholder
   // requests start non-placeholder loading with a separate ImageResource.
   ASSERT_NE(image_resource, image_resource2);
   ASSERT_NE(image_resource->Loader(), image_resource2->Loader());
   ASSERT_NE(image_resource->GetContent(), image_resource2->GetContent());
   ASSERT_EQ(image_resource2, image_resource3);
 
   EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
   EXPECT_FALSE(observer2->ImageNotifyFinishedCalled());
   EXPECT_FALSE(observer3->ImageNotifyFinishedCalled());
 
   // Checks that |imageResource2| (and |imageResource3|) loads a
   // non-placeholder image.
   TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource2,
                                                   observer2.get());
   EXPECT_TRUE(observer3->ImageNotifyFinishedCalled());
 
   // Checks that |imageResource| will loads a placeholder image.
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 
   // |imageResource2| is still a non-placeholder image.
   EXPECT_FALSE(image_resource2->ShouldShowPlaceholder());
   EXPECT_TRUE(image_resource2->GetContent()->GetImage()->IsBitmapImage());
 }
 
-TEST(ImageResourceTest,
-     FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
+TEST_F(ImageResourceTest,
+       FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
   ResourceFetcher* fetcher = CreateFetcher();
   FetchParameters placeholder_params{ResourceRequest(test_url),
                                      FetchInitiatorInfo()};
   placeholder_params.SetAllowImagePlaceholder();
-  ImageResource* image_resource =
-      ImageResource::Fetch(placeholder_params, fetcher);
+  ImageResource* image_resource = ImageResource::Fetch(
+      AdoptRef(new scheduler::FakeWebTaskRunner), placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   TestThatIsPlaceholderRequestAndServeResponse(test_url, image_resource,
                                                observer.get());
 
   FetchParameters non_placeholder_params{ResourceRequest(test_url),
                                          FetchInitiatorInfo()};
   ImageResource* image_resource2 =
-      ImageResource::Fetch(non_placeholder_params, fetcher);
+      ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner),
+                           non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer2 =
       MockImageResourceObserver::Create(image_resource2->GetContent());
 
   ImageResource* image_resource3 =
-      ImageResource::Fetch(non_placeholder_params, fetcher);
+      ImageResource::Fetch(AdoptRef(new scheduler::FakeWebTaskRunner),
+                           non_placeholder_params, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer3 =
       MockImageResourceObserver::Create(image_resource3->GetContent());
 
   EXPECT_FALSE(observer2->ImageNotifyFinishedCalled());
   EXPECT_FALSE(observer3->ImageNotifyFinishedCalled());
 
   // |imageResource| remains a placeholder, while following non-placeholder
   // requests start non-placeholder loading with a separate ImageResource.
   ASSERT_NE(image_resource, image_resource2);
   ASSERT_EQ(image_resource2, image_resource3);
 
   TestThatIsNotPlaceholderRequestAndServeResponse(test_url, image_resource2,
                                                   observer2.get());
   EXPECT_TRUE(observer3->ImageNotifyFinishedCalled());
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
   const struct {
     int status_code;
     AtomicString content_range;
   } tests[] = {
       {200, g_null_atom},
       {404, g_null_atom},
       {206, BuildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))},
   };
   for (const auto& test : tests) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
     FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
     params.SetAllowImagePlaceholder();
-    ImageResource* image_resource =
-        ImageResource::Fetch(params, CreateFetcher());
+    ImageResource* image_resource = ImageResource::Fetch(
+        AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
     EXPECT_EQ(FetchParameters::kAllowPlaceholder,
               params.GetPlaceholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               image_resource->GetResourceRequest().HttpHeaderField("range"));
     EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::Create(image_resource->GetContent());
 
     ResourceResponse response(test_url, "image/jpeg", sizeof(kJpegImage),
                               g_null_atom);
@@ skipping 17 matching lines @@
 
     ASSERT_TRUE(image_resource->GetContent()->HasImage());
     EXPECT_EQ(kJpegImageWidth,
               image_resource->GetContent()->GetImage()->width());
     EXPECT_EQ(kJpegImageHeight,
               image_resource->GetContent()->GetImage()->height());
     EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   }
 }
 
-TEST(ImageResourceTest,
-     FetchAllowPlaceholderFullResponseDecodeFailureNoReload) {
+TEST_F(ImageResourceTest,
+       FetchAllowPlaceholderFullResponseDecodeFailureNoReload) {
   static const char kBadImageData[] = "bad image data";
 
   const struct {
     int status_code;
     AtomicString content_range;
     size_t data_size;
   } tests[] = {
       {200, g_null_atom, sizeof(kBadImageData)},
       {206, BuildContentRange(sizeof(kBadImageData), sizeof(kBadImageData)),
        sizeof(kBadImageData)},
       {204, g_null_atom, 0},
   };
   for (const auto& test : tests) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
     FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
     params.SetAllowImagePlaceholder();
-    ImageResource* image_resource =
-        ImageResource::Fetch(params, CreateFetcher());
+    ImageResource* image_resource = ImageResource::Fetch(
+        AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
     EXPECT_EQ(FetchParameters::kAllowPlaceholder,
               params.GetPlaceholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               image_resource->GetResourceRequest().HttpHeaderField("range"));
     EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::Create(image_resource->GetContent());
 
     ResourceResponse response(test_url, "image/jpeg", test.data_size,
                               g_null_atom);
     response.SetHTTPStatusCode(test.status_code);
     if (test.content_range != g_null_atom)
       response.SetHTTPHeaderField("content-range", test.content_range);
     image_resource->Loader()->DidReceiveResponse(
         WrappedResourceResponse(response));
     image_resource->Loader()->DidReceiveData(kBadImageData, test.data_size);
 
     EXPECT_EQ(ResourceStatus::kDecodeError, image_resource->GetStatus());
     EXPECT_FALSE(image_resource->ShouldShowPlaceholder());
   }
 }
 
-TEST(ImageResourceTest,
-     FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
+TEST_F(ImageResourceTest,
+       FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
   const int kStatusCodes[] = {404, 500};
   for (int status_code : kStatusCodes) {
     KURL test_url(kParsedURLString, kTestURL);
     ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
     FetchParameters params{ResourceRequest(test_url), FetchInitiatorInfo()};
     params.SetAllowImagePlaceholder();
-    ImageResource* image_resource =
-        ImageResource::Fetch(params, CreateFetcher());
+    ImageResource* image_resource = ImageResource::Fetch(
+        AdoptRef(new scheduler::FakeWebTaskRunner), params, CreateFetcher());
     EXPECT_EQ(FetchParameters::kAllowPlaceholder,
               params.GetPlaceholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               image_resource->GetResourceRequest().HttpHeaderField("range"));
     EXPECT_TRUE(image_resource->ShouldShowPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::Create(image_resource->GetContent());
 
     static const char kBadImageData[] = "bad image data";
 
     ResourceResponse response(test_url, "image/jpeg", sizeof(kBadImageData),
                               g_null_atom);
     response.SetHTTPStatusCode(status_code);
     image_resource->Loader()->DidReceiveResponse(
         WrappedResourceResponse(response));
     image_resource->Loader()->DidReceiveData(kBadImageData,
                                              sizeof(kBadImageData));
 
     EXPECT_FALSE(observer->ImageNotifyFinishedCalled());
 
     // The dimensions could not be extracted, and the response code was a 4xx
     // error, so the full original image should be loading.
     TestThatReloadIsStartedThenServeReload(
         test_url, image_resource, image_resource->GetContent(), observer.get(),
         WebCachePolicy::kBypassingCache);
   }
 }
 
-TEST(ImageResourceTest, PeriodicFlushTest) {
+TEST_F(ImageResourceTest, PeriodicFlushTest) {
   ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
       platform;
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
   ResourceRequest request = ResourceRequest(test_url);
-  ImageResource* image_resource = ImageResource::Create(request);
+  ImageResource* image_resource = ImageResource::Create(
+      AdoptRef(new scheduler::FakeWebTaskRunner), request);
   image_resource->SetStatus(ResourceStatus::kPending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::Create(image_resource->GetContent());
 
   // Send the image response.
   ResourceResponse resource_response(KURL(), "image/jpeg", sizeof(kJpegImage2),
                                      g_null_atom);
   resource_response.AddHTTPHeaderField("chrome-proxy", "q=low");
 
@@ skipping 61 matching lines @@
   EXPECT_TRUE(observer->ImageNotifyFinishedCalled());
   EXPECT_TRUE(image_resource->GetContent()->GetImage()->IsBitmapImage());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(50, image_resource->GetContent()->GetImage()->height());
 
   WTF::SetTimeFunctionsForTesting(nullptr);
 }
 
 }  // namespace
 }  // namespace blink