ResourceFetcherTest: introduce FetchTestingPlatformSupport

third_party/WebKit/Source/core/fetch/ResourceFetcherTest.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 26 matching lines @@
 #include "core/fetch/MockFetchContext.h"
 #include "core/fetch/MockResource.h"
 #include "core/fetch/MockResourceClient.h"
 #include "core/fetch/RawResource.h"
 #include "core/fetch/ResourceLoader.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/exported/WrappedResourceResponse.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/HeapAllocator.h"
 #include "platform/heap/Member.h"
+#include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/scheduler/test/fake_web_task_runner.h"
+#include "platform/testing/TestingPlatformSupport.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/weburl_loader_mock.h"
+#include "platform/testing/weburl_loader_mock_factory_impl.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebURLLoader.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLResponse.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Allocator.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 constexpr char kTestResourceFilename[] = "white-1x1.png";
 constexpr char kTestResourceMimeType[] = "image/png";
 constexpr int kTestResourceSize = 103;  // size of web/tests/data/white-1x1.png
 }
 
-class ResourceFetcherTest : public ::testing::Test {};
+class FetchTestingWebURLLoaderMockFactory : public WebURLLoaderMockFactoryImpl {
+ public:
+  FetchTestingWebURLLoaderMockFactory()
+      : m_context(MockFetchContext::create(
+            MockFetchContext::kShouldLoadNewResource)) {}
+  ~FetchTestingWebURLLoaderMockFactory() override {}
+
+  MockFetchContext* context() { return m_context.get(); }
+
+ private:
+  void RunUntilIdle() override { m_context->runLoadingTaskRunnerUntilIdle(); }
+  Persistent<MockFetchContext> m_context;
+};
+
+class FetchTestingPlatform : public TestingPlatformSupportWithMockScheduler {
+ public:
+  FetchTestingPlatform()
+      : m_urlLoaderMockFactory(new FetchTestingWebURLLoaderMockFactory) {}
+  ~FetchTestingPlatform() override {}
+
+  // Platform:
+  WebURLError cancelledError(const WebURL& url) const override {
+    return ResourceError::ResourceError(errorDomainBlinkInternal, -1,
+                                        url.string(),
+                                        "cancelledError for testing");
+  }
+  WebURLLoaderMockFactory* getURLLoaderMockFactory() override {
+    return m_urlLoaderMockFactory.get();
+  }
+  WebURLLoader* createURLLoader() override {
+    return m_urlLoaderMockFactory->createURLLoader(
+        m_oldPlatform->createURLLoader());
+  }
+  MockFetchContext* context() { return m_urlLoaderMockFactory->context(); }
+
+ private:
+  std::unique_ptr<FetchTestingWebURLLoaderMockFactory> m_urlLoaderMockFactory;
+};
+
+class ResourceFetcherTest : public ::testing::Test {
+ public:
+  ResourceFetcherTest() {}
+  ~ResourceFetcherTest() override {}
+
+ protected:
+  MockFetchContext* context() { return m_platform->context(); }
+
+  ScopedTestingPlatformSupport<FetchTestingPlatform> m_platform;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ResourceFetcherTest);
+};
 
 TEST_F(ResourceFetcherTest, StartLoadAfterFrameDetach) {
   KURL secureURL(ParsedURLString, "https://secureorigin.test/image.png");
   // Try to request a url. The request should fail, and a resource in an error
   // state should be returned, and no resource should be present in the cache.
   ResourceFetcher* fetcher = ResourceFetcher::create(nullptr);
   ResourceRequest resourceRequest(secureURL);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
   FetchRequest fetchRequest =
       FetchRequest(resourceRequest, FetchInitiatorInfo());
   Resource* resource = RawResource::fetch(fetchRequest, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->errorOccurred());
   EXPECT_TRUE(resource->resourceError().isAccessCheck());
   EXPECT_FALSE(memoryCache()->resourceForURL(secureURL));
 
   // Start by calling startLoad() directly, rather than via requestResource().
   // This shouldn't crash.
   fetcher->startLoad(RawResource::create(secureURL, Resource::Raw));
 }
 
 TEST_F(ResourceFetcherTest, UseExistingResource) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   URLTestHelpers::registerMockedURLLoadWithCustomResponse(
       url, kTestResourceFilename, WebString::fromUTF8(""),
       WrappedResourceResponse(response));
 
