Loading: use MockFetchContext in ImageResourceTest

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 21 matching lines @@
 
 #include <memory>
 #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/loader/fetch/FetchInitiatorInfo.h"
 #include "platform/loader/fetch/FetchRequest.h"
 #include "platform/loader/fetch/MemoryCache.h"
+#include "platform/loader/fetch/MockFetchContext.h"
 #include "platform/loader/fetch/MockResourceClient.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceLoader.h"
 #include "platform/loader/fetch/UniqueIdentifier.h"
 #include "platform/scheduler/test/fake_web_task_runner.h"
 #include "platform/testing/ScopedMockedURL.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
@@ skipping 116 matching lines @@
                      size_t dataSize) {
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setMimeType(mimeType);
   imageResource->responseReceived(response, nullptr);
   imageResource->appendData(data, dataSize);
   imageResource->finish();
 }
 
-class ImageResourceTestMockFetchContext : public FetchContext {
- public:
-  static ImageResourceTestMockFetchContext* create() {
-    return new ImageResourceTestMockFetchContext;
-  }
-
-  virtual ~ImageResourceTestMockFetchContext() {}
-
-  bool allowImage(bool imagesEnabled, const KURL&) const override {
-    return true;
-  }
-  ResourceRequestBlockedReason canRequest(
-      Resource::Type,
-      const ResourceRequest&,
-      const KURL&,
-      const ResourceLoaderOptions&,
-      SecurityViolationReportingPolicy,
-      FetchRequest::OriginRestriction) const override {
-    return ResourceRequestBlockedReason::None;
-  }
-  bool shouldLoadNewResource(Resource::Type) const override { return true; }
-  RefPtr<WebTaskRunner> loadingTaskRunner() const override { return m_runner; }
-
- private:
-  ImageResourceTestMockFetchContext()
-      : m_runner(adoptRef(new scheduler::FakeWebTaskRunner)) {}
-
-  RefPtr<scheduler::FakeWebTaskRunner> m_runner;
-};
-
 AtomicString buildContentRange(size_t rangeLength, size_t totalLength) {
   return AtomicString(String("bytes 0-" + String::number(rangeLength - 1) +
                              "/" + String::number(totalLength)));
 }
 
+ResourceFetcher* createFetcher() {
+  return ResourceFetcher::create(
+      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+}
+
 TEST(ImageResourceTest, MultipartImage) {
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   // 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);
 
@@ skipping 62 matching lines @@
   EXPECT_EQ(1, observer->imageChangedCount());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(1, observer2->imageChangedCount());
   EXPECT_TRUE(observer2->imageNotifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnRemoveObserver) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
 
   // Emulate starting a real load.
   ImageResource* imageResource =
       ImageResource::create(ResourceRequest(testURL));
   imageResource->setIdentifier(createUniqueIdentifier());
 
   fetcher->startLoad(imageResource);
   memoryCache()->add(imageResource);
 
   std::unique_ptr<MockImageResourceObserver> observer =
@@ skipping 80 matching lines @@
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderAfterFinished) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest request = ResourceRequest(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   ImageResource* imageResource = ImageResource::create(request);
   imageResource->setStatus(ResourceStatus::Pending);
 
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
 
   // Send the image response.
   ResourceResponse resourceResponse(KURL(), "image/jpeg", sizeof(kJpegImage),
                                     nullAtom);
   resourceResponse.addHTTPHeaderField("chrome-proxy-content-transform",
                                       "empty-image");
 
   imageResource->responseReceived(resourceResponse, nullptr);
   imageResource->appendData(reinterpret_cast<const char*>(kJpegImage),
                             sizeof(kJpegImage));
@@ skipping 33 matching lines @@
 
   // 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, ReloadIfLoFiOrPlaceholderViaResourceFetcher) {
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
 
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceRequest request = ResourceRequest(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   FetchRequest fetchRequest(request, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher);
   ImageResourceContent* content = imageResource->getContent();
 
@@ skipping 45 matching lines @@
   memoryCache()->remove(imageResource);
 }
 
 TEST(ImageResourceTest, ReloadIfLoFiOrPlaceholderDuringFetch) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceRequest request(testURL);
   request.setPreviewsState(WebURLRequest::ServerLoFiOn);
   FetchRequest fetchRequest(request, FetchInitiatorInfo());
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
 
   ImageResource* imageResource = ImageResource::fetch(fetchRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // Send the image response.
   ResourceResponse initialResourceResponse(testURL, "image/jpeg",
                                            sizeof(kJpegImage), nullAtom);
   initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
 
@@ skipping 44 matching lines @@
   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, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   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"));
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
@@ skipping 285 matching lines @@
   EXPECT_FALSE(imageResource->getContent()->getImage()->isNull());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->width());
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(client2->notifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDecodeError) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(
           ResourceResponse(testURL, "image/jpeg", 18, nullAtom)),
       nullptr);
 
   EXPECT_EQ(0, observer->imageChangedCount());
 
   imageResource->loader()->didReceiveData("notactuallyanimage", 18);
 
   EXPECT_EQ(ResourceStatus::DecodeError, imageResource->getStatus());
   EXPECT_TRUE(observer->imageNotifyFinishedCalled());
   EXPECT_EQ(ResourceStatus::DecodeError,
             observer->statusOnImageNotifyFinished());
   EXPECT_EQ(2, observer->imageChangedCount());
   EXPECT_FALSE(imageResource->isLoading());
 }
 
 TEST(ImageResourceTest, DecodeErrorWithEmptyBody) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   FetchRequest request(testURL, FetchInitiatorInfo());
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(
       WrappedResourceResponse(
           ResourceResponse(testURL, "image/jpeg", 0, nullAtom)),
       nullptr);
 
