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, 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);
}
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, 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);
}
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());
}
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 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();
}
void notifyFinished(Resource* resource) override {
EXPECT_EQ(m_resource, resource);
ResourceFetcherTestMockFetchContext* context =
ResourceFetcherTestMockFetchContext::create();
context->setCachePolicy(CachePolicyRevalidate);
ResourceFetcher* fetcher2 = ResourceFetcher::create(context);
FetchRequest fetchRequest2(m_resource->url(), FetchInitiatorInfo());
Resource* resource2 = ImageResource::fetch(fetchRequest2, fetcher2);
EXPECT_EQ(m_resource, resource2);
m_notifyFinishedCalled = true;
}
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, 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());
}
TEST_F(FrameFetchContextTest, ModifyPriorityForLowPriorityIframes)
{
Settings* settings = document->frame()->settings();
settings->setLowPriorityIframes(false);
FetchRequest request(ResourceRequest("http://www.example.com"), FetchInitiatorInfo());
FrameFetchContext* childFetchContext = createChildFrame();
// No low priority iframes, expect default values.
EXPECT_EQ(ResourceLoadPriorityVeryHigh, childFetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryHigh));
EXPECT_EQ(ResourceLoadPriorityMedium, childFetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium));
// Low priority iframes enabled, everything should be low priority
settings->setLowPriorityIframes(true);
EXPECT_EQ(ResourceLoadPriorityVeryLow, childFetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryHigh));
EXPECT_EQ(ResourceLoadPriorityVeryLow, childFetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium));
}
TEST_F(CachingCorrectnessTest, PostToSameURLTwice)
{
ResourceRequest request1(KURL(ParsedURLString, kResourceURL));
request1.setHTTPMethod(HTTPNames::POST);
ResourcePtr<Resource> resource1 = new Resource(ResourceRequest(request1.url()), Resource::Raw);
resource1->setLoading(true);
memoryCache()->add(resource1.get());
ResourceRequest request2(KURL(ParsedURLString, kResourceURL));
request2.setHTTPMethod(HTTPNames::POST);
FetchRequest fetch2(request2, FetchInitiatorInfo());
ResourcePtr<Resource> resource2 = RawResource::fetchSynchronously(fetch2, fetcher());
EXPECT_EQ(resource2, memoryCache()->resourceForURL(request2.url()));
EXPECT_NE(resource1, resource2);
}
// 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);
}
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());
}
TEST(ImageResourceTest, CancelOnDecodeError) {
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
ScopedRegisteredURL scopedRegisteredURL(testURL);
ResourceFetcher* fetcher =
ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
FetchRequest request(testURL, FetchInitiatorInfo());
ImageResource* cachedImage = ImageResource::fetch(request, fetcher);
cachedImage->loader()->didReceiveResponse(
nullptr, WrappedResourceResponse(ResourceResponse(
testURL, "image/jpeg", 18, nullAtom, String())),
nullptr);
cachedImage->loader()->didReceiveData(nullptr, "notactuallyanimage", 18, 18,
18);
EXPECT_EQ(Resource::DecodeError, cachedImage->getStatus());
EXPECT_FALSE(cachedImage->isLoading());
}
TEST_F(ResourceFetcherTest, SynchronousRequest) {
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(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, 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));
}
Resource* MemoryCacheCorrectnessTestHelper::fetch() {
ResourceRequest resourceRequest(KURL(ParsedURLString, kResourceURL));
resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal);
FetchRequest fetchRequest(resourceRequest, FetchInitiatorInfo());
return RawResource::fetch(fetchRequest, fetcher());
}
TEST_F(FrameFetchContextTest, ModifyPriorityForExperiments)
{
Settings* settings = document->frame()->settings();
FetchRequest request(ResourceRequest("http://www.example.com"), FetchInitiatorInfo());
FetchRequest preloadRequest(ResourceRequest("http://www.example.com"), FetchInitiatorInfo());
preloadRequest.setForPreload(true);
FetchRequest deferredRequest(ResourceRequest("http://www.example.com"), FetchInitiatorInfo());
deferredRequest.setDefer(FetchRequest::LazyLoad);
// Start with all experiments disabled.
settings->setFEtchIncreaseAsyncScriptPriority(false);
settings->setFEtchIncreaseFontPriority(false);
settings->setFEtchDeferLateScripts(false);
settings->setFEtchIncreasePriorities(false);
// Base case, no priority change. Note that this triggers m_imageFetched, which will matter for setFetchDeferLateScripts() case below.
EXPECT_EQ(ResourceLoadPriorityVeryLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryLow, Resource::Image, request, ResourcePriority::NotVisible));
// Image visibility should increase priority
EXPECT_EQ(ResourceLoadPriorityLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryLow, Resource::Image, request, ResourcePriority::Visible));
// Font priority with and without fetchIncreaseFontPriority()
EXPECT_EQ(ResourceLoadPriorityMedium, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Font, request, ResourcePriority::NotVisible));
settings->setFEtchIncreaseFontPriority(true);
EXPECT_EQ(ResourceLoadPriorityHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Font, request, ResourcePriority::NotVisible));
// Basic script cases
EXPECT_EQ(ResourceLoadPriorityMedium, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, request, ResourcePriority::NotVisible));
EXPECT_EQ(ResourceLoadPriorityMedium, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, preloadRequest, ResourcePriority::NotVisible));
// Enable deferring late scripts. Preload priority should drop.
settings->setFEtchDeferLateScripts(true);
EXPECT_EQ(ResourceLoadPriorityLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, preloadRequest, ResourcePriority::NotVisible));
// Enable increasing priority of async scripts.
EXPECT_EQ(ResourceLoadPriorityLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, deferredRequest, ResourcePriority::NotVisible));
settings->setFEtchIncreaseAsyncScriptPriority(true);
EXPECT_EQ(ResourceLoadPriorityMedium, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, deferredRequest, ResourcePriority::NotVisible));
// Enable increased priorities for the remainder.
settings->setFEtchIncreasePriorities(true);
// Re-test image priority based on visibility with increased priorities
EXPECT_EQ(ResourceLoadPriorityLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryLow, Resource::Image, request, ResourcePriority::NotVisible));
EXPECT_EQ(ResourceLoadPriorityHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryLow, Resource::Image, request, ResourcePriority::Visible));
// Re-test font priority with increased prioriries
settings->setFEtchIncreaseFontPriority(false);
EXPECT_EQ(ResourceLoadPriorityHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Font, request, ResourcePriority::NotVisible));
settings->setFEtchIncreaseFontPriority(true);
EXPECT_EQ(ResourceLoadPriorityVeryHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Font, request, ResourcePriority::NotVisible));
// Re-test basic script cases and deferring late script case with increased prioriries
settings->setFEtchDeferLateScripts(false);
EXPECT_EQ(ResourceLoadPriorityVeryHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, request, ResourcePriority::NotVisible));
EXPECT_EQ(ResourceLoadPriorityHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, preloadRequest, ResourcePriority::NotVisible));
// Re-test deferring late scripts.
settings->setFEtchDeferLateScripts(true);
EXPECT_EQ(ResourceLoadPriorityMedium, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, preloadRequest, ResourcePriority::NotVisible));
// Re-test increasing priority of async scripts. Should ignore general incraesed priorities.
settings->setFEtchIncreaseAsyncScriptPriority(false);
EXPECT_EQ(ResourceLoadPriorityLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, deferredRequest, ResourcePriority::NotVisible));
settings->setFEtchIncreaseAsyncScriptPriority(true);
EXPECT_EQ(ResourceLoadPriorityMedium, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityMedium, Resource::Script, deferredRequest, ResourcePriority::NotVisible));
// Ensure we don't go out of bounds
settings->setFEtchIncreasePriorities(true);
EXPECT_EQ(ResourceLoadPriorityVeryHigh, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryHigh, Resource::Script, request, ResourcePriority::NotVisible));
settings->setFEtchIncreasePriorities(false);
settings->setFEtchDeferLateScripts(true);
EXPECT_EQ(ResourceLoadPriorityVeryLow, fetchContext->modifyPriorityForExperiments(ResourceLoadPriorityVeryLow, Resource::Script, preloadRequest, ResourcePriority::NotVisible));
}
void continueAfterPingLoaderImpl(InstrumentingAgents* instrumentingAgents, unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& response)
{
willSendRequestImpl(instrumentingAgents, identifier, loader, request, response, FetchInitiatorInfo());
}
TEST(ImageResourceTest, ReloadIfLoFiDuringFetch) {
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
ScopedRegisteredURL scopedRegisteredURL(testURL);
ResourceRequest request(testURL);
request.setLoFiState(WebURLRequest::LoFiOn);
FetchRequest fetchRequest(request, FetchInitiatorInfo());
ResourceFetcher* fetcher =
ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
ImageResource* cachedImage = ImageResource::fetch(fetchRequest, fetcher);
Persistent<MockImageResourceClient> client =
new MockImageResourceClient(cachedImage);
// Send the image response.
Vector<unsigned char> jpeg = jpegImage();
ResourceResponse initialResourceResponse(testURL, "image/jpeg", jpeg.size(),
nullAtom, String());
initialResourceResponse.addHTTPHeaderField("chrome-proxy", "q=low");
cachedImage->loader()->didReceiveResponse(
nullptr, WrappedResourceResponse(initialResourceResponse));
cachedImage->loader()->didReceiveData(
nullptr, reinterpret_cast<const char*>(jpeg.data()), jpeg.size(),
jpeg.size(), jpeg.size());
EXPECT_FALSE(cachedImage->errorOccurred());
ASSERT_TRUE(cachedImage->hasImage());
EXPECT_FALSE(cachedImage->getImage()->isNull());
EXPECT_EQ(1, client->imageChangedCount());
EXPECT_EQ(jpeg.size(), client->encodedSizeOnLastImageChanged());
EXPECT_FALSE(client->notifyFinishedCalled());
EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
EXPECT_EQ(1, cachedImage->getImage()->width());
EXPECT_EQ(1, cachedImage->getImage()->height());
// Call reloadIfLoFi() while the image is still loading.
cachedImage->reloadIfLoFi(fetcher);
EXPECT_FALSE(cachedImage->errorOccurred());
EXPECT_FALSE(cachedImage->resourceBuffer());
EXPECT_FALSE(cachedImage->hasImage());
EXPECT_EQ(2, client->imageChangedCount());
EXPECT_EQ(0U, client->encodedSizeOnLastImageChanged());
// The client should not have been notified of completion yet, since the image
// is still loading.
EXPECT_FALSE(client->notifyFinishedCalled());
Vector<unsigned char> jpeg2 = jpegImage2();
cachedImage->loader()->didReceiveResponse(
nullptr, WrappedResourceResponse(ResourceResponse(
testURL, "image/jpeg", jpeg.size(), nullAtom, String())),
nullptr);
cachedImage->loader()->didReceiveData(
nullptr, reinterpret_cast<const char*>(jpeg2.data()), jpeg2.size(),
jpeg2.size(), jpeg2.size());
cachedImage->loader()->didFinishLoading(nullptr, 0.0, jpeg2.size());
EXPECT_FALSE(cachedImage->errorOccurred());
ASSERT_TRUE(cachedImage->hasImage());
EXPECT_FALSE(cachedImage->getImage()->isNull());
EXPECT_EQ(jpeg2.size(), client->encodedSizeOnLastImageChanged());
// The client should have been notified of completion only after the reload
// completed.
EXPECT_TRUE(client->notifyFinishedCalled());
EXPECT_EQ(jpeg2.size(), client->encodedSizeOnNotifyFinished());
EXPECT_EQ(jpeg2.size(), client->encodedSizeOnImageNotifyFinished());
EXPECT_TRUE(cachedImage->getImage()->isBitmapImage());
EXPECT_EQ(50, cachedImage->getImage()->width());
EXPECT_EQ(50, cachedImage->getImage()->height());
}