@@ skipping 16 matching lines @@
   memoryCache()->add(resource);
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.setHTTPHeaderField(HTTPNames::Vary, "*");
   resource->responseReceived(response, nullptr);
   resource->finish();
   ASSERT_TRUE(resource->hasVaryHeader());
 
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
   ResourceRequest resourceRequest(url);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
   FetchRequest fetchRequest =
       FetchRequest(resourceRequest, FetchInitiatorInfo());
   Platform::current()->getURLLoaderMockFactory()->registerURL(
       url, WebURLResponse(), "");
   Resource* newResource = RawResource::fetch(fetchRequest, fetcher);
   EXPECT_NE(resource, newResource);
   newResource->loader()->cancel();
   memoryCache()->remove(newResource);
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
 
   memoryCache()->remove(resource);
 }
 
 TEST_F(ResourceFetcherTest, NavigationTimingInfo) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
 
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
   ResourceRequest resourceRequest(url);
   resourceRequest.setFrameType(WebURLRequest::FrameTypeNested);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextForm);
   FetchRequest fetchRequest =
       FetchRequest(resourceRequest, FetchInitiatorInfo());
   Platform::current()->getURLLoaderMockFactory()->registerURL(
       url, WebURLResponse(), "");
   Resource* resource =
       RawResource::fetchMainResource(fetchRequest, fetcher, SubstituteData());
   resource->responseReceived(response, nullptr);
@@ skipping 13 matching lines @@
   long long redirectEncodedDataLength = 123;
   redirectResponse.setEncodedDataLength(redirectEncodedDataLength);
   ResourceRequest redirectResourceRequest(url);
   fetcher->recordResourceTimingOnRedirect(resource, redirectResponse, false);
   EXPECT_EQ(navigationTimingInfo->transferSize(),
             encodedDataLength + redirectEncodedDataLength);
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
 }
 
 TEST_F(ResourceFetcherTest, VaryOnBack) {
-  MockFetchContext* context =
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource);
-  context->setCachePolicy(CachePolicyHistoryBuffer);
-  ResourceFetcher* fetcher = ResourceFetcher::create(context);
+  context()->setCachePolicy(CachePolicyHistoryBuffer);
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
   Resource* resource = RawResource::create(url, Resource::Raw);
   memoryCache()->add(resource);
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.setHTTPHeaderField(HTTPNames::Vary, "*");
   resource->responseReceived(response, nullptr);
   resource->finish();
   ASSERT_TRUE(resource->hasVaryHeader());
 
   ResourceRequest resourceRequest(url);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
   FetchRequest fetchRequest =
       FetchRequest(resourceRequest, FetchInitiatorInfo());
   Resource* newResource = RawResource::fetch(fetchRequest, fetcher);
   EXPECT_EQ(resource, newResource);
 
   memoryCache()->remove(newResource);
 }
 
 TEST_F(ResourceFetcherTest, VaryResource) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.setHTTPHeaderField(HTTPNames::Vary, "*");
   URLTestHelpers::registerMockedURLLoadWithCustomResponse(
       url, kTestResourceFilename, WebString::fromUTF8(""),
       WrappedResourceResponse(response));
@@ skipping 49 matching lines @@
 TEST_F(ResourceFetcherTest, RevalidateWhileFinishingLoading) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(200);
   response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600");
   response.setHTTPHeaderField(HTTPNames::ETag, "1234567890");
   URLTestHelpers::registerMockedURLLoadWithCustomResponse(
       url, kTestResourceFilename, WebString::fromUTF8(""),
       WrappedResourceResponse(response));
-  ResourceFetcher* fetcher1 = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher1 = ResourceFetcher::create(context());
   ResourceRequest request1(url);
   request1.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
   FetchRequest fetchRequest1 = FetchRequest(request1, FetchInitiatorInfo());
   Resource* resource1 = MockResource::fetch(fetchRequest1, fetcher1);
   Persistent<RequestSameResourceOnComplete> client =
       new RequestSameResourceOnComplete(resource1);
   resource1->addClient(client);
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
   EXPECT_TRUE(client->notifyFinishedCalled());
   resource1->removeClient(client);
   memoryCache()->remove(resource1);
 }
 
 TEST_F(ResourceFetcherTest, DontReuseMediaDataUrl) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
   ResourceRequest request(KURL(ParsedURLString, "data:text/html,foo"));
   request.setRequestContext(WebURLRequest::RequestContextVideo);
   ResourceLoaderOptions options;
   options.dataBufferingPolicy = DoNotBufferData;
   FetchRequest fetchRequest =
       FetchRequest(request, FetchInitiatorTypeNames::internal, options);
   Resource* resource1 = RawResource::fetchMedia(fetchRequest, fetcher);
   Resource* resource2 = RawResource::fetchMedia(fetchRequest, fetcher);
   EXPECT_NE(resource1, resource2);
   memoryCache()->remove(resource2);
