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 "GenericEventQueue.h"
#include "MediaKeyError.h"
#include "MediaKeyMessageEvent.h"
#include "MediaKeys.h"
#include "Settings.h"
namespace WebCore {
PassRefPtr<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())
, m_keyRequestTimer(this, &MediaKeySession::keyRequestTimerFired)
, m_addKeyTimer(this, &MediaKeySession::addKeyTimerFired)
{
m_session->setClient(this);
}
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();
}
const String& MediaKeySession::sessionId() const
{
return m_session->sessionId();
}
void MediaKeySession::generateKeyRequest(const String& mimeType, Uint8Array* initData)
{
m_pendingKeyRequests.append(PendingKeyRequest(mimeType, initData));
m_keyRequestTimer.startOneShot(0);
}
void MediaKeySession::keyRequestTimerFired(Timer&)
{
ASSERT(m_pendingKeyRequests.size());
if (!m_session)
return;
while (!m_pendingKeyRequests.isEmpty()) {
PendingKeyRequest request = m_pendingKeyRequests.takeFirst();
String destinationURL;
MediaKeyError::Code errorCode = 0;
unsigned long systemCode = 0;
RefPtr<Uint8Array> keyRequest = m_session->generateKeyRequest(request.mimeType, request.initData.get(), destinationURL, errorCode, systemCode);
if (!keyRequest) {
sendError(errorCode, systemCode);
continue;
}
sendMessage(keyRequest.get(), destinationURL);
}
}
void MediaKeySession::update(Uint8Array* key, ExceptionCode& ec)
{
if (!key || !key->length()) {
ec = INVALID_ACCESS_ERR;
return;
}
m_pendingKeys.append(key);
m_addKeyTimer.startOneShot(0);
}
void MediaKeySession::addKeyTimerFired(Timer&)
{
ASSERT(m_pendingKeys.size());
if (!m_session)
return;
while (!m_pendingKeys.isEmpty()) {
RefPtr<Uint8Array> pendingKey = m_pendingKeys.takeFirst();
unsigned short errorCode = 0;
unsigned long systemCode = 0;
bool didStoreKey = false;
RefPtr<Uint8Array> nextMessage;
didStoreKey = m_session->update(pendingKey.get(), nextMessage, errorCode, systemCode);
if (nextMessage)
sendMessage(nextMessage.get(), emptyString());
if (didStoreKey) {
RefPtr<Event> keyaddedEvent = Event::create(eventNames().webkitkeyaddedEvent, false, false);
keyaddedEvent->setTarget(this);
m_asyncEventQueue.enqueueEvent(keyaddedEvent.release());
}
if (errorCode) {
sendError(errorCode, systemCode);
}
}
}
void MediaKeySession::sendMessage(Uint8Array* message, String destinationURL)
{
MediaKeyMessageEventInit init;
init.bubbles = false;
init.cancelable = false;
init.message = message;
init.destinationURL = destinationURL;
RefPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(eventNames().webkitkeymessageEvent, init);
event->setTarget(this);
m_asyncEventQueue.enqueueEvent(event.release());
}
void MediaKeySession::sendError(CDMSessionClient::MediaKeyErrorCode errorCode, unsigned long systemCode)
{
RefPtr<MediaKeyError> error = MediaKeyError::create(errorCode, systemCode).get();
setError(error.get());
RefPtr<Event> keyerrorEvent = Event::create(eventNames().webkitkeyerrorEvent, false, false);
keyerrorEvent->setTarget(this);
m_asyncEventQueue.enqueueEvent(keyerrorEvent.release());
}
String MediaKeySession::mediaKeysStorageDirectory() const
{
Document* document = toDocument(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());
}
}
#endif