TEST_F(ResourceFetcherTest, VaryImage) { ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); 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, testImageFilename, WebString::fromUTF8(""), WrappedResourceResponse(response)); FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); Resource* resource = ImageResource::fetch(fetchRequestOriginal, fetcher); ASSERT_TRUE(resource); Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); ASSERT_TRUE(resource->hasVaryHeader()); FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); Resource* newResource = ImageResource::fetch(fetchRequest, fetcher); EXPECT_EQ(resource, newResource); memoryCache()->remove(newResource); Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); }
TEST_F(ResourceFetcherTest, RevalidateDeferedResourceFromTwoInitiators) { KURL url(ParsedURLString, "http://127.0.0.1:8000/font.woff"); ResourceResponse response; response.setURL(url); response.setHTTPStatusCode(200); response.setHTTPHeaderField(HTTPNames::ETag, "1234567890"); Platform::current()->getURLLoaderMockFactory()->registerURL( url, WrappedResourceResponse(response), ""); ResourceFetcherTestMockFetchContext* context = ResourceFetcherTestMockFetchContext::create(); ResourceFetcher* fetcher = ResourceFetcher::create(context); // Fetch to cache a resource. ResourceRequest request1(url); FetchRequest fetchRequest1 = FetchRequest(request1, FetchInitiatorInfo()); Resource* resource1 = FontResource::fetch(fetchRequest1, fetcher); ASSERT_TRUE(resource1); fetcher->startLoad(resource1); Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); EXPECT_TRUE(resource1->isLoaded()); EXPECT_FALSE(resource1->errorOccurred()); // Set the context as it is on reloads. context->setLoadComplete(true); context->setCachePolicy(CachePolicyRevalidate); // Revalidate the resource. ResourceRequest request2(url); FetchRequest fetchRequest2 = FetchRequest(request2, FetchInitiatorInfo()); Resource* resource2 = FontResource::fetch(fetchRequest2, fetcher); ASSERT_TRUE(resource2); EXPECT_EQ(resource1, resource2); EXPECT_TRUE(resource2->isCacheValidator()); EXPECT_TRUE(resource2->stillNeedsLoad()); // Fetch the same resource again before actual load operation starts. ResourceRequest request3(url); FetchRequest fetchRequest3 = FetchRequest(request3, FetchInitiatorInfo()); Resource* resource3 = FontResource::fetch(fetchRequest3, fetcher); ASSERT_TRUE(resource3); EXPECT_EQ(resource2, resource3); EXPECT_TRUE(resource3->isCacheValidator()); EXPECT_TRUE(resource3->stillNeedsLoad()); // startLoad() can be called from any initiator. Here, call it from the // latter. fetcher->startLoad(resource3); Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); EXPECT_TRUE(resource3->isLoaded()); EXPECT_FALSE(resource3->errorOccurred()); EXPECT_TRUE(resource2->isLoaded()); EXPECT_FALSE(resource2->errorOccurred()); memoryCache()->remove(resource1); }
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(ResourceFetcherTestMockFetchContext::create()); 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, Vary) { 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()); ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); 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, 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, testImageFilename, WebString::fromUTF8(""), WrappedResourceResponse(response)); ResourceFetcher* fetcher1 = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); ResourceRequest request1(url); request1.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache"); FetchRequest fetchRequest1 = FetchRequest(request1, FetchInitiatorInfo()); Resource* resource1 = ImageResource::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, VaryOnBack) { ResourceFetcherTestMockFetchContext* context = ResourceFetcherTestMockFetchContext::create(); 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); }
already_AddRefed<Promise> WorkerGlobalScope::Fetch(const RequestOrUSVString& aInput, const RequestInit& aInit, CallerType aCallerType, ErrorResult& aRv) { return FetchRequest(this, aInput, aInit, aCallerType, aRv); }
void expectHeader(const char* input, const char* headerName, bool isPresent, const char* headerValue) { KURL inputURL(ParsedURLString, input); FetchRequest fetchRequest = FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo()); fetchContext->addClientHintsIfNecessary(fetchRequest); EXPECT_STREQ(isPresent ? headerValue : "", fetchRequest.resourceRequest().httpHeaderField(headerName).utf8().data()); }
void HTMLImportElement::load() { if (m_child || !hasAttribute(HTMLNames::srcAttr)) return; KURL url = document().completeURL(getAttribute(HTMLNames::srcAttr)); m_child = document().ensureImportsController().load(document().import(), this, FetchRequest(ResourceRequest(url))); if (m_child) m_child->ownerInserted(); }
already_AddRefed<Promise> Cache::AddAll(const GlobalObject& aGlobal, nsTArray<RefPtr<Request>>&& aRequestList, CallerType aCallerType, ErrorResult& aRv) { MOZ_DIAGNOSTIC_ASSERT(mActor); // If there is no work to do, then resolve immediately if (aRequestList.IsEmpty()) { RefPtr<Promise> promise = Promise::Create(mGlobal, aRv); if (NS_WARN_IF(!promise)) { return nullptr; } promise->MaybeResolveWithUndefined(); return promise.forget(); } AutoTArray<RefPtr<Promise>, 256> fetchList; fetchList.SetCapacity(aRequestList.Length()); // Begin fetching each request in parallel. For now, if an error occurs just // abandon our previous fetch calls. In theory we could cancel them in the // future once fetch supports it. for (uint32_t i = 0; i < aRequestList.Length(); ++i) { RequestOrUSVString requestOrString; requestOrString.SetAsRequest() = aRequestList[i]; RefPtr<Promise> fetch = FetchRequest(mGlobal, requestOrString, RequestInit(), aCallerType, aRv); if (NS_WARN_IF(aRv.Failed())) { return nullptr; } fetchList.AppendElement(std::move(fetch)); } RefPtr<Promise> promise = Promise::Create(mGlobal, aRv); if (NS_WARN_IF(aRv.Failed())) { return nullptr; } RefPtr<FetchHandler> handler = new FetchHandler(mActor->GetWorkerHolder(), this, std::move(aRequestList), promise); RefPtr<Promise> fetchPromise = Promise::All(aGlobal.Context(), fetchList, aRv); if (NS_WARN_IF(aRv.Failed())) { return nullptr; } fetchPromise->AppendNativeHandler(handler); return promise.forget(); }
void request(const WebString& url) { DCHECK(!m_context); m_context = ResourceFetcherTestMockFetchContext::create(); 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(); }
TEST_F(ResourceFetcherTest, StartLoadAfterFrameDetach) { KURL secureURL(ParsedURLString, "https://secureorigin.test/image.png"); // Try to request a url. The request should fail, no resource should be returned, // and no resource should be present in the cache. RefPtrWillBeRawPtr<ResourceFetcher> fetcher = ResourceFetcher::create(FetchContext::create()); FetchRequest fetchRequest = FetchRequest(ResourceRequest(secureURL), FetchInitiatorInfo()); ResourcePtr<ImageResource> image = fetcher->fetchImage(fetchRequest); EXPECT_EQ(image.get(), static_cast<ImageResource*>(0)); EXPECT_EQ(memoryCache()->resourceForURL(secureURL), static_cast<Resource*>(0)); }
void expectHTTPSHeader(const char* input, WebURLRequest::FrameType frameType, bool shouldPrefer) { KURL inputURL(ParsedURLString, input); FetchRequest fetchRequest = FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo()); fetchRequest.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextScript); fetchRequest.mutableResourceRequest().setFrameType(frameType); fetchContext->upgradeInsecureRequest(fetchRequest); EXPECT_STREQ(shouldPrefer ? "1" : "", fetchRequest.resourceRequest().httpHeaderField(HTTPNames::Upgrade_Insecure_Requests).utf8().data()); }
TEST_F(ResourceFetcherTest, LinkPreloadImageAndUse) { ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); URLTestHelpers::registerMockedURLLoad(url, testImageFilename, "image/png"); // Link preload preload scanner FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); fetchRequestOriginal.setLinkPreload(true); Resource* resource = ImageResource::fetch(fetchRequestOriginal, fetcher); ASSERT_TRUE(resource); EXPECT_TRUE(resource->isLinkPreload()); Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); fetcher->preloadStarted(resource); // Image preload scanner FetchRequest fetchRequestPreloadScanner = FetchRequest(url, FetchInitiatorInfo()); Resource* imgPreloadScannerResource = ImageResource::fetch(fetchRequestPreloadScanner, fetcher); EXPECT_EQ(resource, imgPreloadScannerResource); EXPECT_FALSE(resource->isLinkPreload()); fetcher->preloadStarted(resource); // Image created by parser FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); Resource* newResource = ImageResource::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()); }
TEST_F(ResourceFetcherTest, DontReuseMediaDataUrl) { ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); 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); }
TEST_F(ResourceFetcherTest, PreloadImageTwice) { ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); URLTestHelpers::registerMockedURLLoad(url, testImageFilename, "image/png"); FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); Resource* resource = ImageResource::fetch(fetchRequestOriginal, fetcher); ASSERT_TRUE(resource); Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); fetcher->preloadStarted(resource); FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); Resource* newResource = ImageResource::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()); }
void expectHeader(const char* input, const char* headerName, bool isPresent, const char* headerValue, float width = 0) { KURL inputURL(ParsedURLString, input); FetchRequest fetchRequest = FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo()); if (width > 0) { FetchRequest::ResourceWidth resourceWidth; resourceWidth.width = width; resourceWidth.isSet = true; fetchRequest.setResourceWidth(resourceWidth); } fetchContext->addClientHintsIfNecessary(fetchRequest); EXPECT_STREQ(isPresent ? headerValue : "", fetchRequest.resourceRequest().httpHeaderField(headerName).utf8().data()); }
void expectUpgrade(const char* input, WebURLRequest::RequestContext requestContext, WebURLRequest::FrameType frameType, const char* expected) { KURL inputURL(ParsedURLString, input); KURL expectedURL(ParsedURLString, expected); FetchRequest fetchRequest = FetchRequest(ResourceRequest(inputURL), FetchInitiatorInfo()); fetchRequest.mutableResourceRequest().setRequestContext(requestContext); fetchRequest.mutableResourceRequest().setFrameType(frameType); fetchContext->upgradeInsecureRequest(fetchRequest); EXPECT_STREQ(expectedURL.getString().utf8().data(), fetchRequest.resourceRequest().url().getString().utf8().data()); EXPECT_EQ(expectedURL.protocol(), fetchRequest.resourceRequest().url().protocol()); EXPECT_EQ(expectedURL.host(), fetchRequest.resourceRequest().url().host()); EXPECT_EQ(expectedURL.port(), fetchRequest.resourceRequest().url().port()); EXPECT_EQ(expectedURL.hasPort(), fetchRequest.resourceRequest().url().hasPort()); EXPECT_EQ(expectedURL.path(), fetchRequest.resourceRequest().url().path()); }
// 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, testImageFilename, "image/png"); ResourceFetcher* fetcher = ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create()); 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); }
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)); }