platform/testing/{URL|Unit}TestHelpers improvements

third_party/WebKit/Source/platform/loader/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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/loader/fetch/ResourceFetcher.h"
 
+#include <memory>
 #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/loader/fetch/FetchInitiatorInfo.h"
 #include "platform/loader/fetch/FetchInitiatorTypeNames.h"
 #include "platform/loader/fetch/FetchRequest.h"
 #include "platform/loader/fetch/FetchTestingPlatformSupport.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/MockFetchContext.h"
 #include "platform/loader/fetch/MockResource.h"
 #include "platform/loader/fetch/MockResourceClient.h"
 #include "platform/loader/fetch/RawResource.h"
 #include "platform/loader/fetch/ResourceLoader.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/UnitTestHelpers.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
+constexpr int kTestResourceSize = 103;  // size of white-1x1.png
+
+void registerMockedURLLoadWithCustomResponse(const KURL& url,
+                                             const ResourceResponse& response) {
+  URLTestHelpers::registerMockedURLLoadWithCustomResponse(
+      url, testing::platformTestDataPath(kTestResourceFilename),
+      WrappedResourceResponse(response));
 }
 
+void registerMockedURLLoad(const KURL& url) {
+  URLTestHelpers::registerMockedURLLoad(
+      url, testing::platformTestDataPath(kTestResourceFilename),
+      kTestResourceMimeType);
+}
+
+}  // namespace
+
 class ResourceFetcherTest : public ::testing::Test {
  public:
   ResourceFetcherTest() = default;
   ~ResourceFetcherTest() override { memoryCache()->evictResources(); }
 
  protected:
   MockFetchContext* context() { return m_platform->context(); }
 
   ScopedTestingPlatformSupport<FetchTestingPlatformSupport> m_platform;
 
@@ skipping 22 matching lines @@
 }
 
 TEST_F(ResourceFetcherTest, UseExistingResource) {
   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));
+  registerMockedURLLoadWithCustomResponse(url, response);
 
   FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
   Resource* resource = MockResource::fetch(fetchRequest, fetcher);
   ASSERT_TRUE(resource);
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   EXPECT_TRUE(resource->isLoaded());
   EXPECT_TRUE(memoryCache()->contains(resource));
 
   Resource* newResource = MockResource::fetch(fetchRequest, fetcher);
   EXPECT_EQ(resource, newResource);
@@ skipping 88 matching lines @@
 
 TEST_F(ResourceFetcherTest, VaryResource) {
   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));
+  registerMockedURLLoadWithCustomResponse(url, response);
 
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   ASSERT_TRUE(resource->hasVaryHeader());
 
   FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
   Resource* newResource = MockResource::fetch(fetchRequest, fetcher);
   EXPECT_EQ(resource, newResource);
@@ skipping 33 matching lines @@
   bool m_notifyFinishedCalled;
 };
 
 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));
+  registerMockedURLLoadWithCustomResponse(url, response);
   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();
   EXPECT_TRUE(client->notifyFinishedCalled());
@@ skipping 55 matching lines @@
   String debugName() const override { return "ServeRequestsOnCompleteClient"; }
 };
 
 // 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);
+  registerMockedURLLoad(url);
 
   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);
@@ skipping 15 matching lines @@
     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);
+    registerMockedURLLoad(finalURL);
   }
 
   void request(const WebString& url) {
     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();
@@ skipping 36 matching lines @@
   requester.registerRedirect(redirectURL2, redirectURL3);
   requester.registerRedirect(redirectURL3, finalURL);
   requester.registerFinalResource(finalURL);
   requester.request(redirectURL1);
 
   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);
+  registerMockedURLLoad(url);
 
   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());
 }
 
 TEST_F(ResourceFetcherTest, PreloadResourceTwice) {
   ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
-  URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
-                                        kTestResourceMimeType);
+  registerMockedURLLoad(url);
 
   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);
   EXPECT_FALSE(memoryCache()->contains(resource));
   EXPECT_FALSE(resource->isPreloaded());
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
   ResourceFetcher* fetcher = ResourceFetcher::create(context());
 
   KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png");
-  URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename,
-                                        kTestResourceMimeType);
+  registerMockedURLLoad(url);
 
   // Link preload preload scanner
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   fetchRequestOriginal.setLinkPreload(true);
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->isLinkPreload());
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   fetcher->preloadStarted(resource);
 
@@ skipping 17 matching lines @@
   fetcher->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads);
   EXPECT_TRUE(memoryCache()->contains(resource));
   EXPECT_FALSE(resource->isPreloaded());
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndUse) {
   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);
+  registerMockedURLLoad(url);
 
   FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo());
   fetchRequestOriginal.setLinkPreload(true);
   Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->isLinkPreload());
   Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   fetcher->preloadStarted(resource);
 
   FetchRequest fetchRequestSecond = FetchRequest(url, FetchInitiatorInfo());
@@ skipping 80 matching lines @@
   fetcher->stopFetching();
 
   EXPECT_NE(resource, newResource);
 }
 
 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) {
   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);
+  registerMockedURLLoad(url);
 
   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();
 }
 
 }  // namespace blink