@@ skipping 13 matching lines @@
 
 // Testing DecodeError that occurs in didFinishLoading().
 // This is similar to DecodeErrorWithEmptyBody, but with non-empty body.
 TEST(ImageResourceTest, PartialContentWithoutDimensions) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   ResourceRequest resourceRequest(testURL);
   resourceRequest.setHTTPHeaderField("range", "bytes=0-2");
   FetchRequest request(resourceRequest, FetchInitiatorInfo());
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   ImageResource* imageResource = ImageResource::fetch(request, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse partialResponse(testURL, "image/jpeg",
                                    kJpegImageSubrangeWithoutDimensionsLength,
                                    nullAtom);
   partialResponse.setHTTPStatusCode(206);
   partialResponse.setHTTPHeaderField(
       "content-range",
@@ skipping 20 matching lines @@
             observer->statusOnImageNotifyFinished());
   EXPECT_EQ(1, observer->imageChangedCount());
   EXPECT_FALSE(imageResource->isLoading());
 }
 
 TEST(ImageResourceTest, FetchDisallowPlaceholder) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_FALSE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   imageResource->loader()->didReceiveResponse(WrappedResourceResponse(
       ResourceResponse(testURL, "image/jpeg", sizeof(kJpegImage), nullAtom)));
@@ skipping 16 matching lines @@
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderDataURL) {
   KURL testURL(ParsedURLString,
                "data:image/jpeg;base64," +
                    base64Encode(reinterpret_cast<const char*>(kJpegImage),
                                 sizeof(kJpegImage)));
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_FALSE(imageResource->isPlaceholder());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPostRequest) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest resourceRequest(testURL);
   resourceRequest.setHTTPMethod("POST");
   FetchRequest request(resourceRequest, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ(nullAtom,
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_FALSE(imageResource->isPlaceholder());
 
   imageResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderExistingRangeHeader) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
   ResourceRequest resourceRequest(testURL);
   resourceRequest.setHTTPHeaderField("range", "bytes=128-255");
   FetchRequest request(resourceRequest, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::DisallowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=128-255",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_FALSE(imageResource->isPlaceholder());
 
   imageResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderSuccessful) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom);
@@ skipping 25 matching lines @@
   EXPECT_FALSE(imageResource->getContent()->getImage()->isBitmapImage());
   EXPECT_FALSE(imageResource->getContent()->getImage()->isSVGImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderUnsuccessful) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   const char kBadData[] = "notanimageresponse";
 
@@ skipping 42 matching lines @@
   EXPECT_EQ(1, imageResource->getContent()->getImage()->height());
   EXPECT_TRUE(imageResource->getContent()->getImage()->isBitmapImage());
 }
 
 TEST(ImageResourceTest, FetchAllowPlaceholderPartialContentWithoutDimensions) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
   FetchRequest request(testURL, FetchInitiatorInfo());
   request.setAllowImagePlaceholder();
