nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Backed out 5 changesets (bug 1878713, bug 1878039) for wpt failure on clearkey-check-status-for-hdcp.https.html

Browse source 
Backed out changeset ba6c8f006d21 (bug 1878039)
Backed out changeset 825190c91d7a (bug 1878039)
Backed out changeset dda9fe6e9007 (bug 1878039)
Backed out changeset 1ad9eddcde2a (bug 1878713)
Backed out changeset 693b73304431 (bug 1878713)
This commit is contained in:
Narcis Beleuzu 2024-02-09 03:16:47 +02:00
parent db1369b5d8
commit 4701f6b0f9
35 changed files with 116 additions and 431 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

1
dom/chrome-webidl/ChromeUtils.webidl
View file

@ -1105,5 +1105,4 @@ dictionary CDMInformation {
required DOMString keySystemName;
required DOMString capabilities;
required boolean clearlead;
required boolean isHDCP22Compatible;
};

2
dom/media/eme/CDMProxy.h
View file

@ -241,7 +241,7 @@ class CDMProxy {
// Calls MediaKeys->ResolvePromiseWithKeyStatus(aPromiseId, aKeyStatus) after
// the CDM has processed the request.
virtual void GetStatusForPolicy(PromiseId aPromiseId,
const dom::HDCPVersion& aMinHdcpVersion) = 0;
const nsAString& aMinHdcpVersion) = 0;
#ifdef DEBUG
virtual bool IsOnOwnerThread() = 0;

1
dom/media/eme/EMEUtils.cpp
View file

@ -210,7 +210,6 @@ void MFCDMCapabilitiesIPDLToKeySystemConfig(
aKeySystemConfig.mEncryptionSchemes.AppendElement(
NS_ConvertUTF8toUTF16(EncryptionSchemeStr(scheme)));
}
aKeySystemConfig.mIsHDCP22Compatible = aCDMConfig.isHDCP22Compatible();
EME_LOG("New Capabilities=%s",
NS_ConvertUTF16toUTF8(aKeySystemConfig.GetDebugInfo()).get());
}

4
dom/media/eme/KeySystemConfig.cpp
View file

@ -253,8 +253,6 @@ void KeySystemConfig::GetGMPKeySystemConfigs(dom::Promise* aPromise) {
info->mKeySystemName = name;
info->mCapabilities = keySystemConfigs.LastElement().GetDebugInfo();
info->mClearlead = DoesKeySystemSupportClearLead(name);
// TODO : ask real CDM
info->mIsHDCP22Compatible = false;
}
}
aPromise->MaybeResolve(cdmInfo);
@ -316,8 +314,6 @@ nsString KeySystemConfig::GetDebugInfo() const {
debugInfo.AppendLiteral(" WEBM={");
debugInfo.Append(NS_ConvertUTF8toUTF16(mWebM.GetDebugInfo()));
debugInfo.AppendLiteral("}");
debugInfo.AppendASCII(
nsPrintfCString(" isHDCP22Compatible=%d", mIsHDCP22Compatible));
return debugInfo;
}

1
dom/media/eme/KeySystemConfig.h
View file

