NetworkResourceLoader::ShouldContinueDidReceiveResponse NetworkResourceLoader::sharedDidReceiveResponse(const WebCore::ResourceResponse& receivedResponse)
{
m_response = receivedResponse;
m_response.setSource(ResourceResponse::Source::Network);
if (m_parameters.needsCertificateInfo)
m_response.includeCertificateInfo();
// For multipart/x-mixed-replace didReceiveResponseAsync gets called multiple times and buffering would require special handling.
if (!isSynchronous() && m_response.isMultipart())
m_bufferedData = nullptr;
bool shouldSendDidReceiveResponse = true;
#if ENABLE(NETWORK_CACHE)
if (m_response.isMultipart())
m_bufferedDataForCache = nullptr;
if (m_cacheEntryForValidation) {
bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
if (validationSucceeded) {
NetworkCache::singleton().update(originalRequest(), m_parameters.webPageID, *m_cacheEntryForValidation, m_response);
// If the request was conditional then this revalidation was not triggered by the network cache and we pass the
// 304 response to WebCore.
if (originalRequest().isConditional())
m_cacheEntryForValidation = nullptr;
} else
m_cacheEntryForValidation = nullptr;
}
shouldSendDidReceiveResponse = !m_cacheEntryForValidation;
#endif
bool shouldWaitContinueDidReceiveResponse = originalRequest().requester() == ResourceRequest::Requester::Main;
if (shouldSendDidReceiveResponse) {
if (isSynchronous())
m_synchronousLoadData->response = m_response;
else {
if (!sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(m_response, shouldWaitContinueDidReceiveResponse)))
return ShouldContinueDidReceiveResponse::No;
}
}
// For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message.
bool shouldContinueDidReceiveResponse = !shouldWaitContinueDidReceiveResponse;
#if ENABLE(NETWORK_CACHE)
shouldContinueDidReceiveResponse = shouldContinueDidReceiveResponse || m_cacheEntryForValidation;
#endif
if (!shouldContinueDidReceiveResponse)
return ShouldContinueDidReceiveResponse::No;
return ShouldContinueDidReceiveResponse::Yes;
}
void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
{
if (isSynchronous()) {
m_synchronousLoadData->response = entry->response();
sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer());
} else {
bool needsContinueDidReceiveResponseMessage = isMainResource();
sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), needsContinueDidReceiveResponseMessage));
#if ENABLE(SHAREABLE_RESOURCE)
if (!entry->shareableResourceHandle().isNull())
send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle(), currentTime()));
else {
#endif
bool shouldContinue = sendBufferMaybeAborting(*entry->buffer(), entry->buffer()->size());
if (!shouldContinue)
return;
send(Messages::WebResourceLoader::DidFinishResourceLoad(currentTime()));
#if ENABLE(SHAREABLE_RESOURCE)
}
#endif
}
cleanup();
}
void NetworkResourceLoader::didFinishLoading(double finishTime)
{
NETWORKRESOURCELOADER_LOG_ALWAYS("Finished loading network resource: loader = %p, pageID = %llu, frameID = %llu, isMainResource = %d, isSynchronous = %d", this, static_cast<unsigned long long>(m_parameters.webPageID), static_cast<unsigned long long>(m_parameters.webFrameID), isMainResource(), isSynchronous());
#if ENABLE(NETWORK_CACHE)
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTFMove(m_cacheEntryForValidation));
return;
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && !m_bufferedData->isEmpty()) {
// FIXME: Pass a real value or remove the encoded data size feature.
bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1);
if (!shouldContinue)
return;
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
#if ENABLE(NETWORK_CACHE)
tryStoreAsCacheEntry();
#endif
cleanup();
}
void NetworkResourceLoader::sendBuffer(SharedBuffer& buffer, size_t encodedDataLength)
{
ASSERT(!isSynchronous());
IPC::SharedBufferDataReference dataReference(&buffer);
send(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
}
void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request, WebCore::ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
{
++m_redirectCount;
if (isSynchronous()) {
ResourceRequest overridenRequest = redirectRequest;
// FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
// This includes at least updating host records, and comparing the current request instead of the original request here.
if (!protocolHostAndPortAreEqual(originalRequest().url(), redirectRequest.url())) {
ASSERT(m_synchronousLoadData->error.isNull());
m_synchronousLoadData->error = SynchronousLoaderClient::platformBadResponseError();
m_networkLoad->clearCurrentRequest();
overridenRequest = ResourceRequest();
}
continueWillSendRequest(WTFMove(overridenRequest));
return;
}
send(Messages::WebResourceLoader::WillSendRequest(redirectRequest, redirectResponse));
#if ENABLE(NETWORK_CACHE)
if (canUseCachedRedirect(request))
NetworkCache::singleton().storeRedirect(request, redirectResponse, redirectRequest);
#else
UNUSED_PARAM(request);
#endif
}
void NetworkResourceLoader::didSendData(ResourceHandle* handle, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
ASSERT_UNUSED(handle, handle == m_handle);
if (!isSynchronous())
send(Messages::WebResourceLoader::DidSendData(bytesSent, totalBytesToBeSent));
}
void NetworkResourceLoader::didFinishLoading(double finishTime)
{
#if ENABLE(NETWORK_CACHE)
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTF::move(m_cacheEntryForValidation));
return;
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && !m_bufferedData->isEmpty()) {
// FIXME: Pass a real value or remove the encoded data size feature.
bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1);
if (!shouldContinue)
return;
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
#if ENABLE(NETWORK_CACHE)
tryStoreAsCacheEntry();
#endif
cleanup();
}
void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
{
if (isSynchronous()) {
m_synchronousLoadData->response = entry->response();
sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer());
} else {
if (entry->response().url() != originalRequest().url()) {
// This is a cached redirect. Synthesize a minimal redirect so we get things like referer header right.
// FIXME: We should cache the actual redirects.
ResourceRequest syntheticRedirectRequest(entry->response().url());
ResourceResponse syntheticRedirectResponse(originalRequest().url(), { }, 0, { });
sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(syntheticRedirectRequest, syntheticRedirectResponse));
}
bool needsContinueDidReceiveResponseMessage = originalRequest().requester() == ResourceRequest::Requester::Main;
sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), needsContinueDidReceiveResponseMessage));
#if ENABLE(SHAREABLE_RESOURCE)
if (!entry->shareableResourceHandle().isNull())
send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle(), currentTime()));
else {
#endif
bool shouldContinue = sendBufferMaybeAborting(*entry->buffer(), entry->buffer()->size());
if (!shouldContinue)
return;
send(Messages::WebResourceLoader::DidFinishResourceLoad(currentTime()));
#if ENABLE(SHAREABLE_RESOURCE)
}
#endif
}
cleanup();
}
void NetworkResourceLoader::sharedWillSendRedirectedRequest(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& redirectResponse)
{
// We only expect to get the willSendRequest callback from ResourceHandle as the result of a redirect.
ASSERT(!redirectResponse.isNull());
ASSERT(RunLoop::isMain());
m_currentRequest = request;
#if ENABLE(NETWORK_CACHE)
WebCore::updateRedirectChainStatus(m_redirectChainCacheStatus, redirectResponse);
#endif
if (isSynchronous()) {
// FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
// This includes at least updating host records, and comparing the current request instead of the original request here.
if (!protocolHostAndPortAreEqual(originalRequest().url(), m_currentRequest.url())) {
ASSERT(m_synchronousLoadData->error.isNull());
m_synchronousLoadData->error = SynchronousLoaderClient::platformBadResponseError();
m_currentRequest = ResourceRequest();
}
continueWillSendRequest(m_currentRequest);
return;
}
sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(m_currentRequest, redirectResponse));
}
bool NetworkResourceLoader::sendBufferMaybeAborting(SharedBuffer& buffer, size_t encodedDataLength)
{
ASSERT(!isSynchronous());
IPC::SharedBufferDataReference dataReference(&buffer);
return sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
}
void NetworkResourceLoader::didFinishLoading(double finishTime)
{
RELEASE_LOG_IF_ALLOWED("didFinishLoading: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
#if ENABLE(NETWORK_CACHE)
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTFMove(m_cacheEntryForValidation));
return;
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && !m_bufferedData->isEmpty()) {
// FIXME: Pass a real value or remove the encoded data size feature.
sendBuffer(*m_bufferedData, -1);
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
#if ENABLE(NETWORK_CACHE)
tryStoreAsCacheEntry();
#endif
cleanup();
}
void NetworkResourceLoader::startBufferingTimerIfNeeded()
{
if (isSynchronous())
return;
if (m_bufferingTimer.isActive())
return;
m_bufferingTimer.startOneShot(m_parameters.maximumBufferingTime);
}
NetworkResourceLoader::~NetworkResourceLoader()
{
ASSERT(RunLoop::isMain());
#if USE(NETWORK_SESSION)
ASSERT(!m_task);
#else
ASSERT(!m_handle);
#endif
ASSERT(!isSynchronous() || !m_synchronousLoadData->delayedReply);
}
void NetworkResourceLoader::sharedDidFinishLoading(double finishTime)
{
#if ENABLE(NETWORK_CACHE)
if (NetworkCache::singleton().isEnabled()) {
if (m_cacheEntryForValidation) {
// 304 Not Modified
ASSERT(m_response.httpStatusCode() == 304);
LOG(NetworkCache, "(NetworkProcess) revalidated");
didRetrieveCacheEntry(WTF::move(m_cacheEntryForValidation));
return;
}
bool allowStale = originalRequest().cachePolicy() >= ReturnCacheDataElseLoad;
bool hasCacheableRedirect = m_response.isHTTP() && WebCore::redirectChainAllowsReuse(m_redirectChainCacheStatus, allowStale ? WebCore::ReuseExpiredRedirection : WebCore::DoNotReuseExpiredRedirection);
if (hasCacheableRedirect && m_redirectChainCacheStatus.status == RedirectChainCacheStatus::CachedRedirection) {
// Maybe we should cache the actual redirects instead of the end result?
auto now = std::chrono::system_clock::now();
auto responseEndOfValidity = now + WebCore::computeFreshnessLifetimeForHTTPFamily(m_response, now) - WebCore::computeCurrentAge(m_response, now);
hasCacheableRedirect = responseEndOfValidity <= m_redirectChainCacheStatus.endOfValidity;
}
bool isPrivate = sessionID().isEphemeral();
if (m_bufferedDataForCache && hasCacheableRedirect && !isPrivate) {
// Keep the connection alive.
RefPtr<NetworkConnectionToWebProcess> connection(connectionToWebProcess());
RefPtr<NetworkResourceLoader> loader(this);
NetworkCache::singleton().store(originalRequest(), m_response, WTF::move(m_bufferedDataForCache), [loader, connection](NetworkCache::MappedBody& mappedBody) {
#if ENABLE(SHAREABLE_RESOURCE)
if (mappedBody.shareableResourceHandle.isNull())
return;
LOG(NetworkCache, "(NetworkProcess) sending DidCacheResource");
loader->send(Messages::NetworkProcessConnection::DidCacheResource(loader->originalRequest(), mappedBody.shareableResourceHandle, loader->sessionID()));
#endif
});
} else if (!hasCacheableRedirect) {
// Make sure we don't keep a stale entry in the cache.
NetworkCache::singleton().remove(originalRequest());
}
}
#endif
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && m_bufferedData->size()) {
// FIXME: Pass a real value or remove the encoded data size feature.
bool shouldContinue = sendBufferMaybeAborting(*m_bufferedData, -1);
if (!shouldContinue)
return;
}
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
cleanup();
}
void NetworkResourceLoader::didFail(ResourceHandle* handle, const ResourceError& error)
{
ASSERT_UNUSED(handle, handle == m_handle);
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else
send(Messages::WebResourceLoader::DidFailResourceLoad(error));
cleanup();
}
void NetworkResourceLoader::didFinishLoading(ResourceHandle* handle, double finishTime)
{
ASSERT_UNUSED(handle, handle == m_handle);
if (isSynchronous())
sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
else {
if (m_bufferedData && m_bufferedData->size())
sendBuffer(m_bufferedData.get(), -1);
send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
}
cleanup();
}
void NetworkResourceLoader::didFailLoading(const ResourceError& error)
{
ASSERT(!error.isNull());
#if ENABLE(NETWORK_CACHE)
m_cacheEntryForValidation = nullptr;
#endif
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else
send(Messages::WebResourceLoader::DidFailResourceLoad(error));
cleanup();
}
QNonContiguousByteDevice* QNetworkAccessBackend::createUploadByteDevice()
{
if (reply->outgoingDataBuffer)
uploadByteDevice = QNonContiguousByteDeviceFactory::createShared(reply->outgoingDataBuffer);
else if (reply->outgoingData) {
uploadByteDevice = QNonContiguousByteDeviceFactory::createShared(reply->outgoingData);
} else {
return 0;
}
// We want signal emissions only for normal asynchronous uploads
if (!isSynchronous())
connect(uploadByteDevice.data(), SIGNAL(readProgress(qint64,qint64)), this, SLOT(emitReplyUploadProgress(qint64,qint64)));
return uploadByteDevice.data();
}
void NetworkResourceLoader::startNetworkLoad(const ResourceRequest& request)
{
consumeSandboxExtensions();
if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms)
m_bufferedData = SharedBuffer::create();
#if ENABLE(NETWORK_CACHE)
if (canUseCache(request))
m_bufferedDataForCache = SharedBuffer::create();
#endif
NetworkLoadParameters parameters = m_parameters;
parameters.defersLoading = m_defersLoading;
parameters.request = request;
m_networkLoad = std::make_unique<NetworkLoad>(*this, parameters);
}
bool NetworkResourceLoader::sendBufferMaybeAborting(SharedBuffer& buffer, size_t encodedDataLength)
{
ASSERT(!isSynchronous());
#if PLATFORM(COCOA)
ShareableResource::Handle shareableResourceHandle;
NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer);
if (!shareableResourceHandle.isNull()) {
send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime()));
abort();
return false;
}
#endif
IPC::SharedBufferDataReference dataReference(&buffer);
return sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
}
void NetworkResourceLoader::sendBuffer(WebCore::SharedBuffer* buffer, int encodedDataLength)
{
ASSERT(!isSynchronous());
#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
ShareableResource::Handle shareableResourceHandle;
NetworkResourceLoader::tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer);
if (!shareableResourceHandle.isNull()) {
// Since we're delivering this resource by ourselves all at once and don't need anymore data or callbacks from the network layer, abort the loader.
abort();
send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime()));
return;
}
#endif
IPC::SharedBufferDataReference dataReference(buffer);
sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
}
void NetworkResourceLoader::didFailLoading(const ResourceError& error)
{
RELEASE_LOG_IF_ALLOWED("didFailLoading: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isTimeout = %d, isCancellation = %d, errCode = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, error.isTimeout(), error.isCancellation(), error.errorCode());
ASSERT(!error.isNull());
#if ENABLE(NETWORK_CACHE)
m_cacheEntryForValidation = nullptr;
#endif
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else if (auto* connection = messageSenderConnection())
connection->send(Messages::WebResourceLoader::DidFailResourceLoad(error), messageSenderDestinationID());
cleanup();
}
void NetworkResourceLoader::didFailLoading(const ResourceError& error)
{
NETWORKRESOURCELOADER_LOG_ALWAYS("Failed loading network resource: loader = %p, pageID = %llu, frameID = %llu, isMainResource = %d, isSynchronous = %d, isTimeout = %d, isCancellation = %d, errCode = %d", this, m_parameters.webPageID, m_parameters.webFrameID, isMainResource(), isSynchronous(), error.isTimeout(), error.isCancellation(), error.errorCode());
ASSERT(!error.isNull());
#if ENABLE(NETWORK_CACHE)
m_cacheEntryForValidation = nullptr;
#endif
if (isSynchronous()) {
m_synchronousLoadData->error = error;
sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
} else
send(Messages::WebResourceLoader::DidFailResourceLoad(error));
cleanup();
}
void NetworkResourceLoader::startNetworkLoad(const ResourceRequest& request)
{
consumeSandboxExtensions();
if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms)
m_bufferedData = SharedBuffer::create();
#if ENABLE(NETWORK_CACHE)
if (canUseCache(request))
m_bufferedDataForCache = SharedBuffer::create();
#endif
NETWORKRESOURCELOADER_LOG_ALWAYS("Starting network resource load: loader = %p, pageID = %llu, frameID = %llu, isMainResource = %d, isSynchronous = %d", this, m_parameters.webPageID, m_parameters.webFrameID, isMainResource(), isSynchronous());
NetworkLoadParameters parameters = m_parameters;
parameters.defersLoading = m_defersLoading;
parameters.request = request;
m_networkLoad = std::make_unique<NetworkLoad>(*this, parameters);
}
void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace& protectionSpace)
{
ASSERT(RunLoop::isMain());
ASSERT_UNUSED(handle, handle == m_handle);
// Handle server trust evaluation at platform-level if requested, for performance reasons.
if (protectionSpace.authenticationScheme() == ProtectionSpaceAuthenticationSchemeServerTrustEvaluationRequested
&& !NetworkProcess::shared().canHandleHTTPSServerTrustEvaluation()) {
continueCanAuthenticateAgainstProtectionSpace(false);
return;
}
if (isSynchronous()) {
// FIXME: We should ask the WebProcess like the asynchronous case below does.
// This is currently impossible as the WebProcess is blocked waiting on this synchronous load.
// It's possible that we can jump straight to the UI process to resolve this.
continueCanAuthenticateAgainstProtectionSpace(true);
return;
}
sendAbortingOnFailure(Messages::WebResourceLoader::CanAuthenticateAgainstProtectionSpace(protectionSpace));
}
void NetworkResourceLoader::startNetworkLoad(const ResourceRequest& request)
{
RELEASE_LOG_IF_ALLOWED("startNetworkLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
consumeSandboxExtensions();
if (isSynchronous() || m_parameters.maximumBufferingTime > 0ms)
m_bufferedData = SharedBuffer::create();
#if ENABLE(NETWORK_CACHE)
if (canUseCache(request))
m_bufferedDataForCache = SharedBuffer::create();
#endif
NetworkLoadParameters parameters = m_parameters;
parameters.defersLoading = m_defersLoading;
parameters.request = request;
#if USE(NETWORK_SESSION)
if (request.url().protocolIsBlob())
parameters.blobFileReferences = NetworkBlobRegistry::singleton().filesInBlob(m_connection, originalRequest().url());
auto* networkSession = SessionTracker::networkSession(parameters.sessionID);
if (!networkSession) {
WTFLogAlways("Attempted to create a NetworkLoad with a session (id=%" PRIu64 ") that does not exist.", parameters.sessionID.sessionID());
RELEASE_LOG_ERROR_IF_ALLOWED("startNetworkLoad: Attempted to create a NetworkLoad with a session that does not exist (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", sessionID=%" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, parameters.sessionID.sessionID());
NetworkProcess::singleton().logDiagnosticMessage(m_parameters.webPageID, WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::invalidSessionIDKey(), WebCore::ShouldSample::No);
didFailLoading(internalError(request.url()));
return;
}
m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters), *networkSession);
#else
m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters));
#endif
if (m_defersLoading) {
RELEASE_LOG_IF_ALLOWED("startNetworkLoad: Created, but deferred (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")",
m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
}
}
void NetworkResourceLoader::didReceiveResponseAsync(ResourceHandle* handle, const ResourceResponse& response)
{
ASSERT_UNUSED(handle, handle == m_handle);
if (m_parameters.needsCertificateInfo)
response.includeCertificateInfo();
if (isSynchronous())
m_synchronousLoadData->response = response;
else
sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(response, m_parameters.isMainResource));
// m_handle will be null if the request got aborted above.
if (!m_handle)
return;
// For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message.
if (m_parameters.isMainResource)
return;
m_handle->continueDidReceiveResponse();
}
QNonContiguousByteDevice* QNetworkAccessBackend::createUploadByteDevice()
{
if (reply->outgoingDataBuffer)
uploadByteDevice = QSharedPointer<QNonContiguousByteDevice>(QNonContiguousByteDeviceFactory::create(reply->outgoingDataBuffer));
else if (reply->outgoingData) {
uploadByteDevice = QSharedPointer<QNonContiguousByteDevice>(QNonContiguousByteDeviceFactory::create(reply->outgoingData));
} else {
return 0;
}
bool bufferDisallowed =
reply->request.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
QVariant(false)) == QVariant(true);
if (bufferDisallowed)
uploadByteDevice->disableReset();
// We want signal emissions only for normal asynchronous uploads
if (!isSynchronous())
connect(uploadByteDevice.data(), SIGNAL(readProgress(qint64,qint64)), this, SLOT(emitReplyUploadProgress(qint64,qint64)));
return uploadByteDevice.data();
}
void NetworkResourceLoader::start()
{
ASSERT(RunLoop::isMain());
if (m_defersLoading)
return;
// Explicit ref() balanced by a deref() in NetworkResourceLoader::cleanup()
ref();
m_networkingContext = RemoteNetworkingContext::create(sessionID(), m_parameters.shouldClearReferrerOnHTTPSToHTTPRedirect);
consumeSandboxExtensions();
m_currentRequest = originalRequest();
if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms)
m_bufferedData = WebCore::SharedBuffer::create();
bool shouldSniff = m_parameters.contentSniffingPolicy == SniffContent;
m_handle = ResourceHandle::create(m_networkingContext.get(), m_currentRequest, this, false /* defersLoading */, shouldSniff);
}
void NetworkResourceLoader::willSendRequestAsync(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& redirectResponse)
{
ASSERT_UNUSED(handle, handle == m_handle);
// We only expect to get the willSendRequest callback from ResourceHandle as the result of a redirect.
ASSERT(!redirectResponse.isNull());
ASSERT(RunLoop::isMain());
m_currentRequest = request;
if (isSynchronous()) {
// FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
// This includes at least updating host records, and comparing the current request instead of the original request here.
if (!protocolHostAndPortAreEqual(originalRequest().url(), request.url())) {
ASSERT(m_synchronousLoadData->error.isNull());
m_synchronousLoadData->error = SynchronousLoaderClient::platformBadResponseError();
m_currentRequest = ResourceRequest();
}
continueWillSendRequest(m_currentRequest);
return;
}
sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(request, redirectResponse));
}
