void ResourceLoader::didReceiveResponse(const ResourceResponse& r) { ASSERT(!m_reachedTerminalState); // Protect this in this delegate method since the additional processing can do // anything including possibly derefing this; one example of this is Radar 3266216. Ref<ResourceLoader> protect(*this); logResourceResponseSource(m_frame.get(), r.source()); m_response = r; if (FormData* data = m_request.httpBody()) data->removeGeneratedFilesIfNeeded(); if (m_options.sendLoadCallbacks() == SendCallbacks) frameLoader()->notifier().didReceiveResponse(this, m_response); }
void FetchManager::Loader::didReceiveResponse(unsigned long, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle) { ASSERT(handle); m_responseHttpStatusCode = response.httpStatusCode(); // Recompute the tainting if the request was redirected to a different // origin. if (!SecurityOrigin::create(response.url())->isSameSchemeHostPort(m_request->origin().get())) { switch (m_request->mode()) { case WebURLRequest::FetchRequestModeSameOrigin: ASSERT_NOT_REACHED(); break; case WebURLRequest::FetchRequestModeNoCORS: m_request->setResponseTainting(FetchRequestData::OpaqueTainting); break; case WebURLRequest::FetchRequestModeCORS: case WebURLRequest::FetchRequestModeCORSWithForcedPreflight: m_request->setResponseTainting(FetchRequestData::CORSTainting); break; } } FetchResponseData* responseData = FetchResponseData::createWithBuffer(BodyStreamBuffer::create(createFetchDataConsumerHandleFromWebHandle(handle))); responseData->setStatus(response.httpStatusCode()); responseData->setStatusMessage(response.httpStatusText()); for (auto& it : response.httpHeaderFields()) responseData->headerList()->append(it.key, it.value); responseData->setURL(response.url()); responseData->setMIMEType(response.mimeType()); FetchResponseData* taintedResponse = responseData; switch (m_request->tainting()) { case FetchRequestData::BasicTainting: taintedResponse = responseData->createBasicFilteredResponse(); break; case FetchRequestData::CORSTainting: taintedResponse = responseData->createCORSFilteredResponse(); break; case FetchRequestData::OpaqueTainting: taintedResponse = responseData->createOpaqueFilteredResponse(); break; } Response* r = Response::create(m_resolver->executionContext(), taintedResponse); r->headers()->setGuard(Headers::ImmutableGuard); m_resolver->resolve(r); m_resolver.clear(); }
void Resource::updateResponseAfterRevalidation(const ResourceResponse& validatingResponse) { m_responseTimestamp = currentTime(); // RFC2616 10.3.5 // Update cached headers from the 304 response const HTTPHeaderMap& newHeaders = validatingResponse.httpHeaderFields(); for (const auto& header : newHeaders) { // Entity headers should not be sent by servers when generating a 304 // response; misconfigured servers send them anyway. We shouldn't allow // such headers to update the original request. We'll base this on the // list defined by RFC2616 7.1, with a few additions for extension headers // we care about. if (!shouldUpdateHeaderAfterRevalidation(header.key)) continue; m_response.setHTTPHeaderField(header.key, header.value); } }
ResourceResponse ResourceResponseBase::fromCrossThreadData(CrossThreadData&& data) { ResourceResponse response; response.setURL(data.url); response.setMimeType(data.mimeType); response.setExpectedContentLength(data.expectedContentLength); response.setTextEncodingName(data.textEncodingName); response.setHTTPStatusCode(data.httpStatusCode); response.setHTTPStatusText(data.httpStatusText); response.setHTTPVersion(data.httpVersion); response.m_httpHeaderFields = WTFMove(data.httpHeaderFields); response.m_networkLoadTiming = data.networkLoadTiming; response.m_type = data.type; response.m_isRedirected = data.isRedirected; return response; }
ResourcePtr<Resource> createTestResource(const KURL& url, const KURL& allowOriginUrl, CorsStatus corsStatus) { ResourceResponse response; response.setURL(url); response.setHTTPStatusCode(200); if (corsStatus == WithCors) { response.setHTTPHeaderField("access-control-allow-origin", SecurityOrigin::create(allowOriginUrl)->toAtomicString()); response.setHTTPHeaderField("access-control-allow-credentials", "true"); } ResourcePtr<Resource> resource = new Resource(ResourceRequest(response.url()), Resource::Raw); resource->setResponse(response); return resource; }
void ResourceLoader::didReceiveResponse(const ResourceResponse& r) { ASSERT(!m_reachedTerminalState); // Protect this in this delegate method since the additional processing can do // anything including possibly derefing this; one example of this is Radar 3266216. Ref<ResourceLoader> protectedThis(*this); logResourceResponseSource(m_frame.get(), r.source()); m_response = r; if (m_response.isHttpVersion0_9()) { auto url = m_response.url(); // Non-HTTP responses are interpreted as HTTP/0.9 which may allow exfiltration of data // from non-HTTP services. Therefore cancel if the document was loaded with different // HTTP version or if the resource request was to a non-default port. if (!m_documentLoader->response().isHttpVersion0_9()) { String message = "Cancelled resource load from '" + url.string() + "' because it is using HTTP/0.9 and the document was loaded with a different HTTP version."; m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, identifier()); ResourceError error(emptyString(), 0, url, message); didFail(error); return; } if (!isDefaultPortForProtocol(url.port(), url.protocol())) { String message = "Cancelled resource load from '" + url.string() + "' because it is using HTTP/0.9 on a non-default port."; m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, identifier()); ResourceError error(emptyString(), 0, url, message); didFail(error); return; } String message = "Sandboxing '" + m_response.url().string() + "' because it is using HTTP/0.9."; m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, m_identifier); frameLoader()->forceSandboxFlags(SandboxScripts | SandboxPlugins); } if (FormData* data = m_request.httpBody()) data->removeGeneratedFilesIfNeeded(); if (m_options.sendLoadCallbacks() == SendCallbacks) frameLoader()->notifier().didReceiveResponse(this, m_response); }
void ProgressTracker::incrementProgress(unsigned long identifier, const ResourceResponse& response) { LOG(Progress, "Progress incremented (%p) - value %f, tracked frames %d, originating frame %p", this, m_progressValue, m_numProgressTrackedFrames, m_originatingProgressFrame.get()); if (m_numProgressTrackedFrames <= 0) return; long long estimatedLength = response.expectedContentLength(); if (estimatedLength < 0) estimatedLength = progressItemDefaultEstimatedLength; m_totalPageAndResourceBytesToLoad += estimatedLength; if (ProgressItem* item = m_progressItems.get(identifier)) { item->bytesReceived = 0; item->estimatedLength = estimatedLength; } else m_progressItems.set(identifier, adoptPtr(new ProgressItem(estimatedLength))); }
void ProgressTracker::incrementProgress(unsigned long identifier, const ResourceResponse& response) { // LOG (Progress, "_private->numProgressTrackedFrames %d, _private->originatingProgressFrame %p", _private->numProgressTrackedFrames, _private->originatingProgressFrame); if (m_numProgressTrackedFrames <= 0) return; long long estimatedLength = response.expectedContentLength(); if (estimatedLength < 0) estimatedLength = progressItemDefaultEstimatedLength; m_totalPageAndResourceBytesToLoad += estimatedLength; if (ProgressItem* item = m_progressItems.get(identifier)) { item->bytesReceived = 0; item->estimatedLength = estimatedLength; } else m_progressItems.set(identifier, new ProgressItem(estimatedLength)); }
static RefPtr<Inspector::Protocol::Network::Response> buildObjectForResourceResponse(const ResourceResponse& response, DocumentLoader* loader) { if (response.isNull()) return nullptr; double status = response.httpStatusCode(); Ref<InspectorObject> headers = buildObjectForHeaders(response.httpHeaderFields()); auto responseObject = Inspector::Protocol::Network::Response::create() .setUrl(response.url().string()) .setStatus(status) .setStatusText(response.httpStatusText()) .setHeaders(WTFMove(headers)) .setMimeType(response.mimeType()) .release(); responseObject->setFromDiskCache(response.source() == ResourceResponse::Source::DiskCache || response.source() == ResourceResponse::Source::DiskCacheAfterValidation); responseObject->setTiming(buildObjectForTiming(response.networkLoadTiming(), loader)); return WTFMove(responseObject); }
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = adoptGRef(response.toSoupMessage()); m_download->didReceiveResponse(response); if (response.httpStatusCode() >= 400) { downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url().string(), response.httpStatusText())); return; } String suggestedFilename = response.suggestedFilename(); if (suggestedFilename.isEmpty()) { URL url = response.url(); url.setQuery(String()); url.removeFragmentIdentifier(); suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent()); } bool overwrite; String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename, overwrite); if (destinationURI.isEmpty()) { #if PLATFORM(GTK) GOwnPtr<char> buffer(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data())); String errorMessage = String::fromUTF8(buffer.get()); #else String errorMessage = makeString("Cannot determine destination URI for download with suggested filename ", suggestedFilename); #endif downloadFailed(platformDownloadDestinationError(response, errorMessage)); return; } GRefPtr<GFile> file = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data())); GOwnPtr<GError> error; m_outputStream = adoptGRef(g_file_replace(file.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr())); if (!m_outputStream) { downloadFailed(platformDownloadDestinationError(response, error->message)); return; } GRefPtr<GFileInfo> info = adoptGRef(g_file_info_new()); g_file_info_set_attribute_string(info.get(), "metadata::download-uri", response.url().string().utf8().data()); g_file_set_attributes_async(file.get(), info.get(), G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, 0, 0, 0); m_download->didCreateDestination(destinationURI); }
void MainResourceLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse) { // Note that there are no asserts here as there are for the other callbacks. This is due to the // fact that this "callback" is sent when starting every load, and the state of callback // deferrals plays less of a part in this function in preventing the bad behavior deferring // callbacks is meant to prevent. ASSERT(!newRequest.isNull()); // The additional processing can do anything including possibly removing the last // reference to this object; one example of this is 3266216. RefPtr<MainResourceLoader> protect(this); // Update cookie policy base URL as URL changes, except for subframes, which use the // URL of the main frame which doesn't change when we redirect. if (frameLoader()->isLoadingMainFrame()) newRequest.setFirstPartyForCookies(newRequest.url()); // If we're fielding a redirect in response to a POST, force a load from origin, since // this is a common site technique to return to a page viewing some data that the POST // just modified. // Also, POST requests always load from origin, but this does not affect subresources. if (newRequest.cachePolicy() == UseProtocolCachePolicy && isPostOrRedirectAfterPost(newRequest, redirectResponse)) newRequest.setCachePolicy(ReloadIgnoringCacheData); ResourceLoader::willSendRequest(newRequest, redirectResponse); // Don't set this on the first request. It is set when the main load was started. m_documentLoader->setRequest(newRequest); Frame* top = m_frame->tree()->top(); if (top != m_frame) frameLoader()->checkIfDisplayInsecureContent(top->document()->securityOrigin(), newRequest.url()); // FIXME: Ideally we'd stop the I/O until we hear back from the navigation policy delegate // listener. But there's no way to do that in practice. So instead we cancel later if the // listener tells us to. In practice that means the navigation policy needs to be decided // synchronously for these redirect cases. if (!redirectResponse.isNull()) { ref(); // balanced by deref in continueAfterNavigationPolicy frameLoader()->policyChecker()->checkNavigationPolicy(newRequest, callContinueAfterNavigationPolicy, this); } }
PassRefPtrWillBeRawPtr<ArchiveResource> ArchiveResource::create( PassRefPtr<SharedBuffer> data, const KURL& url, const String& contentID, const AtomicString& mimeType, const AtomicString& textEncoding, const String& frameName, const ResourceResponse& response) { if (!data) return nullptr; if (response.isNull()) { const ResourceResponse& resourceResponse = ResourceResponse( url, mimeType, data->size(), textEncoding, String()); return adoptRefWillBeNoop(new ArchiveResource( data, url, contentID, mimeType, textEncoding, frameName, resourceResponse)); } return adoptRefWillBeNoop(new ArchiveResource( data, url, contentID, mimeType, textEncoding, frameName, response)); }
void ResourceLoader::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse) { // Protect this in this delegate method since the additional processing can do // anything including possibly derefing this; one example of this is Radar 3266216. RefPtr<ResourceLoader> protector(this); ASSERT(!m_reachedTerminalState); if (m_options.sendLoadCallbacks == SendCallbacks) { if (!m_identifier) { m_identifier = m_frame->page()->progress()->createUniqueIdentifier(); frameLoader()->notifier()->assignIdentifierToInitialRequest(m_identifier, documentLoader(), request); } frameLoader()->notifier()->willSendRequest(this, request, redirectResponse); } if (!redirectResponse.isNull()) resourceLoadScheduler()->crossOriginRedirectReceived(this, request.url()); m_request = request; }
void ResourceLoadNotifier::sendRemainingDelegateMessages(DocumentLoader* loader, unsigned long identifier, const ResourceRequest& request, const ResourceResponse& response, const char* data, int dataLength, int encodedDataLength, const ResourceError& error) { // If the request is null, willSendRequest cancelled the load. We should // only dispatch didFailLoading in this case. if (request.isNull()) { ASSERT(error.isCancellation()); dispatchDidFailLoading(loader, identifier, error); return; } if (!response.isNull()) dispatchDidReceiveResponse(loader, identifier, response); if (dataLength > 0) dispatchDidReceiveData(loader, identifier, data, dataLength, encodedDataLength); if (error.isNull()) dispatchDidFinishLoading(loader, identifier, 0); else dispatchDidFailLoading(loader, identifier, error); }
void ProgressTracker::incrementProgress(unsigned long identifier, const ResourceResponse& response) { if (!m_frame->isLoading()) return; if (m_frame->loader().provisionalDocumentLoader() && m_frame->loader().provisionalDocumentLoader()->mainResourceIdentifier() == identifier) m_mainResourceIdentifier = identifier; long long estimatedLength = response.expectedContentLength(); if (estimatedLength < 0) estimatedLength = progressItemDefaultEstimatedLength; m_totalPageAndResourceBytesToLoad += estimatedLength; if (ProgressItem* item = m_progressItems.get(identifier)) { item->bytesReceived = 0; item->estimatedLength = estimatedLength; } else { m_progressItems.set(identifier, adoptPtr(new ProgressItem(estimatedLength))); } }
void ResourceHandle::platformLoadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data) { LOG(Network, "ResourceHandle::platformLoadResourceSynchronously:%s allowStoredCredentials:%u", request.url().string().utf8().data(), storedCredentials); ASSERT(!request.isEmpty()); ASSERT(response.isNull()); ASSERT(error.isNull()); SynchronousLoaderClient client; client.setAllowStoredCredentials(storedCredentials == AllowStoredCredentials); RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(context, request, &client, false /*defersLoading*/, true /*shouldContentSniff*/)); handle->d->m_storageSession = context->storageSession().platformSession(); if (handle->d->m_scheduledFailureType != NoFailure) { error = context->blockedError(request); return; } handle->createCFURLConnection(storedCredentials == AllowStoredCredentials, ResourceHandle::shouldContentSniffURL(request.url()), SchedulingBehavior::Synchronous, handle->client()->connectionProperties(handle.get()).get()); CFURLConnectionScheduleWithRunLoop(handle->connection(), CFRunLoopGetCurrent(), synchronousLoadRunLoopMode()); CFURLConnectionScheduleDownloadWithRunLoop(handle->connection(), CFRunLoopGetCurrent(), synchronousLoadRunLoopMode()); CFURLConnectionStart(handle->connection()); while (!client.isDone()) CFRunLoopRunInMode(synchronousLoadRunLoopMode(), UINT_MAX, true); error = client.error(); CFURLConnectionCancel(handle->connection()); if (error.isNull()) response = client.response(); data.swap(client.mutableData()); }
void WebAssociatedURLLoaderImpl::ClientAdapter::didReceiveResponse( unsigned long, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle) { ALLOW_UNUSED_LOCAL(handle); DCHECK(!handle); if (!m_client) return; if (m_options.exposeAllResponseHeaders || m_options.crossOriginRequestPolicy != WebAssociatedURLLoaderOptions:: CrossOriginRequestPolicyUseAccessControl) { // Use the original ResourceResponse. m_client->didReceiveResponse(WrappedResourceResponse(response)); return; } HTTPHeaderSet exposedHeaders; extractCorsExposedHeaderNamesList(response, exposedHeaders); HTTPHeaderSet blockedHeaders; for (const auto& header : response.httpHeaderFields()) { if (FetchUtils::isForbiddenResponseHeaderName(header.key) || (!isOnAccessControlResponseHeaderWhitelist(header.key) && !exposedHeaders.contains(header.key))) blockedHeaders.add(header.key); } if (blockedHeaders.isEmpty()) { // Use the original ResourceResponse. m_client->didReceiveResponse(WrappedResourceResponse(response)); return; } // If there are blocked headers, copy the response so we can remove them. WebURLResponse validatedResponse = WrappedResourceResponse(response); for (const auto& header : blockedHeaders) validatedResponse.clearHTTPHeaderField(header); m_client->didReceiveResponse(validatedResponse); }
void ProgressTracker::incrementProgress(unsigned long identifier, const ResourceResponse& response) { LOG(Progress, "Progress incremented (%p) - value %f, tracked frames %d, originating frame %p", this, m_progressValue, m_numProgressTrackedFrames, m_originatingProgressFrame.get()); if (m_numProgressTrackedFrames <= 0) return; long long estimatedLength = response.expectedContentLength(); if (estimatedLength < 0) estimatedLength = progressItemDefaultEstimatedLength; m_totalPageAndResourceBytesToLoad += estimatedLength; auto& item = m_progressItems.add(identifier, nullptr).iterator->value; if (!item) { item = std::make_unique<ProgressItem>(estimatedLength); return; } item->bytesReceived = 0; item->estimatedLength = estimatedLength; }
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(); }
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)); }
void SubresourceLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse) { // Store the previous URL because the call to ResourceLoader::willSendRequest will modify it. URL previousURL = request().url(); Ref<SubresourceLoader> protect(*this); ASSERT(!newRequest.isNull()); if (!redirectResponse.isNull()) { // CachedResources are keyed off their original request URL. // Requesting the same original URL a second time can redirect to a unique second resource. // Therefore, if a redirect to a different destination URL occurs, we should no longer consider this a revalidation of the first resource. // Doing so would have us reusing the resource from the first request if the second request's revalidation succeeds. if (newRequest.isConditional() && m_resource->resourceToRevalidate() && newRequest.url() != m_resource->resourceToRevalidate()->response().url()) { newRequest.makeUnconditional(); MemoryCache::singleton().revalidationFailed(*m_resource); if (m_frame) m_frame->mainFrame().diagnosticLoggingClient().logDiagnosticMessageWithResult(DiagnosticLoggingKeys::cachedResourceRevalidationKey(), emptyString(), DiagnosticLoggingResultFail); } if (!m_documentLoader->cachedResourceLoader().canRequest(m_resource->type(), newRequest.url(), options())) { cancel(); return; } if (m_resource->isImage() && m_documentLoader->cachedResourceLoader().shouldDeferImageLoad(newRequest.url())) { cancel(); return; } m_resource->willSendRequest(newRequest, redirectResponse); } if (newRequest.isNull() || reachedTerminalState()) return; ResourceLoader::willSendRequest(newRequest, redirectResponse); if (newRequest.isNull()) cancel(); }
TEST(ResourceTest, RevalidateWithFragment) { KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); ResourceResponse response; response.setURL(url); response.setHTTPStatusCode(200); Resource* resource = RawResource::create(url, Resource::Raw); resource->responseReceived(response, nullptr); resource->finish(); // Revalidating with a url that differs by only the fragment // shouldn't trigger a securiy check. url.setFragmentIdentifier("bar"); resource->setRevalidatingRequest(ResourceRequest(url)); ResourceResponse revalidatingResponse; revalidatingResponse.setURL(url); revalidatingResponse.setHTTPStatusCode(304); resource->responseReceived(revalidatingResponse, nullptr); }
void ResourceLoader::didReceiveResponse(const ResourceResponse& r) { ASSERT(!m_reachedTerminalState); // Protect this in this delegate method since the additional processing can do // anything including possibly derefing this; one example of this is Radar 3266216. Ref<ResourceLoader> protect(*this); logResourceResponseSource(m_frame.get(), r.source()); m_response = r; if (m_response.isHttpVersion0_9()) { String message = "Sandboxing '" + m_response.url().string() + "' because it is using HTTP/0.9."; m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, m_identifier); frameLoader()->forceSandboxFlags(SandboxScripts | SandboxPlugins); } if (FormData* data = m_request.httpBody()) data->removeGeneratedFilesIfNeeded(); if (m_options.sendLoadCallbacks() == SendCallbacks) frameLoader()->notifier().didReceiveResponse(this, m_response); }
void MainResourceLoader::didReceiveResponse(const ResourceResponse& r) { #if ENABLE(OFFLINE_WEB_APPLICATIONS) if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForMainResponse(request(), r)) return; #endif HTTPHeaderMap::const_iterator it = r.httpHeaderFields().find(AtomicString("x-frame-options")); if (it != r.httpHeaderFields().end()) { String content = it->second; if (m_frame->loader()->shouldInterruptLoadForXFrameOptions(content, r.url())) { cancel(); return; } } // There is a bug in CFNetwork where callbacks can be dispatched even when loads are deferred. // See <rdar://problem/6304600> for more details. #if !PLATFORM(CF) ASSERT(shouldLoadAsEmptyDocument(r.url()) || !defersLoading()); #endif if (m_loadingMultipartContent) { frameLoader()->setupForReplaceByMIMEType(r.mimeType()); clearResourceData(); } if (r.isMultipart()) m_loadingMultipartContent = true; // The additional processing can do anything including possibly removing the last // reference to this object; one example of this is 3266216. RefPtr<MainResourceLoader> protect(this); m_documentLoader->setResponse(r); m_response = r; ASSERT(!m_waitingForContentPolicy); m_waitingForContentPolicy = true; ref(); // balanced by deref in continueAfterContentPolicy and didCancel frameLoader()->checkContentPolicy(m_response.mimeType(), callContinueAfterContentPolicy, this); }
void WorkerScriptLoader::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle) { DCHECK(!handle); if (response.httpStatusCode() / 100 != 2 && response.httpStatusCode()) { notifyError(); return; } m_identifier = identifier; m_responseURL = response.url(); m_responseEncoding = response.textEncodingName(); m_appCacheID = response.appCacheID(); processContentSecurityPolicy(response); m_originTrialTokens = OriginTrialContext::parseHeaderValue(response.httpHeaderField(HTTPNames::Origin_Trial)); if (NetworkUtils::isReservedIPAddress(response.remoteIPAddress())) { m_responseAddressSpace = SecurityOrigin::create(m_responseURL)->isLocalhost() ? WebAddressSpaceLocal : WebAddressSpacePrivate; } if (m_responseCallback) (*m_responseCallback)(); }
static bool canUseResponse(ResourceResponse& response, double responseTimestamp) { if (response.isNull()) return false; // FIXME: Why isn't must-revalidate considered a reason we can't use the response? if (response.cacheControlContainsNoCache() || response.cacheControlContainsNoStore()) return false; if (response.httpStatusCode() == 303) { // Must not be cached. return false; } if (response.httpStatusCode() == 302 || response.httpStatusCode() == 307) { // Default to not cacheable. // FIXME: Consider allowing these to be cached if they have headers permitting caching. return false; } return currentAge(response, responseTimestamp) <= freshnessLifetime(response, responseTimestamp); }
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = adoptGRef(response.toSoupMessage()); m_download->didReceiveResponse(response); if (response.httpStatusCode() >= 400) { downloadFailed(downloadNetworkError(ResourceError(errorDomainDownload, response.httpStatusCode(), response.url().string(), response.httpStatusText()))); return; } String suggestedFilename = response.suggestedFilename(); if (suggestedFilename.isEmpty()) { KURL url = response.url(); url.setQuery(String()); url.removeFragmentIdentifier(); suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent()); } bool overwrite; String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename.utf8().data(), overwrite); if (destinationURI.isEmpty()) { GOwnPtr<char> errorMessage(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data())); downloadFailed(downloadDestinationError(response, errorMessage.get())); return; } GRefPtr<GFile> file = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data())); GOwnPtr<GError> error; m_outputStream = adoptGRef(g_file_replace(file.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr())); if (!m_outputStream) { downloadFailed(downloadDestinationError(response, error->message)); return; } m_download->didCreateDestination(destinationURI); }
ResourceError FrameLoaderClientAndroid::pluginWillHandleLoadError(const ResourceResponse& request) { return ResourceError(String(), InternalErrorPluginWillHandleLoadError, request.url(), String()); }
ResourceError FrameLoaderClientAndroid::fileDoesNotExistError(const ResourceResponse& request) { return ResourceError(String(), InternalErrorFileDoesNotExist, request.url(), String()); }
ResourceError FrameLoaderClientAndroid::cannotShowMIMETypeError(const ResourceResponse& request) { return ResourceError(String(), InternalErrorCannotShowMimeType, request.url(), String()); }