@ -176,7 +176,6 @@ struct KeySystemConfig {
nsTArray<nsString> mEncryptionSchemes;
ContainerSupport mMP4;
ContainerSupport mWebM;
bool mIsHDCP22Compatible = false;
};
KeySystemConfig::SessionType ConvertToKeySystemConfigSessionType(

19
dom/media/eme/MediaKeys.cpp
View file

@ -800,7 +800,6 @@ void MediaKeys::GetSessionsInfo(nsString& sessionsInfo) {
}
}
// https://w3c.github.io/encrypted-media/#dom-mediakeys-getstatusforpolicy
already_AddRefed<Promise> MediaKeys::GetStatusForPolicy(
const MediaKeysPolicy& aPolicy, ErrorResult& aRv) {
RefPtr<DetailedPromise> promise(
@ -809,10 +808,15 @@ already_AddRefed<Promise> MediaKeys::GetStatusForPolicy(
return nullptr;
}
// 1. If policy has no present members, return a promise rejected with a newly
// created TypeError.
if (!aPolicy.mMinHdcpVersion.WasPassed()) {
promise->MaybeRejectWithTypeError("No minHdcpVersion in MediaKeysPolicy");
// Currently, only widevine CDM supports for this API.
if (!IsWidevineKeySystem(mKeySystem)) {
EME_LOG(
"MediaKeys[%p]::GetStatusForPolicy() HDCP policy check on unsupported "
"keysystem ",
this);
NS_WARNING("Tried to query without a CDM");
promise->MaybeRejectWithNotSupportedError(
"HDCP policy check on unsupported keysystem");
return promise.forget();
}
@ -824,9 +828,8 @@ already_AddRefed<Promise> MediaKeys::GetStatusForPolicy(
}
EME_LOG("GetStatusForPolicy minHdcpVersion = %s.",
HDCPVersionValues::GetString(aPolicy.mMinHdcpVersion.Value()).data());
mProxy->GetStatusForPolicy(StorePromise(promise),
aPolicy.mMinHdcpVersion.Value());
NS_ConvertUTF16toUTF8(aPolicy.mMinHdcpVersion).get());
mProxy->GetStatusForPolicy(StorePromise(promise), aPolicy.mMinHdcpVersion);
return promise.forget();
}

4
dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp
View file

@ -332,8 +332,8 @@ void MediaDrmCDMProxy::OnKeyStatusesChange(const nsAString& aSessionId) {
}
}
void MediaDrmCDMProxy::GetStatusForPolicy(
PromiseId aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
void MediaDrmCDMProxy::GetStatusForPolicy(PromiseId aPromiseId,
const nsAString& aMinHdcpVersion) {
// TODO: Implement GetStatusForPolicy.
constexpr auto err =
"Currently Fennec does not support GetStatusForPolicy"_ns;

2
dom/media/eme/mediadrm/MediaDrmCDMProxy.h
View file

@ -99,7 +99,7 @@ class MediaDrmCDMProxy final : public CDMProxy {
void OnKeyStatusesChange(const nsAString& aSessionId) override;
void GetStatusForPolicy(PromiseId aPromiseId,
const dom::HDCPVersion& aMinHdcpVersion) override;
const nsAString& aMinHdcpVersion) override;
#ifdef DEBUG
bool IsOnOwnerThread() override;

6
dom/media/eme/mediafoundation/WMFCDMImpl.h
View file

@ -92,12 +92,6 @@ class WMFCDMImpl final {
return mCDM->SetServerCertificate(aPromiseId, aCert);
}
RefPtr<GenericPromise> GetStatusForPolicy(
uint32_t aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
MOZ_DIAGNOSTIC_ASSERT(mCDM);
return mCDM->GetStatusForPolicy(aPromiseId, aMinHdcpVersion);
}
uint64_t Id() {
MOZ_DIAGNOSTIC_ASSERT(mCDM,
"Should be called only after Init() is resolved");

46
dom/media/eme/mediafoundation/WMFCDMProxy.cpp
View file

@ -6,7 +6,6 @@
#include "WMFCDMProxy.h"
#include "mozilla/dom/MediaKeysBinding.h"
#include "mozilla/dom/MediaKeySession.h"
#include "mozilla/dom/MediaKeySystemAccessBinding.h"
#include "mozilla/EMEUtils.h"
@ -152,28 +151,6 @@ void WMFCDMProxy::ResolvePromise(PromiseId aId) {
NS_NewRunnableFunction("WMFCDMProxy::ResolvePromise", resolve));
}
void WMFCDMProxy::ResolvePromiseWithKeyStatus(
const PromiseId& aId, const dom::MediaKeyStatus& aStatus) {
auto resolve = [self = RefPtr{this}, this, aId, aStatus]() {
RETURN_IF_SHUTDOWN();
EME_LOG("WMFCDMProxy::ResolvePromiseWithKeyStatus(this=%p, pid=%" PRIu32
", status=%s)",
this, aId, ToMediaKeyStatusStr(aStatus));
if (!mKeys.IsNull()) {
mKeys->ResolvePromiseWithKeyStatus(aId, aStatus);
} else {
NS_WARNING("WMFCDMProxy unable to resolve promise!");
}
};
if (NS_IsMainThread()) {
resolve();
return;
}
mMainThread->Dispatch(NS_NewRunnableFunction(
"WMFCDMProxy::ResolvePromiseWithKeyStatus", resolve));
}
void WMFCDMProxy::RejectPromise(PromiseId aId, ErrorResult&& aException,
const nsCString& aReason) {
if (!NS_IsMainThread()) {
@ -375,29 +352,6 @@ void WMFCDMProxy::SetServerCertificate(PromiseId aPromiseId,
});
}
void WMFCDMProxy::GetStatusForPolicy(PromiseId aPromiseId,
const dom::HDCPVersion& aMinHdcpVersion) {
MOZ_ASSERT(NS_IsMainThread());
RETURN_IF_SHUTDOWN();
EME_LOG("WMFCDMProxy::GetStatusForPolicy(this=%p, pid=%" PRIu32
", minHDCP=%s)",
this, aPromiseId,
dom::HDCPVersionValues::GetString(aMinHdcpVersion).data());
mCDM->GetStatusForPolicy(aPromiseId, aMinHdcpVersion)
->Then(
mMainThread, __func__,
[self = RefPtr{this}, this, aPromiseId]() {
RETURN_IF_SHUTDOWN();
ResolvePromiseWithKeyStatus(aPromiseId,
dom::MediaKeyStatus::Usable);
},
[self = RefPtr{this}, this, aPromiseId]() {
RETURN_IF_SHUTDOWN();
ResolvePromiseWithKeyStatus(aPromiseId,
dom::MediaKeyStatus::Output_restricted);
});
}
bool WMFCDMProxy::IsHardwareDecryptionSupported() const {
return mozilla::IsHardwareDecryptionSupported(mConfig);
}

6
dom/media/eme/mediafoundation/WMFCDMProxy.h
View file

@ -100,7 +100,7 @@ class WMFCDMProxy : public CDMProxy {
void OnKeyStatusesChange(const nsAString& aSessionId) override;
void GetStatusForPolicy(PromiseId aPromiseId,
const dom::HDCPVersion& aMinHdcpVersion) override;
const nsAString& aMinHdcpVersion) override {}
#ifdef DEBUG
bool IsOnOwnerThread() override {
@ -126,10 +126,6 @@ class WMFCDMProxy : public CDMProxy {
// Reject promise with an InvalidStateError and the given message.
void RejectPromiseWithStateError(PromiseId aId, const nsCString& aReason);
// For HDCP GetStatusForPolicy usage.
void ResolvePromiseWithKeyStatus(const PromiseId& aId,
const dom::MediaKeyStatus& aStatus);
CopyableTArray<MFCDMMediaCapability> GenerateMFCDMMediaCapabilities(
const dom::Sequence<dom::MediaKeySystemMediaCapability>& aCapabilities,
const Maybe<nsString>& forcedRobustness = Nothing());

79
dom/media/gmp/ChromiumCDMParent.cpp
View file

@ -276,44 +276,67 @@ void ChromiumCDMParent::CompleteQueryOutputProtectionStatus(
aProtectionMask);
}
static cdm::HdcpVersion ToCDMHdcpVersion(
const dom::HDCPVersion& aMinHdcpVersion) {
switch (aMinHdcpVersion) {
case dom::HDCPVersion::_1_0:
return cdm::HdcpVersion::kHdcpVersion1_0;
case dom::HDCPVersion::_1_1:
return cdm::HdcpVersion::kHdcpVersion1_1;
case dom::HDCPVersion::_1_2:
return cdm::HdcpVersion::kHdcpVersion1_2;
case dom::HDCPVersion::_1_3:
return cdm::HdcpVersion::kHdcpVersion1_3;
case dom::HDCPVersion::_1_4:
return cdm::HdcpVersion::kHdcpVersion1_4;
case dom::HDCPVersion::_2_0:
return cdm::HdcpVersion::kHdcpVersion2_0;
case dom::HDCPVersion::_2_1:
return cdm::HdcpVersion::kHdcpVersion2_1;
case dom::HDCPVersion::_2_2:
return cdm::HdcpVersion::kHdcpVersion2_2;
case dom::HDCPVersion::_2_3:
return cdm::HdcpVersion::kHdcpVersion2_3;
// When adding another version remember to update GMPMessageUtils so that we
// can serialize it correctly and have correct bounds on the enum!
default:
MOZ_ASSERT_UNREACHABLE("Unexpected HDCP version!");
// See
// https://cs.chromium.org/chromium/src/media/blink/webcontentdecryptionmodule_impl.cc?l=33-66&rcl=d49aa59ac8c2925d5bec229f3f1906537b6b4547
static Result<cdm::HdcpVersion, nsresult> ToCDMHdcpVersion(
const nsCString& aMinHdcpVersion) {
if (aMinHdcpVersion.IsEmpty()) {
return cdm::HdcpVersion::kHdcpVersionNone;
}
if (aMinHdcpVersion.EqualsIgnoreCase("1.0")) {
return cdm::HdcpVersion::kHdcpVersion1_0;
}
if (aMinHdcpVersion.EqualsIgnoreCase("1.1")) {
return cdm::HdcpVersion::kHdcpVersion1_1;
}
if (aMinHdcpVersion.EqualsIgnoreCase("1.2")) {
return cdm::HdcpVersion::kHdcpVersion1_2;
}
if (aMinHdcpVersion.EqualsIgnoreCase("1.3")) {
return cdm::HdcpVersion::kHdcpVersion1_3;
}
if (aMinHdcpVersion.EqualsIgnoreCase("1.4")) {
return cdm::HdcpVersion::kHdcpVersion1_4;
}
if (aMinHdcpVersion.EqualsIgnoreCase("2.0")) {
return cdm::HdcpVersion::kHdcpVersion2_0;
}
if (aMinHdcpVersion.EqualsIgnoreCase("2.1")) {
return cdm::HdcpVersion::kHdcpVersion2_1;
}
if (aMinHdcpVersion.EqualsIgnoreCase("2.2")) {
return cdm::HdcpVersion::kHdcpVersion2_2;
}
// When adding another version remember to update GMPMessageUtils so that we
// can serialize it correctly and have correct bounds on the enum!
// Invalid hdcp version string.
return Err(NS_ERROR_INVALID_ARG);
}
void ChromiumCDMParent::GetStatusForPolicy(
uint32_t aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
void ChromiumCDMParent::GetStatusForPolicy(uint32_t aPromiseId,
const nsCString& aMinHdcpVersion) {
MOZ_ASSERT(mGMPThread->IsOnCurrentThread());
GMP_LOG_DEBUG("ChromiumCDMParent::GetStatusForPolicy(this=%p)", this);
if (mIsShutdown) {
RejectPromiseShutdown(aPromiseId);
return;
}
if (!SendGetStatusForPolicy(aPromiseId, ToCDMHdcpVersion(aMinHdcpVersion))) {
auto hdcpVersionResult = ToCDMHdcpVersion(aMinHdcpVersion);
if (hdcpVersionResult.isErr()) {
ErrorResult rv;
// XXXbz there's no spec for this yet, and
// <https://github.com/WICG/hdcp-detection/blob/master/explainer.md>
// does not define what exceptions get thrown. Let's assume
// TypeError for invalid args, as usual.
constexpr auto err =
"getStatusForPolicy failed due to bad hdcp version argument"_ns;
rv.ThrowTypeError(err);
RejectPromise(aPromiseId, std::move(rv), err);
return;
}
if (!SendGetStatusForPolicy(aPromiseId, hdcpVersionResult.unwrap())) {
RejectPromiseWithStateError(
aPromiseId, "Failed to send getStatusForPolicy to CDM process"_ns);
}

2
dom/media/gmp/ChromiumCDMParent.h
View file

@ -80,7 +80,7 @@ class ChromiumCDMParent final : public PChromiumCDMParent,
uint32_t aProtectionMask);
void GetStatusForPolicy(uint32_t aPromiseId,
const dom::HDCPVersion& aMinHdcpVersion);
const nsCString& aMinHdcpVersion);
RefPtr<DecryptPromise> Decrypt(MediaRawData* aSample);

12
dom/media/gmp/ChromiumCDMProxy.cpp
View file

@ -8,7 +8,6 @@
#include "ChromiumCDMCallbackProxy.h"
#include "MediaResult.h"
#include "mozilla/dom/MediaKeySession.h"
#include "mozilla/dom/MediaKeysBinding.h"
#include "GMPUtils.h"
#include "nsPrintfCString.h"
#include "GMPService.h"
@ -600,13 +599,12 @@ RefPtr<DecryptPromise> ChromiumCDMProxy::Decrypt(MediaRawData* aSample) {
[cdm, sample]() { return cdm->Decrypt(sample); });
}
void ChromiumCDMProxy::GetStatusForPolicy(
PromiseId aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
void ChromiumCDMProxy::GetStatusForPolicy(PromiseId aPromiseId,
const nsAString& aMinHdcpVersion) {
MOZ_ASSERT(NS_IsMainThread());
EME_LOG("ChromiumCDMProxy::GetStatusForPolicy(this=%p, pid=%" PRIu32
") minHdcpVersion=%s",
this, aPromiseId,
dom::HDCPVersionValues::GetString(aMinHdcpVersion).data());
this, aPromiseId, NS_ConvertUTF16toUTF8(aMinHdcpVersion).get());
RefPtr<gmp::ChromiumCDMParent> cdm = GetCDMParent();
if (!cdm) {
@ -615,10 +613,10 @@ void ChromiumCDMProxy::GetStatusForPolicy(
return;
}
mGMPThread->Dispatch(NewRunnableMethod<uint32_t, dom::HDCPVersion>(
mGMPThread->Dispatch(NewRunnableMethod<uint32_t, nsCString>(
"gmp::ChromiumCDMParent::GetStatusForPolicy", cdm,
&gmp::ChromiumCDMParent::GetStatusForPolicy, aPromiseId,
aMinHdcpVersion));
NS_ConvertUTF16toUTF8(aMinHdcpVersion)));
}
void ChromiumCDMProxy::Terminated() {

2
dom/media/gmp/ChromiumCDMProxy.h
View file

@ -98,7 +98,7 @@ class ChromiumCDMProxy : public CDMProxy {
void OnKeyStatusesChange(const nsAString& aSessionId) override;
void GetStatusForPolicy(PromiseId aPromiseId,
const dom::HDCPVersion& aMinHdcpVersion) override;
const nsAString& aMinHdcpVersion) override;
#ifdef DEBUG
bool IsOnOwnerThread() override;

2
dom/media/gmp/GMPMessageUtils.h
View file

@ -70,7 +70,7 @@ template <>
struct ParamTraits<cdm::HdcpVersion>
: public ContiguousEnumSerializerInclusive<
cdm::HdcpVersion, cdm::HdcpVersion::kHdcpVersionNone,
cdm::HdcpVersion::kHdcpVersion2_3> {};
cdm::HdcpVersion::kHdcpVersion2_2> {};
template <>
struct ParamTraits<GMPSimulcastStream> {

17
dom/media/ipc/MFCDMChild.cpp
View file

@ -399,23 +399,6 @@ RefPtr<GenericPromise> MFCDMChild::SetServerCertificate(
return mPendingGenericPromises[aPromiseId].Ensure(__func__);
}
RefPtr<GenericPromise> MFCDMChild::GetStatusForPolicy(
uint32_t aPromiseId, const dom::HDCPVersion& aMinHdcpVersion) {
MOZ_ASSERT(mManagerThread);
MOZ_ASSERT(mId > 0, "Should call Init() first and wait for it");
if (mShutdown) {
return GenericPromise::CreateAndReject(NS_ERROR_ABORT, __func__);
}
MOZ_ASSERT(mPendingGenericPromises.find(aPromiseId) ==
mPendingGenericPromises.end());
mPendingGenericPromises.emplace(aPromiseId,
MozPromiseHolder<GenericPromise>{});
INVOKE_ASYNC(GetStatusForPolicy, aPromiseId, aMinHdcpVersion);
return mPendingGenericPromises[aPromiseId].Ensure(__func__);
}
mozilla::ipc::IPCResult MFCDMChild::RecvOnSessionKeyMessage(
const MFCDMKeyMessage& aMessage) {
LOG("RecvOnSessionKeyMessage, sessionId=%s",

3
dom/media/ipc/MFCDMChild.h
View file

@ -63,9 +63,6 @@ class MFCDMChild final : public PMFCDMChild {
RefPtr<GenericPromise> SetServerCertificate(uint32_t aPromiseId,
nsTArray<uint8_t>& aCert);
RefPtr<GenericPromise> GetStatusForPolicy(
uint32_t aPromiseId, const dom::HDCPVersion& aMinHdcpVersion);
mozilla::ipc::IPCResult RecvOnSessionKeyMessage(
const MFCDMKeyMessage& aMessage);
mozilla::ipc::IPCResult RecvOnSessionKeyStatusesChanged(

39
dom/media/ipc/MFCDMParent.cpp
View file

@ -10,7 +10,6 @@
#include <propkeydef.h> // For DEFINE_PROPERTYKEY() definition
#include <propvarutil.h> // For InitPropVariantFrom*()
#include "mozilla/dom/MediaKeysBinding.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/KeySystemNames.h"
#include "mozilla/ipc/UtilityAudioDecoderChild.h"
@ -154,18 +153,6 @@ static inline LPCWSTR InitDataTypeToString(const nsAString& aInitDataType) {
}
}
// The HDCP value follows the feature value in
// https://docs.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilities.istypesupported?view=winrt-19041
// - 1 (on without HDCP 2.2 Type 1 restriction)
// - 2 (on with HDCP 2.2 Type 1 restriction)
static nsString GetHdcpPolicy(const dom::HDCPVersion& aMinHdcpVersion) {
if (aMinHdcpVersion == dom::HDCPVersion::_2_2 ||
aMinHdcpVersion == dom::HDCPVersion::_2_3) {
return nsString(u"hdcp=2");
}
return nsString(u"hdcp=1");
}
static void BuildCapabilitiesArray(
const nsTArray<MFCDMMediaCapability>& aCapabilities,
AutoPropVar& capabilitiesPropOut) {
@ -647,19 +634,6 @@ static bool FactorySupports(ComPtr<IMFContentDecryptionModuleFactory>& aFactory,
return support;
}
static nsresult IsHDCPVersionSupported(
ComPtr<IMFContentDecryptionModuleFactory>& aFactory,
const nsString& aKeySystem, const dom::HDCPVersion& aMinHdcpVersion) {
nsresult rv = NS_OK;
// Codec doesn't matter when querying the HDCP policy, so use H264.
if (!FactorySupports(aFactory, aKeySystem, nsCString("avc1"),
KeySystemConfig::EMECodecString(""),
GetHdcpPolicy(aMinHdcpVersion))) {
rv = NS_ERROR_DOM_MEDIA_CDM_HDCP_NOT_SUPPORT;
}
return rv;
}
static bool IsKeySystemHWSecure(
const nsAString& aKeySystem,
const nsTArray<MFCDMMediaCapability>& aCapabilities) {
@ -926,11 +900,6 @@ void MFCDMParent::GetCapabilities(const nsString& aKeySystem,
}
}
if (IsHDCPVersionSupported(factory, aKeySystem, dom::HDCPVersion::_2_2) ==
NS_OK) {
aCapabilitiesOut.isHDCP22Compatible() = true;
}
// TODO: don't hardcode
aCapabilitiesOut.initDataTypes().AppendElement(u"keyids");
aCapabilitiesOut.initDataTypes().AppendElement(u"cenc");
@ -1121,14 +1090,6 @@ mozilla::ipc::IPCResult MFCDMParent::RecvSetServerCertificate(
return IPC_OK();
}
mozilla::ipc::IPCResult MFCDMParent::RecvGetStatusForPolicy(
const dom::HDCPVersion& aMinHdcpVersion,
GetStatusForPolicyResolver&& aResolver) {
MOZ_ASSERT(mCDM, "RecvInit() must be called and waited on before this call");
aResolver(IsHDCPVersionSupported(mFactory, mKeySystem, aMinHdcpVersion));
return IPC_OK();
}
void MFCDMParent::ConnectSessionEvents(MFCDMSession* aSession) {
// TODO : clear session's event source when the session gets removed.
mKeyMessageEvents.Forward(aSession->KeyMessageEvent());

4
dom/media/ipc/MFCDMParent.h
View file

@ -79,10 +79,6 @@ class MFCDMParent final : public PMFCDMParent {
const CopyableTArray<uint8_t>& aCertificate,
UpdateSessionResolver&& aResolver);
mozilla::ipc::IPCResult RecvGetStatusForPolicy(
const dom::HDCPVersion& aMinHdcpVersion,
GetStatusForPolicyResolver&& aResolver);
nsISerialEventTarget* ManagerThread() { return mManagerThread; }
void AssertOnManagerThread() const {
MOZ_ASSERT(mManagerThread->IsOnCurrentThread());

6
dom/media/ipc/MFCDMSerializers.h
View file

@ -47,12 +47,6 @@ struct ParamTraits<mozilla::dom::MediaKeyStatus>
mozilla::dom::MediaKeyStatus::EndGuard_> {
};
template <>
struct ParamTraits<mozilla::dom::HDCPVersion>
: public ContiguousEnumSerializer<mozilla::dom::HDCPVersion,
mozilla::dom::HDCPVersion::_1_0,
mozilla::dom::HDCPVersion::EndGuard_> {};
} // namespace IPC
#endif // DOM_MEDIA_IPC_MFCDMSERIALIZERS_H_

3
dom/media/ipc/PMFCDM.ipdl
View file

@ -11,7 +11,6 @@ using mozilla::KeySystemConfig::SessionType from "mozilla/KeySystemConfig.h";
using mozilla::CryptoScheme from "MediaData.h";
using mozilla::dom::MediaKeyMessageType from "mozilla/dom/MediaKeyMessageEventBinding.h";
using mozilla::dom::MediaKeyStatus from "mozilla/dom/MediaKeyStatusMapBinding.h";
using mozilla::dom::HDCPVersion from "mozilla/dom/MediaKeysBinding.h";
namespace mozilla {
@ -57,7 +56,6 @@ struct MFCDMCapabilitiesIPDL {
CryptoScheme[] encryptionSchemes;
Requirement distinctiveID;
Requirement persistentState;
bool isHDCP22Compatible;
};
union MFCDMCapabilitiesResult {
@ -109,7 +107,6 @@ parent:
async CloseSession(nsString sessionId) returns (nsresult result);
async RemoveSession(nsString sessionId) returns (nsresult result);
async SetServerCertificate(uint8_t[] certificate) returns (nsresult result);
async GetStatusForPolicy(HDCPVersion minHdcpVersion) returns (nsresult result);
async __delete__();
child:

2
dom/media/test/mochitest_media_engine.toml
View file

@ -6,5 +6,3 @@ skip-if = ["!wmfme"]
["test_eme_mfcdm_generate_request.html"]
["test_eme_wideinve_l1_installation.html"]
["test_eme_mfcdm_getstatusforpolicy.html"]

90
dom/media/test/test_eme_getstatusforpolicy.html
View file

@ -1,7 +1,7 @@
<!DOCTYPE HTML>
<html>
<head>
<title>Test getStatusForPolicy on ClearKey CDM</title>
<title>Test Encrypted Media Extensions</title>
<script src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
<script type="text/javascript" src="manifest.js"></script>
@ -12,70 +12,8 @@
<video id="v" controls></video>
<script class="testbody" type="text/javascript">
add_task(async function setupTestingPrefs() {
await SpecialPowers.pushPrefEnv({
set: [
["media.eme.hdcp-policy-check.enabled", true],
],
});
});
SimpleTest.waitForExplicitFinish();
// We expect that ClearKey has HDCP 2.0 compliant.
const expectedResults = [
{
minHdcpVersion : "1.0",
expectedResult : "usable"
},
{
minHdcpVersion : "1.1",
expectedResult : "usable"
},
{
minHdcpVersion : "1.2",
expectedResult : "usable"
},
{
minHdcpVersion : "1.3",
expectedResult : "usable"
},
{
minHdcpVersion : "1.4",
expectedResult : "usable"
},
{
minHdcpVersion : "2.0",
expectedResult : "usable"
},
{
minHdcpVersion : "2.1",
expectedResult : "output-restricted"
},
{
minHdcpVersion : "2.2",
expectedResult : "output-restricted"
},
{
minHdcpVersion : "2.3",
expectedResult : "output-restricted"
},
];
add_task(async function testGetStatusForPolicy() {
for (let result of expectedResults) {
let mediaKey = await createMediaKeysAndSet();
let video = document.getElementById("v");
is(video.mediaKeys, mediaKey,
"Should have set MediaKeys on media element");
let keyStatus = await
video.mediaKeys.getStatusForPolicy({minHdcpVersion : result.minHdcpVersion})
.catch(e => ok(false, "getStatusForPolicy failed!"));
info(`getStatusForPolicy for HDCP ${result.minHdcpVersion} : ${keyStatus}`);
is(keyStatus, result.expectedResult,
`Expected ${result.expectedResult}, got ${keyStatus}`);
}
});
// Helper function
function createMediaKeysAndSet() {
return navigator.requestMediaKeySystemAccess(CLEARKEY_KEYSYSTEM, gCencMediaKeySystemConfig)
.then(function (access) {
@ -87,6 +25,30 @@ function createMediaKeysAndSet() {
});
}
function test() {
createMediaKeysAndSet()
.then((m) => {
let video = document.getElementById("v");
is(video.mediaKeys, m, "Should have set MediaKeys on media element");
// getStatusForPolicy() is not suppored by ClearKey key system.
// The promise will always be rejected with NotSupportedError.
return video.mediaKeys.getStatusForPolicy({minHdcpVersion: "hdcp-2.0"});
})
.then((mediaKeyStatus) => {
ok(false, "Promise of getStatusForPolicy should not be resolved with clearkey key system");
})
// Promise rejected with NotSupportedError as expected.
.catch(reason => is("NotSupportedError", reason.name,
"Promise should be rejected with NotSupportedError."))
.then(() => SimpleTest.finish());
}
SpecialPowers.pushPrefEnv({"set":
[
["media.eme.hdcp-policy-check.enabled", true],
]
}, test);
</script>
</pre>
</body>

115
dom/media/test/test_eme_mfcdm_getstatusforpolicy.html
View file

@ -1,115 +0,0 @@
<!DOCTYPE HTML>
<html>
<head>
<title>Test getStatusForPolicy on MFCDM</title>
<script src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
<script type="text/javascript" src="manifest.js"></script>
<script type="text/javascript" src="eme.js"></script>
</head>
<body>
<pre id="test">
<video id="v" controls></video>
<script class="testbody" type="text/javascript">
add_task(async function setupTestingPrefs() {
await SpecialPowers.pushPrefEnv({
set: [
["media.eme.hdcp-policy-check.enabled", true],
["media.wmf.media-engine.enabled", 2],
["media.eme.playready.enabled", true],
["media.eme.widevine.experiment.enabled", true],
// This is used to trigger Widevine CDM installation check
["media.gmp-widevinecdm-l1.enabled", true],
["media.eme.wmf.clearkey.enabled", true],
// Use the mock clearkey CDM to create cdm for all other key systems.
["media.eme.wmf.use-mock-cdm-for-external-cdms", true],
// Our mock CDM doesn't implement 'IsTypeSupportedEx()', only 'IsTypeSupported()'
["media.eme.playready.istypesupportedex", false],
],
});
});
// We expect that all key system have HDCP 2.1 compliant, which is pre-defined
// in `WMFClearKeyCDMFactory::IsTypeSupported`.
const expectedResults = [
{
minHdcpVersion : "1.0",
expectedResult : "usable"
},
{
minHdcpVersion : "1.1",
expectedResult : "usable"
},
{
minHdcpVersion : "1.2",
expectedResult : "usable"
},
{
minHdcpVersion : "1.3",
expectedResult : "usable"
},
{
minHdcpVersion : "1.4",
expectedResult : "usable"
},
{
minHdcpVersion : "2.0",
expectedResult : "usable"
},
{
minHdcpVersion : "2.1",
expectedResult : "usable"
},
{
minHdcpVersion : "2.2",
expectedResult : "output-restricted"
},
{
minHdcpVersion : "2.3",
expectedResult : "output-restricted"
},
];
const kKeySystems = [
"com.microsoft.playready.recommendation",
"com.microsoft.playready.recommendation.3000",
"com.microsoft.playready.recommendation.3000.clearlead",
"com.widevine.alpha.experiment",
"com.widevine.alpha.experiment2",
"org.w3.clearkey",
];
add_task(async function testGetStatusForPolicy() {
for (let keySystem of kKeySystems) {
for (let result of expectedResults) {
let mediaKey = await createMediaKeysAndSet(keySystem);
let video = document.getElementById("v");
is(video.mediaKeys, mediaKey,
"Should have set MediaKeys on media element");
let keyStatus = await
video.mediaKeys.getStatusForPolicy({minHdcpVersion : result.minHdcpVersion})
.catch(e => ok(false, "getStatusForPolicy failed!"));
info(`getStatusForPolicy for HDCP ${result.minHdcpVersion} : ${keyStatus}`);
is(keyStatus, result.expectedResult,
`Expected ${result.expectedResult}, got ${keyStatus}`);
}
}
});
// Helper function
function createMediaKeysAndSet(keySystem) {
return navigator.requestMediaKeySystemAccess(keySystem, gCencMediaKeySystemConfig)
.then(function (access) {
return access.createMediaKeys();
})
.then(function (mediaKeys) {
document.getElementById("v").setMediaKeys(mediaKeys);
return mediaKeys;
});
}
</script>
</pre>
</body>
</html>

17
dom/webidl/MediaKeys.webidl
View file

@ -18,22 +18,9 @@ enum MediaKeySessionType {
// persistent-usage-record,
};
// https://w3c.github.io/encrypted-media/#idl-def-hdcpversion
enum HDCPVersion {
"1.0",
"1.1",
"1.2",
"1.3",
"1.4",
"2.0",
"2.1",
"2.2",
"2.3",
};
// https://w3c.github.io/encrypted-media/#idl-def-mediakeyspolicy
// https://github.com/WICG/media-capabilities/blob/master/eme-extension-policy-check.md
dictionary MediaKeysPolicy {
HDCPVersion minHdcpVersion;
DOMString minHdcpVersion = "";
};
[Exposed=Window]

3
ipc/glue/UtilityAudioDecoderChild.cpp
View file

@ -215,9 +215,6 @@ void UtilityAudioDecoderChild::GetKeySystemCapabilities(
info->mCapabilities = config.GetDebugInfo();
info->mClearlead =
DoesKeySystemSupportClearLead(info->mKeySystemName);
if (capabilities.isHDCP22Compatible()) {
info->mIsHDCP22Compatible = true;
}
}
promise->MaybeResolve(cdmInfo);
},

11
media/gmp-clearkey/0.1/ClearKeyCDM.cpp
View file

@ -25,13 +25,10 @@ void ClearKeyCDM::Initialize(bool aAllowDistinctiveIdentifier,
void ClearKeyCDM::GetStatusForPolicy(uint32_t aPromiseId,
const Policy& aPolicy) {
// Pretend the device is HDCP 2.0 compliant.
const cdm::HdcpVersion kDeviceHdcpVersion = cdm::kHdcpVersion2_0;
if (aPolicy.min_hdcp_version <= kDeviceHdcpVersion) {
mHost->OnResolveKeyStatusPromise(aPromiseId, KeyStatus::kUsable);
} else {
mHost->OnResolveKeyStatusPromise(aPromiseId, KeyStatus::kOutputRestricted);
}
// MediaKeys::GetStatusForPolicy checks the keysystem and
// reject the promise with NS_ERROR_DOM_NOT_SUPPORTED_ERR without calling CDM.
// This function should never be called and is not supported.
assert(false);
}
void ClearKeyCDM::SetServerCertificate(uint32_t aPromiseId,
const uint8_t* aServerCertificateData,

31
media/wmf-clearkey/WMFClearKeyCDMFactory.cpp
View file

@ -4,8 +4,6 @@
#include "WMFClearKeyCDMFactory.h"
#include <string>
#include <Mferror.h>
#include "WMFClearKeyCDMAccess.h"
@ -17,36 +15,11 @@ using Microsoft::WRL::MakeAndInitialize;
ActivatableClass(WMFClearKeyCDMFactory);
bool isRequiringHDCP22OrAbove(LPCWSTR aType) {
if (aType == nullptr || *aType == L'\0') {
return false;
}
// The HDCP value follows the feature value in
// https://docs.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilities.istypesupported?view=winrt-19041
// - 1 (on without HDCP 2.2 Type 1 restriction)
// - 2 (on with HDCP 2.2 Type 1 restriction)
std::wstring wstr(aType);
std::string hdcpStr(wstr.begin(), wstr.end());
return wstr.find(L"hdcp=2") != std::string::npos;
}
STDMETHODIMP_(BOOL)
WMFClearKeyCDMFactory::IsTypeSupported(_In_ LPCWSTR aKeySystem,
_In_opt_ LPCWSTR aContentType) {
// For testing, return support for most of cases. Only returns false for some
// special cases.
bool needHDCP22OrAbove = isRequiringHDCP22OrAbove(aContentType);
ENTRY_LOG_ARGS("Need-HDCP2.2+=%d", needHDCP22OrAbove);
// As the API design of the Media Foundation, we can only know whether the
// requester is asking for HDCP 2.2+ or not, we can't know the exact HDCP
// version which is used in getStatusPolicy web api. Therefore, we pretend
// ourselves only having HDCP 2.1 compliant.
if (needHDCP22OrAbove) {
return false;
}
// For testing, always return support. Maybe we can block support for certain
// type if needed?
return true;
}

2
testing/web-platform/meta/encrypted-media/__dir__.ini
View file

@ -1,3 +1,3 @@
prefs: [dom.security.featurePolicy.experimental.enabled:true, dom.security.featurePolicy.header.enabled:true, dom.security.featurePolicy.webidl.enabled:true, media.eme.hdcp-policy-check.enabled:true]
prefs: [dom.security.featurePolicy.experimental.enabled:true, dom.security.featurePolicy.header.enabled:true, dom.security.featurePolicy.webidl.enabled:true]
lsan-disabled: true
leak-threshold: [default:51200]

3
testing/web-platform/meta/encrypted-media/clearkey-check-status-for-hdcp.https.html.ini
View file

@ -3,3 +3,6 @@
if (processor == "x86") and debug: [OK, TIMEOUT]
[org.w3.clearkey support for empty HDCP version.]
expected: FAIL
[org.w3.clearkey support for HDCP 1.0.]
expected: FAIL

1
toolkit/content/aboutSupport.js
View file

@ -1181,7 +1181,6 @@ var snapshotFormatters = {
$.new("td", getAudioRobustness(rvArray)),
$.new("td", getCapabilities(rvArray)),
$.new("td", cdmInfo.clearlead ? "Yes" : "No"),
$.new("td", cdmInfo.isHDCP22Compatible ? "Yes" : "No"),
]);
}

3
toolkit/content/aboutSupport.xhtml
View file

@ -567,7 +567,7 @@
<tbody id="media-content-decryption-modules-tbody">
<tr>
<th colspan="6" class="title-column" data-l10n-id="media-content-decryption-modules-title"/>
<th colspan="5" class="title-column" data-l10n-id="media-content-decryption-modules-title"/>
</tr>
<tr>
<th data-l10n-id="media-key-system-name"/>
@ -575,7 +575,6 @@
<th data-l10n-id="media-audio-robustness"/>
<th data-l10n-id="media-cdm-capabilities"/>
<th data-l10n-id="media-cdm-clear-lead"/>
<th data-l10n-id="media-hdcp-22-compatible"/>
</tr>
</tbody>

3
toolkit/locales/en-US/toolkit/about/aboutSupport.ftl
View file

@ -205,9 +205,6 @@ media-cdm-capabilities = Capabilities
# are not encrypted. It allows playback to start without having to wait for
# license response, improving video start time and user experience.
media-cdm-clear-lead = Clear Lead
# We choose 2.2 as this is the version which the video provider usually want to have in order to stream 4K video securely
# HDCP version https://w3c.github.io/encrypted-media/#idl-def-hdcpversion
media-hdcp-22-compatible = HDCP 2.2 Compatible
##

1
xpcom/base/ErrorList.py
View file

@ -1177,7 +1177,6 @@ with modules["DOM_MEDIA"]:
# Internal CDM error
errors["NS_ERROR_DOM_MEDIA_CDM_NO_SESSION_ERR"] = FAILURE(50)
errors["NS_ERROR_DOM_MEDIA_CDM_SESSION_OPERATION_ERR"] = FAILURE(51)
errors["NS_ERROR_DOM_MEDIA_CDM_HDCP_NOT_SUPPORT"] = FAILURE(52)
# Internal platform-related errors
errors["NS_ERROR_DOM_MEDIA_CUBEB_INITIALIZATION_ERR"] = FAILURE(101)