@@ skipping 44 matching lines @@
 // Regression test for http://crbug.com/594072.
 // This emulates a modal dialog triggering a nested run loop inside
 // ResourceLoader::cancel(). If the ResourceLoader doesn't promptly cancel its
 // WebURLLoader before notifying its clients, a nested run loop  may send a
 // network response, leading to an invalid state transition in ResourceLoader.
 TEST_F(ResourceFetcherTest, ResponseOnCancel) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
                                         kTestResourceMimeType);
 
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
   ResourceRequest resourceRequest(url);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
   FetchRequest fetchRequest =
       FetchRequest(resourceRequest, FetchInitiatorInfo());
   Resource* resource = RawResource::fetch(fetchRequest, fetcher);
   Persistent<ServeRequestsOnCompleteClient> client =
       new ServeRequestsOnCompleteClient();
   resource->addClient(client);
   resource->loader()->cancel();
   resource->removeClient(client);
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
 }
 
 class ScopedMockRedirectRequester {
   STACK_ALLOCATED();
   WTF_MAKE_NONCOPYABLE(ScopedMockRedirectRequester);
 
  public:
-  ScopedMockRedirectRequester() : m_context(nullptr) {}
+  ScopedMockRedirectRequester(MockFetchContext* context) : m_context(context) {}
 
   ~ScopedMockRedirectRequester() { cleanUp(); }
 
   void registerRedirect(const WebString& fromURL, const WebString& toURL) {
     KURL redirectURL(ParsedURLString, fromURL);
     WebURLResponse redirectResponse;
     redirectResponse.setURL(redirectURL);
     redirectResponse.setHTTPStatusCode(301);
     redirectResponse.setHTTPHeaderField(HTTPNames::Location, toURL);
     redirectResponse.setEncodedDataLength(kRedirectResponseOverheadBytes);
     Platform::current()->getURLLoaderMockFactory()->registerURL(
         redirectURL, redirectResponse, "");
   }
 
   void registerFinalResource(const WebString& url) {
     KURL finalURL(ParsedURLString, url);
     URLTestHelpers::registerMockedURLLoad(finalURL, kTestResourceFilename);
   }
 
   void request(const WebString& url) {
-    DCHECK(!m_context);
-    m_context =
-        MockFetchContext::create(MockFetchContext::kShouldLoadNewResource);
     ResourceFetcher* fetcher = ResourceFetcher::create(m_context);
     ResourceRequest resourceRequest(url);
     resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
     FetchRequest fetchRequest =
         FetchRequest(resourceRequest, FetchInitiatorInfo());
     RawResource::fetch(fetchRequest, fetcher);
     Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   }
 
   void cleanUp() {
     Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs();
     memoryCache()->evictResources();
   }
 
-  MockFetchContext* context() const { return m_context; }
-
  private:
   Member<MockFetchContext> m_context;
 };
 
 TEST_F(ResourceFetcherTest, SameOriginRedirect) {
   const char redirectURL[] = "http://127.0.0.1:8000/redirect.html";
   const char finalURL[] = "http://127.0.0.1:8000/final.html";
-  ScopedMockRedirectRequester requester;
+  ScopedMockRedirectRequester requester(context());
   requester.registerRedirect(redirectURL, finalURL);
   requester.registerFinalResource(finalURL);
   requester.request(redirectURL);
 
   EXPECT_EQ(kRedirectResponseOverheadBytes + kTestResourceSize,
-            requester.context()->getTransferSize());
+            context()->getTransferSize());
 }
 
 TEST_F(ResourceFetcherTest, CrossOriginRedirect) {
   const char redirectURL[] = "http://otherorigin.test/redirect.html";
   const char finalURL[] = "http://127.0.0.1:8000/final.html";
-  ScopedMockRedirectRequester requester;
+  ScopedMockRedirectRequester requester(context());
   requester.registerRedirect(redirectURL, finalURL);
   requester.registerFinalResource(finalURL);
   requester.request(redirectURL);
 
-  EXPECT_EQ(kTestResourceSize, requester.context()->getTransferSize());
+  EXPECT_EQ(kTestResourceSize, context()->getTransferSize());
 }
 
 TEST_F(ResourceFetcherTest, ComplexCrossOriginRedirect) {
   const char redirectURL1[] = "http://127.0.0.1:8000/redirect1.html";
   const char redirectURL2[] = "http://otherorigin.test/redirect2.html";
   const char redirectURL3[] = "http://127.0.0.1:8000/redirect3.html";
   const char finalURL[] = "http://127.0.0.1:8000/final.html";
-  ScopedMockRedirectRequester requester;
+  ScopedMockRedirectRequester requester(context());
   requester.registerRedirect(redirectURL1, redirectURL2);
   requester.registerRedirect(redirectURL2, redirectURL3);
   requester.registerRedirect(redirectURL3, finalURL);
   requester.registerFinalResource(finalURL);
   requester.request(redirectURL1);
 
-  EXPECT_EQ(kTestResourceSize, requester.context()->getTransferSize());
+  EXPECT_EQ(kTestResourceSize, context()->getTransferSize());
 }
 
 TEST_F(ResourceFetcherTest, SynchronousRequest) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
                                         kTestResourceMimeType);
 
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
   ResourceRequest resourceRequest(url);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
   FetchRequest fetchRequest(resourceRequest, FetchInitiatorInfo());
   fetchRequest.makeSynchronous();
   Resource* resource = RawResource::fetch(fetchRequest, fetcher);
   EXPECT_TRUE(resource->isLoaded());
   EXPECT_EQ(ResourceLoadPriorityHighest,
             resource->resourceRequest().priority());
 
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
   memoryCache()->remove(resource);
 }
 
 TEST_F(ResourceFetcherTest, PreloadResourceTwice) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
                                         kTestResourceMimeType);
 
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   fetcher->preloadStarted(resource);
 
   FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
   Resource* newResource = MockResource::fetch(fetchRequest, fetcher);
   EXPECT_EQ(resource, newResource);
   fetcher->preloadStarted(resource);
 
   fetcher->clearPreloads(ResourceFetcher::ClearAllPreloads);
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
   EXPECT_FALSE(memoryCache()->contains(resource));
   EXPECT_FALSE(resource->isPreloaded());
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
                                         kTestResourceMimeType);
 
   // Link preload preload scanner
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   fetchRequestOriginal.setLinkPreload(true);
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
@@ skipping 15 matching lines @@
   Resource* newResource = MockResource::fetch(fetchRequest, fetcher);
   Persistent<MockResourceClient> client = new MockResourceClient(newResource);
   EXPECT_EQ(resource, newResource);
   EXPECT_FALSE(resource->isLinkPreload());
 
   // DCL reached
   fetcher->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads);
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
   EXPECT_TRUE(memoryCache()->contains(resource));
   EXPECT_FALSE(resource->isPreloaded());
