SubresourceLoader.cpp [plain text]
#include "config.h"
#include "SubresourceLoader.h"
#include "CachedResourceLoader.h"
#include "CrossOriginAccessControl.h"
#include "DiagnosticLoggingClient.h"
#include "DiagnosticLoggingKeys.h"
#include "Document.h"
#include "DocumentLoader.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "Logging.h"
#include "MainFrame.h"
#include "MemoryCache.h"
#include "Page.h"
#include "ResourceLoadObserver.h"
#include "Settings.h"
#include <wtf/Ref.h>
#include <wtf/RefCountedLeakCounter.h>
#include <wtf/StdLibExtras.h>
#include <wtf/TemporaryChange.h>
#include <wtf/text/CString.h>
#if PLATFORM(IOS)
#include <RuntimeApplicationChecks.h>
#endif
#if ENABLE(CONTENT_EXTENSIONS)
#include "ResourceLoadInfo.h"
#endif
namespace WebCore {
DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, subresourceLoaderCounter, ("SubresourceLoader"));
SubresourceLoader::RequestCountTracker::RequestCountTracker(CachedResourceLoader& cachedResourceLoader, const CachedResource& resource)
: m_cachedResourceLoader(cachedResourceLoader)
, m_resource(resource)
{
m_cachedResourceLoader.incrementRequestCount(m_resource);
}
SubresourceLoader::RequestCountTracker::~RequestCountTracker()
{
m_cachedResourceLoader.decrementRequestCount(m_resource);
}
SubresourceLoader::SubresourceLoader(Frame& frame, CachedResource& resource, const ResourceLoaderOptions& options)
: ResourceLoader(frame, options)
, m_resource(&resource)
, m_loadingMultipartContent(false)
, m_state(Uninitialized)
, m_requestCountTracker(InPlace, frame.document()->cachedResourceLoader(), resource)
{
#ifndef NDEBUG
subresourceLoaderCounter.increment();
#endif
#if ENABLE(CONTENT_EXTENSIONS)
m_resourceType = toResourceType(resource.type());
#endif
}
SubresourceLoader::~SubresourceLoader()
{
ASSERT(m_state != Initialized);
ASSERT(reachedTerminalState());
#ifndef NDEBUG
subresourceLoaderCounter.decrement();
#endif
}
RefPtr<SubresourceLoader> SubresourceLoader::create(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
{
RefPtr<SubresourceLoader> subloader(adoptRef(new SubresourceLoader(frame, resource, options)));
#if PLATFORM(IOS)
if (!IOSApplication::isWebProcess()) {
subloader->m_iOSOriginalRequest = request;
return subloader.release();
}
#endif
if (!subloader->init(request))
return nullptr;
return subloader;
}
#if PLATFORM(IOS)
bool SubresourceLoader::startLoading()
{
ASSERT(!IOSApplication::isWebProcess());
if (!init(m_iOSOriginalRequest))
return false;
m_iOSOriginalRequest = ResourceRequest();
start();
return true;
}
#endif
CachedResource* SubresourceLoader::cachedResource()
{
return m_resource;
}
void SubresourceLoader::cancelIfNotFinishing()
{
if (m_state != Initialized)
return;
ResourceLoader::cancel();
}
bool SubresourceLoader::init(const ResourceRequest& request)
{
if (!ResourceLoader::init(request))
return false;
ASSERT(!reachedTerminalState());
m_state = Initialized;
m_documentLoader->addSubresourceLoader(this);
if (options().mode == FetchOptions::Mode::Cors)
m_origin = SecurityOrigin::createFromString(request.httpOrigin());
return true;
}
bool SubresourceLoader::isSubresourceLoader()
{
return true;
}
void SubresourceLoader::willSendRequestInternal(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
{
URL previousURL = request().url();
Ref<SubresourceLoader> protectedThis(*this);
if (!newRequest.url().isValid()) {
cancel(cannotShowURLError());
return;
}
ASSERT(!newRequest.isNull());
if (!redirectResponse.isNull()) {
if (options().redirect != FetchOptions::Redirect::Follow) {
if (options().redirect == FetchOptions::Redirect::Error) {
cancel();
return;
}
m_resource->setOpaqueRedirect();
m_resource->responseReceived({ });
didFinishLoading(currentTime());
return;
}
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->page())
m_frame->page()->diagnosticLoggingClient().logDiagnosticMessageWithResult(DiagnosticLoggingKeys::cachedResourceRevalidationKey(), emptyString(), DiagnosticLoggingResultFail, ShouldSample::Yes);
}
if (!m_documentLoader->cachedResourceLoader().canRequest(m_resource->type(), newRequest.url(), options(), false , true )) {
cancel();
return;
}
if (options().mode == FetchOptions::Mode::Cors && !checkCrossOriginAccessControl(request(), redirectResponse, newRequest)) {
cancel();
return;
}
if (m_resource->isImage() && m_documentLoader->cachedResourceLoader().shouldDeferImageLoad(newRequest.url())) {
cancel();
return;
}
m_resource->redirectReceived(newRequest, redirectResponse);
}
if (newRequest.isNull() || reachedTerminalState())
return;
ResourceLoader::willSendRequestInternal(newRequest, redirectResponse);
if (newRequest.isNull())
cancel();
ResourceLoadObserver::sharedObserver().logSubresourceLoading(m_frame.get(), newRequest, redirectResponse);
}
void SubresourceLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
ASSERT(m_state == Initialized);
Ref<SubresourceLoader> protectedThis(*this);
m_resource->didSendData(bytesSent, totalBytesToBeSent);
}
void SubresourceLoader::didReceiveResponse(const ResourceResponse& response)
{
ASSERT(!response.isNull());
ASSERT(m_state == Initialized);
Ref<SubresourceLoader> protectedThis(*this);
if (shouldIncludeCertificateInfo())
response.includeCertificateInfo();
if (response.isHttpVersion0_9()) {
if (m_frame) {
String message = "Sandboxing '" + response.url().string() + "' because it is using HTTP/0.9.";
m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message, identifier());
frameLoader()->forceSandboxFlags(SandboxScripts | SandboxPlugins);
}
}
if (m_resource->resourceToRevalidate()) {
if (response.httpStatusCode() == 304) {
m_resource->setResponse(response);
MemoryCache::singleton().revalidationSucceeded(*m_resource, response);
if (m_frame && m_frame->page())
m_frame->page()->diagnosticLoggingClient().logDiagnosticMessageWithResult(DiagnosticLoggingKeys::cachedResourceRevalidationKey(), emptyString(), DiagnosticLoggingResultPass, ShouldSample::Yes);
if (!reachedTerminalState())
ResourceLoader::didReceiveResponse(response);
return;
}
MemoryCache::singleton().revalidationFailed(*m_resource);
if (m_frame && m_frame->page())
m_frame->page()->diagnosticLoggingClient().logDiagnosticMessageWithResult(DiagnosticLoggingKeys::cachedResourceRevalidationKey(), emptyString(), DiagnosticLoggingResultFail, ShouldSample::Yes);
}
m_resource->responseReceived(response);
if (reachedTerminalState())
return;
ResourceLoader::didReceiveResponse(response);
if (reachedTerminalState())
return;
if (response.isMultipart() && m_resource->type() != CachedResource::MainResource) {
m_loadingMultipartContent = true;
m_requestCountTracker = Nullopt;
if (!m_resource->isImage()) {
cancel();
return;
}
}
auto* buffer = resourceData();
if (m_loadingMultipartContent && buffer && buffer->size()) {
m_resource->finishLoading(buffer->copy().ptr());
clearResourceData();
m_documentLoader->subresourceLoaderFinishedLoadingOnePart(this);
didFinishLoadingOnePart(0);
}
checkForHTTPStatusCodeError();
}
void SubresourceLoader::didReceiveData(const char* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)
{
didReceiveDataOrBuffer(data, length, nullptr, encodedDataLength, dataPayloadType);
}
void SubresourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
didReceiveDataOrBuffer(nullptr, 0, WTFMove(buffer), encodedDataLength, dataPayloadType);
}
void SubresourceLoader::didReceiveDataOrBuffer(const char* data, int length, RefPtr<SharedBuffer>&& prpBuffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())
return;
ASSERT(!m_resource->resourceToRevalidate());
ASSERT(!m_resource->errorOccurred());
ASSERT(m_state == Initialized);
Ref<SubresourceLoader> protectedThis(*this);
RefPtr<SharedBuffer> buffer = prpBuffer;
ResourceLoader::didReceiveDataOrBuffer(data, length, WTFMove(buffer), encodedDataLength, dataPayloadType);
if (!m_loadingMultipartContent) {
if (auto* resourceData = this->resourceData())
m_resource->addDataBuffer(*resourceData);
else
m_resource->addData(buffer ? buffer->data() : data, buffer ? buffer->size() : length);
}
}
bool SubresourceLoader::checkForHTTPStatusCodeError()
{
if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
return false;
m_state = Finishing;
m_resource->error(CachedResource::LoadError);
cancel();
return true;
}
static void logResourceLoaded(Frame* frame, CachedResource::Type type)
{
if (!frame || !frame->page())
return;
String resourceType;
switch (type) {
case CachedResource::MainResource:
resourceType = DiagnosticLoggingKeys::mainResourceKey();
break;
case CachedResource::ImageResource:
resourceType = DiagnosticLoggingKeys::imageKey();
break;
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
case CachedResource::CSSStyleSheet:
resourceType = DiagnosticLoggingKeys::styleSheetKey();
break;
case CachedResource::Script:
resourceType = DiagnosticLoggingKeys::scriptKey();
break;
case CachedResource::FontResource:
#if ENABLE(SVG_FONTS)
case CachedResource::SVGFontResource:
#endif
resourceType = DiagnosticLoggingKeys::fontKey();
break;
case CachedResource::MediaResource:
case CachedResource::RawResource:
resourceType = DiagnosticLoggingKeys::rawKey();
break;
case CachedResource::SVGDocumentResource:
resourceType = DiagnosticLoggingKeys::svgDocumentKey();
break;
case CachedResource::LinkPreload:
#if ENABLE(LINK_PREFETCH)
case CachedResource::LinkPrefetch:
case CachedResource::LinkSubresource:
#endif
#if ENABLE(VIDEO_TRACK)
case CachedResource::TextTrackResource:
#endif
resourceType = DiagnosticLoggingKeys::otherKey();
break;
}
frame->page()->diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceKey(), DiagnosticLoggingKeys::loadedKey(), resourceType, ShouldSample::Yes);
}
bool SubresourceLoader::checkCrossOriginAccessControl(const ResourceRequest& previousRequest, const ResourceResponse& redirectResponse, ResourceRequest& newRequest)
{
if (m_origin->canRequest(newRequest.url()))
return true;
String errorDescription;
bool responsePassesCORS = m_origin->canRequest(previousRequest.url())
|| passesAccessControlCheck(redirectResponse, options().allowCredentials(), *m_origin, errorDescription);
if (!responsePassesCORS || !isValidCrossOriginRedirectionURL(newRequest.url())) {
if (m_frame && m_frame->document()) {
String errorMessage = "Cross-origin redirection denied by Cross-Origin Resource Sharing policy: " +
(!responsePassesCORS ? errorDescription : "Redirected to either a non-HTTP URL or a URL that contains credentials.");
m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, errorMessage);
}
return false;
}
m_origin = SecurityOrigin::createUnique();
cleanRedirectedRequestForAccessControl(newRequest);
updateRequestForAccessControl(newRequest, *m_origin, options().allowCredentials());
return true;
}
void SubresourceLoader::didFinishLoading(double finishTime)
{
if (m_state != Initialized)
return;
ASSERT(!reachedTerminalState());
ASSERT(!m_resource->resourceToRevalidate());
ASSERT(!m_resource->errorOccurred() || m_resource->status() == CachedResource::DecodeError);
LOG(ResourceLoading, "Received '%s'.", m_resource->url().string().latin1().data());
logResourceLoaded(m_frame.get(), m_resource->type());
Ref<SubresourceLoader> protectedThis(*this);
CachedResourceHandle<CachedResource> protectResource(m_resource);
m_state = Finishing;
m_resource->setLoadFinishTime(finishTime);
m_resource->finishLoading(resourceData());
if (wasCancelled())
return;
m_resource->finish();
ASSERT(!reachedTerminalState());
didFinishLoadingOnePart(finishTime);
notifyDone();
if (reachedTerminalState())
return;
releaseResources();
}
void SubresourceLoader::didFail(const ResourceError& error)
{
if (m_state != Initialized)
return;
ASSERT(!reachedTerminalState());
LOG(ResourceLoading, "Failed to load '%s'.\n", m_resource->url().string().latin1().data());
Ref<SubresourceLoader> protectedThis(*this);
CachedResourceHandle<CachedResource> protectResource(m_resource);
m_state = Finishing;
if (m_resource->resourceToRevalidate())
MemoryCache::singleton().revalidationFailed(*m_resource);
m_resource->setResourceError(error);
if (!m_resource->isPreloaded())
MemoryCache::singleton().remove(*m_resource);
m_resource->error(CachedResource::LoadError);
cleanupForError(error);
notifyDone();
if (reachedTerminalState())
return;
releaseResources();
}
void SubresourceLoader::willCancel(const ResourceError& error)
{
#if PLATFORM(IOS)
if (m_state != Initialized && m_state != Uninitialized)
#else
if (m_state != Initialized)
#endif
return;
ASSERT(!reachedTerminalState());
LOG(ResourceLoading, "Cancelled load of '%s'.\n", m_resource->url().string().latin1().data());
Ref<SubresourceLoader> protectedThis(*this);
#if PLATFORM(IOS)
m_state = m_state == Uninitialized ? CancelledWhileInitializing : Finishing;
#else
m_state = Finishing;
#endif
auto& memoryCache = MemoryCache::singleton();
if (m_resource->resourceToRevalidate())
memoryCache.revalidationFailed(*m_resource);
m_resource->setResourceError(error);
memoryCache.remove(*m_resource);
}
void SubresourceLoader::didCancel(const ResourceError&)
{
if (m_state == Uninitialized)
return;
m_resource->cancelLoad();
notifyDone();
}
void SubresourceLoader::notifyDone()
{
if (reachedTerminalState())
return;
m_requestCountTracker = Nullopt;
#if PLATFORM(IOS)
m_documentLoader->cachedResourceLoader().loadDone(m_resource, m_state != CancelledWhileInitializing);
#else
m_documentLoader->cachedResourceLoader().loadDone(m_resource);
#endif
if (reachedTerminalState())
return;
m_documentLoader->removeSubresourceLoader(this);
}
void SubresourceLoader::releaseResources()
{
ASSERT(!reachedTerminalState());
#if PLATFORM(IOS)
if (m_state != Uninitialized && m_state != CancelledWhileInitializing)
#else
if (m_state != Uninitialized)
#endif
m_resource->clearLoader();
m_resource = nullptr;
ResourceLoader::releaseResources();
}
}