MediaResourceLoader.cpp [plain text]
#include "config.h"
#include "MediaResourceLoader.h"
#if ENABLE(VIDEO)
#include "CachedRawResource.h"
#include "CachedResourceLoader.h"
#include "CachedResourceRequest.h"
#include "CrossOriginAccessControl.h"
#include "Document.h"
#include "SecurityOrigin.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
MediaResourceLoader::MediaResourceLoader(Document& document, const String& crossOriginMode)
: ContextDestructionObserver(&document)
, m_document(&document)
, m_crossOriginMode(crossOriginMode)
{
}
MediaResourceLoader::~MediaResourceLoader()
{
ASSERT(m_resources.isEmpty());
}
void MediaResourceLoader::contextDestroyed()
{
ContextDestructionObserver::contextDestroyed();
m_document = nullptr;
}
RefPtr<PlatformMediaResource> MediaResourceLoader::requestResource(ResourceRequest&& request, LoadOptions options)
{
if (!m_document)
return nullptr;
DataBufferingPolicy bufferingPolicy = options & LoadOption::BufferData ? WebCore::BufferData : WebCore::DoNotBufferData;
auto cachingPolicy = options & LoadOption::DisallowCaching ? CachingPolicy::DisallowCaching : CachingPolicy::AllowCaching;
request.setRequester(ResourceRequest::Requester::Media);
#if HAVE(AVFOUNDATION_LOADER_DELEGATE) && PLATFORM(MAC)
if (!m_crossOriginMode.isNull())
request.makeUnconditional();
#endif
CachedResourceRequest cacheRequest(WTFMove(request), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, bufferingPolicy, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, cachingPolicy));
cacheRequest.setAsPotentiallyCrossOrigin(m_crossOriginMode, *m_document);
CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest));
if (!resource)
return nullptr;
Ref<MediaResource> mediaResource = MediaResource::create(*this, resource);
m_resources.add(mediaResource.ptr());
return WTFMove(mediaResource);
}
void MediaResourceLoader::removeResource(MediaResource& mediaResource)
{
ASSERT(m_resources.contains(&mediaResource));
m_resources.remove(&mediaResource);
}
Ref<MediaResource> MediaResource::create(MediaResourceLoader& loader, CachedResourceHandle<CachedRawResource> resource)
{
return adoptRef(*new MediaResource(loader, resource));
}
MediaResource::MediaResource(MediaResourceLoader& loader, CachedResourceHandle<CachedRawResource> resource)
: m_loader(loader)
, m_resource(resource)
{
ASSERT(resource);
resource->addClient(*this);
}
MediaResource::~MediaResource()
{
stop();
m_loader->removeResource(*this);
}
void MediaResource::stop()
{
if (!m_resource)
return;
m_resource->removeClient(*this);
m_resource = nullptr;
}
void MediaResource::setDefersLoading(bool defersLoading)
{
if (m_resource)
m_resource->setDefersLoading(defersLoading);
}
void MediaResource::responseReceived(CachedResource& resource, const ResourceResponse& response)
{
ASSERT_UNUSED(resource, &resource == m_resource);
if (!m_loader->document())
return;
RefPtr<MediaResource> protectedThis(this);
if (m_resource->resourceError().isAccessControl()) {
static NeverDestroyed<const String> consoleMessage("Cross-origin media resource load denied by Cross-Origin Resource Sharing policy.");
m_loader->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage.get());
m_didPassAccessControlCheck = false;
if (m_client)
m_client->accessControlCheckFailed(*this, ResourceError(errorDomainWebKitInternal, 0, response.url(), consoleMessage.get()));
stop();
return;
}
m_didPassAccessControlCheck = m_resource->options().mode == FetchOptions::Mode::Cors;
if (m_client)
m_client->responseReceived(*this, response);
}
bool MediaResource::shouldCacheResponse(CachedResource& resource, const ResourceResponse& response)
{
ASSERT_UNUSED(resource, &resource == m_resource);
RefPtr<MediaResource> protectedThis(this);
if (m_client)
return m_client->shouldCacheResponse(*this, response);
return true;
}
void MediaResource::redirectReceived(CachedResource& resource, ResourceRequest& request, const ResourceResponse& response)
{
ASSERT_UNUSED(resource, &resource == m_resource);
RefPtr<MediaResource> protectedThis(this);
if (m_client)
m_client->redirectReceived(*this, request, response);
}
void MediaResource::dataSent(CachedResource& resource, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
ASSERT_UNUSED(resource, &resource == m_resource);
RefPtr<MediaResource> protectedThis(this);
if (m_client)
m_client->dataSent(*this, bytesSent, totalBytesToBeSent);
}
void MediaResource::dataReceived(CachedResource& resource, const char* data, int dataLength)
{
ASSERT_UNUSED(resource, &resource == m_resource);
RefPtr<MediaResource> protectedThis(this);
if (m_client)
m_client->dataReceived(*this, data, dataLength);
}
void MediaResource::notifyFinished(CachedResource& resource)
{
ASSERT_UNUSED(resource, &resource == m_resource);
RefPtr<MediaResource> protectedThis(this);
if (m_client) {
if (m_resource->loadFailedOrCanceled())
m_client->loadFailed(*this, m_resource->resourceError());
else
m_client->loadFinished(*this);
}
stop();
}
#if USE(SOUP)
char* MediaResource::getOrCreateReadBuffer(CachedResource& resource, size_t requestedSize, size_t& actualSize)
{
ASSERT_UNUSED(resource, &resource == m_resource);
return m_client ? m_client->getOrCreateReadBuffer(*this, requestedSize, actualSize) : nullptr;
}
#endif
}
#endif