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