MediaKeySession.cpp [plain text]
#include "config.h"
#include "MediaKeySession.h"
#if ENABLE(ENCRYPTED_MEDIA_V2)
#include "CDM.h"
#include "CDMSession.h"
#include "Document.h"
#include "Event.h"
#include "EventNames.h"
#include "FileSystem.h"
#include "GenericEventQueue.h"
#include "MediaKeyError.h"
#include "MediaKeyMessageEvent.h"
#include "MediaKeys.h"
#include "Settings.h"
namespace WebCore {
Ref<MediaKeySession> MediaKeySession::create(ScriptExecutionContext& context, MediaKeys* keys, const String& keySystem)
{
auto session = adoptRef(*new MediaKeySession(context, keys, keySystem));
session->suspendIfNeeded();
return session;
}
MediaKeySession::MediaKeySession(ScriptExecutionContext& context, MediaKeys* keys, const String& keySystem)
: ActiveDOMObject(&context)
, m_keys(keys)
, m_keySystem(keySystem)
, m_asyncEventQueue(*this)
, m_session(keys->cdm()->createSession(this))
, m_keyRequestTimer(*this, &MediaKeySession::keyRequestTimerFired)
, m_addKeyTimer(*this, &MediaKeySession::addKeyTimerFired)
{
}
MediaKeySession::~MediaKeySession()
{
if (m_session) {
m_session->setClient(nullptr);
m_session = nullptr;
}
m_asyncEventQueue.cancelAllEvents();
}
void MediaKeySession::setError(MediaKeyError* error)
{
m_error = error;
}
void MediaKeySession::close()
{
if (m_session)
m_session->releaseKeys();
}
RefPtr<ArrayBuffer> MediaKeySession::cachedKeyForKeyId(const String& keyId) const
{
return m_session ? m_session->cachedKeyForKeyID(keyId) : nullptr;
}
const String& MediaKeySession::sessionId() const
{
return m_session->sessionId();
}
void MediaKeySession::generateKeyRequest(const String& mimeType, Ref<Uint8Array>&& initData)
{
m_pendingKeyRequests.append({ mimeType, WTFMove(initData) });
m_keyRequestTimer.startOneShot(0);
}
void MediaKeySession::keyRequestTimerFired()
{
ASSERT(m_pendingKeyRequests.size());
if (!m_session)
return;
while (!m_pendingKeyRequests.isEmpty()) {
PendingKeyRequest request = m_pendingKeyRequests.takeFirst();
String destinationURL;
MediaKeyError::Code errorCode = 0;
uint32_t systemCode = 0;
RefPtr<Uint8Array> keyRequest = m_session->generateKeyRequest(request.mimeType, request.initData.ptr(), destinationURL, errorCode, systemCode);
if (errorCode) {
sendError(errorCode, systemCode);
continue;
}
if (keyRequest)
sendMessage(keyRequest.get(), destinationURL);
}
}
void MediaKeySession::update(Ref<Uint8Array>&& key, ExceptionCode& ec)
{
if (!key->length()) {
ec = INVALID_ACCESS_ERR;
return;
}
m_pendingKeys.append(WTFMove(key));
m_addKeyTimer.startOneShot(0);
}
void MediaKeySession::addKeyTimerFired()
{
ASSERT(m_pendingKeys.size());
if (!m_session)
return;
while (!m_pendingKeys.isEmpty()) {
auto pendingKey = m_pendingKeys.takeFirst();
unsigned short errorCode = 0;
uint32_t systemCode = 0;
bool didStoreKey = false;
RefPtr<Uint8Array> nextMessage;
didStoreKey = m_session->update(pendingKey.ptr(), nextMessage, errorCode, systemCode);
if (nextMessage)
sendMessage(nextMessage.get(), emptyString());
if (didStoreKey) {
auto keyaddedEvent = Event::create(eventNames().webkitkeyaddedEvent, false, false);
keyaddedEvent->setTarget(this);
m_asyncEventQueue.enqueueEvent(WTFMove(keyaddedEvent));
keys()->keyAdded();
}
if (errorCode) {
sendError(errorCode, systemCode);
}
}
}
void MediaKeySession::sendMessage(Uint8Array* message, String destinationURL)
{
auto event = MediaKeyMessageEvent::create(eventNames().webkitkeymessageEvent, message, destinationURL);
event->setTarget(this);
m_asyncEventQueue.enqueueEvent(WTFMove(event));
}
void MediaKeySession::sendError(CDMSessionClient::MediaKeyErrorCode errorCode, uint32_t systemCode)
{
Ref<MediaKeyError> error = MediaKeyError::create(errorCode, systemCode).get();
setError(error.ptr());
auto keyerrorEvent = Event::create(eventNames().webkitkeyerrorEvent, false, false);
keyerrorEvent->setTarget(this);
m_asyncEventQueue.enqueueEvent(WTFMove(keyerrorEvent));
}
String MediaKeySession::mediaKeysStorageDirectory() const
{
Document* document = downcast<Document>(scriptExecutionContext());
if (!document)
return emptyString();
Settings* settings = document->settings();
if (!settings)
return emptyString();
String storageDirectory = settings->mediaKeysStorageDirectory();
if (storageDirectory.isEmpty())
return emptyString();
SecurityOrigin* origin = document->securityOrigin();
if (!origin)
return emptyString();
return pathByAppendingComponent(storageDirectory, origin->databaseIdentifier());
}
bool MediaKeySession::hasPendingActivity() const
{
return (m_keys && !isClosed()) || m_asyncEventQueue.hasPendingEvents();
}
void MediaKeySession::stop()
{
close();
}
const char* MediaKeySession::activeDOMObjectName() const
{
return "MediaKeySession";
}
bool MediaKeySession::canSuspendForDocumentSuspension() const
{
return false;
}
}
#endif