+
+  memoryCache()->remove(resource);
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndUse) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
-  ResourceFetcher* fetcher2 = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
+  ResourceFetcher* fetcher2 = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
                                         kTestResourceMimeType);
 
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   fetchRequestOriginal.setLinkPreload(true);
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->isLinkPreload());
@@ skipping 54 matching lines @@
   EXPECT_TRUE(resource->isPreloaded());
   fetcher->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads);
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
   EXPECT_TRUE(memoryCache()->contains(resource));
   EXPECT_TRUE(resource->isPreloaded());
 
   // DCL reached on second fetcher
   fetcher2->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads);
   EXPECT_TRUE(memoryCache()->contains(resource));
   EXPECT_FALSE(resource->isPreloaded());
+
+  memoryCache()->remove(resource);
 }
 
 TEST_F(ResourceFetcherTest, Revalidate304) {
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
   Resource* resource = RawResource::create(url, Resource::Raw);
   memoryCache()->add(resource);
   ResourceResponse response;
   response.setURL(url);
   response.setHTTPStatusCode(304);
   response.setHTTPHeaderField("etag", "1234567890");
   resource->responseReceived(response, nullptr);
   resource->finish();
 
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
   ResourceRequest resourceRequest(url);
   resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
   FetchRequest fetchRequest =
       FetchRequest(resourceRequest, FetchInitiatorInfo());
   Platform::current()->getURLLoaderMockFactory()->registerURL(
       url, WebURLResponse(), "");
   Resource* newResource = RawResource::fetch(fetchRequest, fetcher);
   fetcher->stopFetching();
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
 
   EXPECT_NE(resource, newResource);
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) {
-  ResourceFetcher* fetcher = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
-  ResourceFetcher* fetcher2 = ResourceFetcher::create(
-      MockFetchContext::create(MockFetchContext::kShouldLoadNewResource));
+  ResourceFetcher* fetcher = ResourceFetcher::create(context());
+  ResourceFetcher* fetcher2 = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
   URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
                                         kTestResourceMimeType);
 
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   fetchRequestOriginal.setLinkPreload(true);
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->isLinkPreload());
   fetcher->preloadStarted(resource);
 
   // Resource created by parser on the second fetcher
   FetchRequest fetchRequest2 = FetchRequest(url, FetchInitiatorInfo());
   Resource* newResource2 = MockResource::fetch(fetchRequest2, fetcher2);
   Persistent<MockResourceClient> client2 = new MockResourceClient(newResource2);
   EXPECT_EQ(resource, newResource2);
   EXPECT_FALSE(fetcher2->isFetching());
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
 }
 
 }  // namespace blink