void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength) { if (!m_hasReceivedData) { RELEASE_LOG_IF_ALLOWED("didReceiveBuffer: Started receiving data (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); m_hasReceivedData = true; } #if ENABLE(NETWORK_CACHE) ASSERT(!m_cacheEntryForValidation); if (m_bufferedDataForCache) { // Prevent memory growth in case of streaming data. const size_t maximumCacheBufferSize = 10 * 1024 * 1024; if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize) m_bufferedDataForCache->append(buffer.get()); else m_bufferedDataForCache = nullptr; } #endif // FIXME: At least on OS X Yosemite we always get -1 from the resource handle. unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer->size(); m_bytesReceived += buffer->size(); if (m_bufferedData) { m_bufferedData->append(buffer.get()); m_bufferedDataEncodedDataLength += encodedDataLength; startBufferingTimerIfNeeded(); return; } sendBuffer(buffer, encodedDataLength); }
void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, bool needsContinueDidReceiveResponseMessage) { LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResponse for '%s'. Status %d.", m_coreLoader->url().string().latin1().data(), response.httpStatusCode()); RELEASE_LOG_IF_ALLOWED("WebResourceLoader::didReceiveResponse, WebResourceLoader = %p, status = %d.", this, response.httpStatusCode()); Ref<WebResourceLoader> protect(*this); if (m_coreLoader->documentLoader()->applicationCacheHost()->maybeLoadFallbackForResponse(m_coreLoader.get(), response)) return; bool shoudCallCoreLoaderDidReceiveResponse = true; #if USE(QUICK_LOOK) // Refrain from calling didReceiveResponse if QuickLook will convert this response, since the MIME type of the // converted resource isn't yet known. WebResourceLoaderQuickLookDelegate will later call didReceiveResponse upon // receiving the converted data. bool isMainLoad = m_coreLoader->documentLoader()->mainResourceLoader() == m_coreLoader; if (isMainLoad && QuickLookHandle::shouldCreateForMIMEType(response.mimeType())) { m_coreLoader->documentLoader()->setQuickLookHandle(QuickLookHandle::create(*m_coreLoader, response)); shoudCallCoreLoaderDidReceiveResponse = false; } #endif if (shoudCallCoreLoaderDidReceiveResponse) m_coreLoader->didReceiveResponse(response); // If m_coreLoader becomes null as a result of the didReceiveResponse callback, we can't use the send function(). if (!m_coreLoader) return; if (needsContinueDidReceiveResponseMessage) send(Messages::NetworkResourceLoader::ContinueDidReceiveResponse()); }
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(); }
RefPtr<SubresourceLoader> WebLoaderStrategy::loadResource(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options) { RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options); if (loader) scheduleLoad(*loader, &resource, frame.document()->referrerPolicy() == ReferrerPolicy::Default); else RELEASE_LOG_IF_ALLOWED(frame, "loadResource: Unable to create SubresourceLoader (frame = %p", &frame); return loader; }
void NetworkResourceLoader::start() { ASSERT(RunLoop::isMain()); if (m_defersLoading) { RELEASE_LOG_IF_ALLOWED("start: Loading is deferred (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous()); return; } #if ENABLE(NETWORK_CACHE) if (canUseCache(originalRequest())) { RELEASE_LOG_IF_ALLOWED("start: Retrieving resource from cache (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous()); retrieveCacheEntry(originalRequest()); return; } #endif startNetworkLoad(originalRequest()); }
void NetworkResourceLoader::setDefersLoading(bool defers) { if (m_defersLoading == defers) return; m_defersLoading = defers; if (defers) RELEASE_LOG_IF_ALLOWED("setDefersLoading: Deferring resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); else RELEASE_LOG_IF_ALLOWED("setDefersLoading: Resuming deferred resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); if (m_networkLoad) { m_networkLoad->setDefersLoading(defers); return; } if (!m_defersLoading) start(); else RELEASE_LOG_IF_ALLOWED("setDefersLoading: defers = TRUE, but nothing to stop (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); }
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 WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength) { LOG(Network, "(WebProcess) WebResourceLoader::didReceiveData of size %lu for '%s'", data.size(), m_coreLoader->url().string().latin1().data()); RELEASE_LOG_IF_ALLOWED("WebResourceLoader::didReceiveData, WebResourceLoader = %p, size = %lu", this, data.size()); #if USE(QUICK_LOOK) if (QuickLookHandle* quickLookHandle = m_coreLoader->documentLoader()->quickLookHandle()) { if (quickLookHandle->didReceiveData(adoptCF(CFDataCreate(kCFAllocatorDefault, data.data(), data.size())).get())) return; } #endif m_coreLoader->didReceiveData(reinterpret_cast<const char*>(data.data()), data.size(), encodedDataLength, DataPayloadBytes); }
void WebResourceLoader::didFinishResourceLoad(double finishTime) { LOG(Network, "(WebProcess) WebResourceLoader::didFinishResourceLoad for '%s'", m_coreLoader->url().string().latin1().data()); RELEASE_LOG_IF_ALLOWED("WebResourceLoader::didFinishResourceLoad, WebResourceLoader = %p", this); #if USE(QUICK_LOOK) if (QuickLookHandle* quickLookHandle = m_coreLoader->documentLoader()->quickLookHandle()) { if (quickLookHandle->didFinishLoading()) return; } #endif m_coreLoader->didFinishLoading(finishTime); }
void WebResourceLoader::didFailResourceLoad(const ResourceError& error) { LOG(Network, "(WebProcess) WebResourceLoader::didFailResourceLoad for '%s'", m_coreLoader->url().string().latin1().data()); RELEASE_LOG_IF_ALLOWED("WebResourceLoader::didFailResourceLoad, WebResourceLoader = %p", this); #if USE(QUICK_LOOK) if (QuickLookHandle* quickLookHandle = m_coreLoader->documentLoader()->quickLookHandle()) quickLookHandle->didFail(); #endif if (m_coreLoader->documentLoader()->applicationCacheHost()->maybeLoadFallbackForError(m_coreLoader.get(), error)) return; m_coreLoader->didFail(error); }
void WebResourceLoader::willSendRequest(ResourceRequest&& proposedRequest, ResourceResponse&& redirectResponse) { LOG(Network, "(WebProcess) WebResourceLoader::willSendRequest to '%s'", proposedRequest.url().string().latin1().data()); RELEASE_LOG_IF_ALLOWED("WebResourceLoader::willSendRequest, WebResourceLoader = %p", this); RefPtr<WebResourceLoader> protectedThis(this); if (m_coreLoader->documentLoader()->applicationCacheHost()->maybeLoadFallbackForRedirect(m_coreLoader.get(), proposedRequest, redirectResponse)) return; m_coreLoader->willSendRequest(WTFMove(proposedRequest), redirectResponse, [protectedThis](ResourceRequest&& request) { if (!protectedThis->m_coreLoader) return; protectedThis->send(Messages::NetworkResourceLoader::ContinueWillSendRequest(request)); }); }
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::abort() { ASSERT(RunLoop::isMain()); RELEASE_LOG_IF_ALLOWED("abort: Canceling resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); if (m_networkLoad) { #if ENABLE(NETWORK_CACHE) if (canUseCache(m_networkLoad->currentRequest())) { // We might already have used data from this incomplete load. Ensure older versions don't remain in the cache after cancel. if (!m_response.isNull()) NetworkCache::singleton().remove(m_networkLoad->currentRequest()); } #endif m_networkLoad->cancel(); } cleanup(); }
void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& handle, double finishTime) { LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().latin1().data()); RELEASE_LOG_IF_ALLOWED("WebResourceLoader::didReceiveResource, WebResourceLoader = %p", this); RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer(); #if USE(QUICK_LOOK) if (QuickLookHandle* quickLookHandle = m_coreLoader->documentLoader()->quickLookHandle()) { if (buffer) { if (quickLookHandle->didReceiveData(buffer->existingCFData())) { quickLookHandle->didFinishLoading(); return; } } else quickLookHandle->didFail(); } #endif if (!buffer) { LOG_ERROR("Unable to create buffer from ShareableResource sent from the network process."); m_coreLoader->didFail(internalError(m_coreLoader->request().url())); return; } Ref<WebResourceLoader> protect(*this); // Only send data to the didReceiveData callback if it exists. if (unsigned bufferSize = buffer->size()) m_coreLoader->didReceiveBuffer(buffer.releaseNonNull(), bufferSize, DataPayloadWholeResource); if (!m_coreLoader) return; m_coreLoader->didFinishLoading(finishTime); }
void NetworkResourceLoader::continueWillSendRequest(ResourceRequest&& newRequest) { RELEASE_LOG_IF_ALLOWED("continueWillSendRequest: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier); // If there is a match in the network cache, we need to reuse the original cache policy. newRequest.setCachePolicy(originalRequest().cachePolicy()); #if ENABLE(NETWORK_CACHE) if (m_isWaitingContinueWillSendRequestForCachedRedirect) { LOG(NetworkCache, "(NetworkProcess) Retrieving cached redirect"); if (canUseCachedRedirect(newRequest)) retrieveCacheEntry(newRequest); else startNetworkLoad(newRequest); m_isWaitingContinueWillSendRequestForCachedRedirect = false; return; } #endif if (m_networkLoad) m_networkLoad->continueWillSendRequest(WTFMove(newRequest)); }
void WebLoaderStrategy::scheduleLoad(ResourceLoader& resourceLoader, CachedResource* resource, bool shouldClearReferrerOnHTTPSToHTTPRedirect) { ResourceLoadIdentifier identifier = resourceLoader.identifier(); ASSERT(identifier); // FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient. // EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient, // but in the meantime we have to make sure not to mis-cast. WebFrameLoaderClient* webFrameLoaderClient = toWebFrameLoaderClient(resourceLoader.frameLoader()->client()); WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr; WebPage* webPage = webFrame ? webFrame->page() : nullptr; WebResourceLoader::TrackingParameters trackingParameters; trackingParameters.pageID = webPage ? webPage->pageID() : 0; trackingParameters.frameID = webFrame ? webFrame->frameID() : 0; trackingParameters.resourceID = identifier; #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML) // If the DocumentLoader schedules this as an archive resource load, // then we should remember the ResourceLoader in our records but not schedule it in the NetworkProcess. if (resourceLoader.documentLoader()->scheduleArchiveLoad(resourceLoader, resourceLoader.request())) { LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as an archive resource.", resourceLoader.url().string().utf8().data()); RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled as an archive resource (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier); m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters)); return; } #endif if (resourceLoader.documentLoader()->applicationCacheHost()->maybeLoadResource(resourceLoader, resourceLoader.request(), resourceLoader.request().url())) { LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded from application cache.", resourceLoader.url().string().utf8().data()); RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be loaded from application cache (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier); m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters)); return; } if (resourceLoader.request().url().protocolIsData()) { LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded as data.", resourceLoader.url().string().utf8().data()); RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be loaded as data (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier); startLocalLoad(resourceLoader); return; } #if USE(QUICK_LOOK) if (resourceLoader.request().url().protocolIs(QLPreviewProtocol())) { LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a QuickLook resource.", resourceLoader.url().string().utf8().data()); RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled as a QuickLook resource (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier); startLocalLoad(resourceLoader); return; } #endif #if USE(SOUP) // For apps that call g_resource_load in a web extension. // https://blogs.gnome.org/alexl/2012/01/26/resources-in-glib/ if (resourceLoader.request().url().protocolIs("resource")) { LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a GResource.", resourceLoader.url().string().utf8().data()); RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled as a GResource (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier); startLocalLoad(resourceLoader); return; } #endif LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be scheduled with the NetworkProcess with priority %d", resourceLoader.url().string().latin1().data(), static_cast<int>(resourceLoader.request().priority())); ContentSniffingPolicy contentSniffingPolicy = resourceLoader.shouldSniffContent() ? SniffContent : DoNotSniffContent; StoredCredentials allowStoredCredentials = resourceLoader.shouldUseCredentialStorage() ? AllowStoredCredentials : DoNotAllowStoredCredentials; NetworkResourceLoadParameters loadParameters; loadParameters.identifier = identifier; loadParameters.webPageID = webPage ? webPage->pageID() : 0; loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0; loadParameters.sessionID = webPage ? webPage->sessionID() : SessionID::defaultSessionID(); loadParameters.request = resourceLoader.request(); loadParameters.contentSniffingPolicy = contentSniffingPolicy; loadParameters.allowStoredCredentials = allowStoredCredentials; // If there is no WebFrame then this resource cannot be authenticated with the client. loadParameters.clientCredentialPolicy = (webFrame && webPage && resourceLoader.isAllowedToAskUserForCredentials()) ? ClientCredentialPolicy::MayAskClientForCredentials : ClientCredentialPolicy::CannotAskClientForCredentials; loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect; loadParameters.defersLoading = resourceLoader.defersLoading(); loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo(); loadParameters.maximumBufferingTime = maximumBufferingTime(resource); ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials); if (!WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) { RELEASE_LOG_ERROR_IF_ALLOWED(resourceLoader, "scheduleLoad: Unable to schedule resource with the NetworkProcess (frame = %p, priority = %d, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), static_cast<int>(resourceLoader.request().priority()), loadParameters.webPageID, loadParameters.webFrameID, loadParameters.identifier); // We probably failed to schedule this load with the NetworkProcess because it had crashed. // This load will never succeed so we will schedule it to fail asynchronously. scheduleInternallyFailedLoad(resourceLoader); return; } auto webResourceLoader = WebResourceLoader::create(resourceLoader, trackingParameters); RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: Resource has been queued for scheduling with the NetworkProcess (frame = %p, priority = %d, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", WebResourceLoader = %p)", resourceLoader.frame(), static_cast<int>(resourceLoader.request().priority()), loadParameters.webPageID, loadParameters.webFrameID, loadParameters.identifier, webResourceLoader.ptr()); m_webResourceLoaders.set(identifier, WTFMove(webResourceLoader)); }
void CachedResource::load(CachedResourceLoader& cachedResourceLoader) { if (!cachedResourceLoader.frame()) { RELEASE_LOG_IF_ALLOWED("load: No associated frame"); failBeforeStarting(); return; } Frame& frame = *cachedResourceLoader.frame(); // Prevent new loads if we are in the PageCache or being added to the PageCache. // We query the top document because new frames may be created in pagehide event handlers // and their pageCacheState will not reflect the fact that they are about to enter page // cache. if (auto* topDocument = frame.mainFrame().document()) { if (topDocument->pageCacheState() != Document::NotInPageCache) { RELEASE_LOG_IF_ALLOWED("load: Already in page cache or being added to it (frame = %p)", &frame); failBeforeStarting(); return; } } FrameLoader& frameLoader = frame.loader(); if (m_options.securityCheck == DoSecurityCheck && (frameLoader.state() == FrameStateProvisional || !frameLoader.activeDocumentLoader() || frameLoader.activeDocumentLoader()->isStopping())) { if (frameLoader.state() == FrameStateProvisional) RELEASE_LOG_IF_ALLOWED("load: Failed security check -- state is provisional (frame = %p)", &frame); else if (!frameLoader.activeDocumentLoader()) RELEASE_LOG_IF_ALLOWED("load: Failed security check -- not active document (frame = %p)", &frame); else if (frameLoader.activeDocumentLoader()->isStopping()) RELEASE_LOG_IF_ALLOWED("load: Failed security check -- active loader is stopping (frame = %p)", &frame); failBeforeStarting(); return; } m_loading = true; #if USE(QUICK_LOOK) if (!m_resourceRequest.isNull() && m_resourceRequest.url().protocolIs(QLPreviewProtocol())) { // When QuickLook is invoked to convert a document, it returns a unique URL in the // NSURLReponse for the main document. To make safeQLURLForDocumentURLAndResourceURL() // work, we need to use the QL URL not the original URL. const URL& documentURL = frameLoader.documentLoader()->response().url(); m_resourceRequest.setURL(safeQLURLForDocumentURLAndResourceURL(documentURL, url())); } #endif if (isCacheValidator()) { CachedResource* resourceToRevalidate = m_resourceToRevalidate; ASSERT(resourceToRevalidate->canUseCacheValidator()); ASSERT(resourceToRevalidate->isLoaded()); const String& lastModified = resourceToRevalidate->response().httpHeaderField(HTTPHeaderName::LastModified); const String& eTag = resourceToRevalidate->response().httpHeaderField(HTTPHeaderName::ETag); if (!lastModified.isEmpty() || !eTag.isEmpty()) { ASSERT(cachedResourceLoader.cachePolicy(type()) != CachePolicyReload); if (cachedResourceLoader.cachePolicy(type()) == CachePolicyRevalidate) m_resourceRequest.setHTTPHeaderField(HTTPHeaderName::CacheControl, "max-age=0"); if (!lastModified.isEmpty()) m_resourceRequest.setHTTPHeaderField(HTTPHeaderName::IfModifiedSince, lastModified); if (!eTag.isEmpty()) m_resourceRequest.setHTTPHeaderField(HTTPHeaderName::IfNoneMatch, eTag); } } #if ENABLE(LINK_PREFETCH) if (type() == CachedResource::LinkPrefetch || type() == CachedResource::LinkSubresource) m_resourceRequest.setHTTPHeaderField(HTTPHeaderName::Purpose, "prefetch"); #endif m_resourceRequest.setPriority(loadPriority()); // Navigation algorithm is setting up the request before sending it to CachedResourceLoader?CachedResource. // So no need for extra fields for MainResource. if (type() != CachedResource::MainResource) frameLoader.addExtraFieldsToSubresourceRequest(m_resourceRequest); // FIXME: It's unfortunate that the cache layer and below get to know anything about fragment identifiers. // We should look into removing the expectation of that knowledge from the platform network stacks. ResourceRequest request(m_resourceRequest); if (!m_fragmentIdentifierForRequest.isNull()) { URL url = request.url(); url.setFragmentIdentifier(m_fragmentIdentifierForRequest); request.setURL(url); m_fragmentIdentifierForRequest = String(); } m_loader = platformStrategies()->loaderStrategy()->loadResource(frame, *this, request, m_options); if (!m_loader) { RELEASE_LOG_IF_ALLOWED("load: Unable to create SubresourceLoader (frame = %p)", &frame); failBeforeStarting(); return; } m_status = Pending; }