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));
}