-  ImageResource* imageResource = ImageResource::fetch(
-      request,
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+  ImageResource* imageResource = ImageResource::fetch(request, createFetcher());
   EXPECT_EQ(FetchRequest::AllowPlaceholder,
             request.placeholderImageRequestType());
   EXPECT_EQ("bytes=0-2047",
             imageResource->resourceRequest().httpHeaderField("range"));
   EXPECT_TRUE(imageResource->isPlaceholder());
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   // TODO(hiroshige): Make the range request header and partial content length
   // consistent. https://crbug.com/689760.
@@ skipping 48 matching lines @@
   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, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   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(ResourceStatus::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(observer->imageNotifyFinishedCalled());
 
   imageResource->loader()->cancel();
 }
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderThenDisallowPlaceholderAfterLoaded) {
   KURL testURL(ParsedURLString, kTestURL);
   ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
-  ResourceFetcher* fetcher =
-      ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
+  ResourceFetcher* fetcher = createFetcher();
   FetchRequest placeholderRequest(testURL, FetchInitiatorInfo());
   placeholderRequest.setAllowImagePlaceholder();
   ImageResource* imageResource =
       ImageResource::fetch(placeholderRequest, fetcher);
   std::unique_ptr<MockImageResourceObserver> observer =
       MockImageResourceObserver::create(imageResource->getContent());
 
   ResourceResponse response(testURL, "image/jpeg",
                             kJpegImageSubrangeWithDimensionsLength, nullAtom);
   response.setHTTPStatusCode(206);
@@ skipping 39 matching lines @@
       {200, nullAtom},
       {404, nullAtom},
       {206, buildContentRange(sizeof(kJpegImage), sizeof(kJpegImage))},
   };
   for (const auto& test : tests) {
     KURL testURL(ParsedURLString, kTestURL);
     ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
     FetchRequest request(testURL, FetchInitiatorInfo());
     request.setAllowImagePlaceholder();
-    ImageResource* imageResource = ImageResource::fetch(
-        request,
-        ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+    ImageResource* imageResource =
+        ImageResource::fetch(request, createFetcher());
     EXPECT_EQ(FetchRequest::AllowPlaceholder,
               request.placeholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               imageResource->resourceRequest().httpHeaderField("range"));
     EXPECT_TRUE(imageResource->isPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::create(imageResource->getContent());
 
     ResourceResponse response(testURL, "image/jpeg", sizeof(kJpegImage),
                               nullAtom);
@@ skipping 35 matching lines @@
       {206, buildContentRange(sizeof(kBadImageData), sizeof(kBadImageData)),
        sizeof(kBadImageData)},
       {204, nullAtom, 0},
   };
   for (const auto& test : tests) {
     KURL testURL(ParsedURLString, kTestURL);
     ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
     FetchRequest request(testURL, FetchInitiatorInfo());
     request.setAllowImagePlaceholder();
-    ImageResource* imageResource = ImageResource::fetch(
-        request,
-        ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+    ImageResource* imageResource =
+        ImageResource::fetch(request, createFetcher());
     EXPECT_EQ(FetchRequest::AllowPlaceholder,
               request.placeholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               imageResource->resourceRequest().httpHeaderField("range"));
     EXPECT_TRUE(imageResource->isPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::create(imageResource->getContent());
 
     ResourceResponse response(testURL, "image/jpeg", test.dataSize, nullAtom);
     response.setHTTPStatusCode(test.statusCode);
@@ skipping 10 matching lines @@
 
 TEST(ImageResourceTest,
      FetchAllowPlaceholderFullResponseDecodeFailureWithReload) {
   const int kStatusCodes[] = {404, 500};
   for (int statusCode : kStatusCodes) {
     KURL testURL(ParsedURLString, kTestURL);
     ScopedMockedURLLoad scopedMockedURLLoad(testURL, GetTestFilePath());
 
     FetchRequest request(testURL, FetchInitiatorInfo());
     request.setAllowImagePlaceholder();
-    ImageResource* imageResource = ImageResource::fetch(
-        request,
-        ResourceFetcher::create(ImageResourceTestMockFetchContext::create()));
+    ImageResource* imageResource =
+        ImageResource::fetch(request, createFetcher());
     EXPECT_EQ(FetchRequest::AllowPlaceholder,
               request.placeholderImageRequestType());
     EXPECT_EQ("bytes=0-2047",
               imageResource->resourceRequest().httpHeaderField("range"));
     EXPECT_TRUE(imageResource->isPlaceholder());
     std::unique_ptr<MockImageResourceObserver> observer =
         MockImageResourceObserver::create(imageResource->getContent());
 
     static const char kBadImageData[] = "bad image data";
 
@@ skipping 119 matching lines @@
   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