#include "config.h"
#include "RemoteCDM.h"
#if ENABLE(GPU_PROCESS) && ENABLE(ENCRYPTED_MEDIA)
#include "GPUProcessConnection.h"
#include "RemoteCDMInstance.h"
#include "RemoteCDMInstanceConfiguration.h"
#include "RemoteCDMInstanceIdentifier.h"
#include "RemoteCDMProxyMessages.h"
#include "WebCoreArgumentCoders.h"
#include "WebProcess.h"
#include <WebCore/CDMKeySystemConfiguration.h>
#include <WebCore/CDMRestrictions.h>
#include <WebCore/SharedBuffer.h>
namespace WebKit {
using namespace WebCore;
std::unique_ptr<RemoteCDM> RemoteCDM::create(WeakPtr<RemoteCDMFactory>&& factory, RemoteCDMIdentifier&& identifier, RemoteCDMConfiguration&& configuration)
{
return std::unique_ptr<RemoteCDM>(new RemoteCDM(WTFMove(factory), WTFMove(identifier), WTFMove(configuration)));
}
RemoteCDM::RemoteCDM(WeakPtr<RemoteCDMFactory>&& factory, RemoteCDMIdentifier&& identifier, RemoteCDMConfiguration&& configuration)
: m_factory(WTFMove(factory))
, m_identifier(WTFMove(identifier))
, m_configuration(WTFMove(configuration))
{
}
void RemoteCDM::getSupportedConfiguration(CDMKeySystemConfiguration&& configuration, LocalStorageAccess access, SupportedConfigurationCallback&& callback)
{
if (!m_factory) {
callback(WTF::nullopt);
return;
}
m_factory->gpuProcessConnection().connection().sendWithAsyncReply(Messages::RemoteCDMProxy::GetSupportedConfiguration(WTFMove(configuration), access), WTFMove(callback), m_identifier);
}
bool RemoteCDM::supportsConfiguration(const CDMKeySystemConfiguration&) const
{
ASSERT_NOT_REACHED();
return false;
}
bool RemoteCDM::supportsConfigurationWithRestrictions(const CDMKeySystemConfiguration&, const CDMRestrictions&) const
{
ASSERT_NOT_REACHED();
return false;
}
bool RemoteCDM::supportsSessionTypeWithConfiguration(const CDMSessionType&, const CDMKeySystemConfiguration&) const
{
ASSERT_NOT_REACHED();
return false;
}
bool RemoteCDM::supportsInitData(const AtomString& type, const SharedBuffer& data) const
{
return true;
}
CDMRequirement RemoteCDM::distinctiveIdentifiersRequirement(const CDMKeySystemConfiguration& configuration, const CDMRestrictions& restrictions) const
{
ASSERT_NOT_REACHED();
return CDMRequirement::NotAllowed;
}
CDMRequirement RemoteCDM::persistentStateRequirement(const CDMKeySystemConfiguration&, const CDMRestrictions&) const
{
ASSERT_NOT_REACHED();
return CDMRequirement::NotAllowed;
}
bool RemoteCDM::distinctiveIdentifiersAreUniquePerOriginAndClearable(const CDMKeySystemConfiguration&) const
{
ASSERT_NOT_REACHED();
return false;
}
RefPtr<CDMInstance> RemoteCDM::createInstance()
{
if (!m_factory)
return nullptr;
RemoteCDMInstanceIdentifier identifier;
RemoteCDMInstanceConfiguration configuration;
m_factory->gpuProcessConnection().connection().sendSync(Messages::RemoteCDMProxy::CreateInstance(), Messages::RemoteCDMProxy::CreateInstance::Reply(identifier, configuration), m_identifier);
if (!identifier)
return nullptr;
return RemoteCDMInstance::create(makeWeakPtr(m_factory.get()), WTFMove(identifier), WTFMove(configuration));
}
void RemoteCDM::loadAndInitialize()
{
if (!m_factory)
return;
m_factory->gpuProcessConnection().connection().send(Messages::RemoteCDMProxy::LoadAndInitialize(), m_identifier);
}
RefPtr<SharedBuffer> RemoteCDM::sanitizeResponse(const SharedBuffer& response) const
{
return response.copy();
}
Optional<String> RemoteCDM::sanitizeSessionId(const String& sessionId) const
{
return sessionId;
}
}
#endif