Schedule bitmap animation timers on the compositor task runner.

third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp

Index: third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
diff --git a/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp b/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
index c1481326609f508fa329e364369117d302b0b71b..5bb8a9967dc6ae7a706c43ff3c7516d2f2f08620 100644
--- a/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
+++ b/third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp
@@ -99,11 +99,21 @@ 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(
@@ -328,7 +338,7 @@ ResourceFetcher* CreateFetcher() {
       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());
@@ -336,7 +346,7 @@ TEST(ImageResourceTest, MultipartImage) {
   // 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);
 
@@ -410,15 +420,15 @@ TEST(ImageResourceTest, MultipartImage) {
   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);
@@ -441,8 +451,9 @@ TEST(ImageResourceTest, CancelOnRemoveObserver) {
   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 =
@@ -483,8 +494,9 @@ TEST(ImageResourceTest, DecodedDataRemainsWhileHasClients) {
   // 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 =
@@ -505,11 +517,12 @@ TEST(ImageResourceTest, UpdateBitmapImages) {
   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 =
@@ -549,11 +562,13 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
       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 =
@@ -592,13 +607,14 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinishedWithOldHeaders) {
       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 =
@@ -635,7 +651,7 @@ TEST(ImageResourceTest,
   EXPECT_TRUE(image_resource->IsLoaded());
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
+TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
   ResourceFetcher* fetcher = CreateFetcher();
 
   KURL test_url(kParsedURLString, kTestURL);
@@ -644,7 +660,8 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
   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 =
@@ -677,7 +694,7 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
   GetMemoryCache()->Remove(image_resource);
 }
 
-TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
+TEST_F(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
@@ -686,7 +703,8 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   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());
 
@@ -723,14 +741,15 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
       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 =
@@ -747,9 +766,10 @@ TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderForPlaceholder) {
       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());
 
@@ -764,9 +784,10 @@ TEST(ImageResourceTest, SVGImage) {
   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());
 
@@ -802,9 +823,10 @@ TEST(ImageResourceTest, SuccessfulRevalidationJpeg) {
             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());
 
@@ -836,9 +858,10 @@ TEST(ImageResourceTest, SuccessfulRevalidationSvg) {
   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());
 
@@ -871,9 +894,10 @@ TEST(ImageResourceTest, FailedRevalidationJpegToJpeg) {
   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());
 
@@ -905,9 +929,10 @@ TEST(ImageResourceTest, FailedRevalidationJpegToSvg) {
   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());
 
@@ -939,9 +964,10 @@ TEST(ImageResourceTest, FailedRevalidationSvgToJpeg) {
             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());
 
@@ -973,9 +999,10 @@ TEST(ImageResourceTest, FailedRevalidationSvgToSvg) {
 
 // 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 =
@@ -1013,13 +1040,14 @@ TEST(ImageResourceTest, AddClientAfterPrune) {
   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());
 
@@ -1040,13 +1068,14 @@ TEST(ImageResourceTest, CancelOnDecodeError) {
   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());
 
@@ -1071,7 +1100,7 @@ TEST(ImageResourceTest, DecodeErrorWithEmptyBody) {
 
 // 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());
 
@@ -1079,7 +1108,8 @@ TEST(ImageResourceTest, PartialContentWithoutDimensions) {
   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());
 
@@ -1114,12 +1144,13 @@ TEST(ImageResourceTest, PartialContentWithoutDimensions) {
   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 =
@@ -1129,14 +1160,15 @@ TEST(ImageResourceTest, FetchDisallowPlaceholder) {
                                                   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,
@@ -1144,14 +1176,15 @@ TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   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,
@@ -1161,14 +1194,15 @@ TEST(ImageResourceTest, FetchAllowPlaceholderPostRequest) {
   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",
@@ -1178,13 +1212,14 @@ TEST(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) {
   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 =
@@ -1194,13 +1229,14 @@ TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
                                                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",
@@ -1234,13 +1270,15 @@ TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
       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",
@@ -1280,7 +1318,7 @@ TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
       WebCachePolicy::kBypassingCache);
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   KURL test_url(kParsedURLString, kTestURL);
   ScopedMockedURLLoad scoped_mocked_url_load(test_url, GetTestFilePath());
 
@@ -1289,20 +1327,22 @@ TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   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());
 
@@ -1332,8 +1372,8 @@ TEST(ImageResourceTest, FetchAllowPlaceholderThenDisallowPlaceholder) {
   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());
 
@@ -1341,8 +1381,8 @@ TEST(ImageResourceTest,
   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());
 
@@ -1352,12 +1392,14 @@ TEST(ImageResourceTest,
   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());
 
@@ -1374,7 +1416,7 @@ TEST(ImageResourceTest,
   EXPECT_TRUE(observer3->ImageNotifyFinishedCalled());
 }
 
-TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
+TEST_F(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
   const struct {
     int status_code;
     AtomicString content_range;
@@ -1389,8 +1431,8 @@ TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
 
     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",
@@ -1428,8 +1470,8 @@ TEST(ImageResourceTest, FetchAllowPlaceholderFullResponseDecodeSuccess) {
   }
 }
 
-TEST(ImageResourceTest,
-     FetchAllowPlaceholderFullResponseDecodeFailureNoReload) {
+TEST_F(ImageResourceTest,
+       FetchAllowPlaceholderFullResponseDecodeFailureNoReload) {
   static const char kBadImageData[] = "bad image data";
 
   const struct {
@@ -1448,8 +1490,8 @@ TEST(ImageResourceTest,
 
     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",
@@ -1472,8 +1514,8 @@ TEST(ImageResourceTest,
   }
 }
 
-TEST(ImageResourceTest,
-     FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
+TEST_F(ImageResourceTest,
+       FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
   const int kStatusCodes[] = {404, 500};
   for (int status_code : kStatusCodes) {
     KURL test_url(kParsedURLString, kTestURL);
@@ -1481,8 +1523,8 @@ TEST(ImageResourceTest,
 
     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",
@@ -1511,13 +1553,14 @@ TEST(ImageResourceTest,
   }
 }
 
-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 =