Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- This WPT test may be referenced by the following Test IDs:
- /media-capabilities/decodingInfoEncryptedMedia.https.html - WPT Dashboard Interop Dashboard
<!DOCTYPE html>
<title>MediaCapabilities.decodingInfo() for encrypted media</title>
<meta name="timeout" content="long">
<script src=/resources/testharness.js></script>
<script src="/resources/testharnessreport.js"></script>
<script>
// Minimal VideoConfiguration that will be allowed per spec. All optional
// properties are missing.
var minimalVideoConfiguration = {
contentType: 'video/webm; codecs="vp09.00.10.08"',
width: 800,
height: 600,
bitrate: 3000,
framerate: 24,
};
// Minimal AudioConfiguration that will be allowed per spec. All optional
// properties are missing.
var minimalAudioConfiguration = {
contentType: 'audio/webm; codecs="opus"',
};
// Minimal MediaCapabilitiesKeySystemConfiguration that will be allowed per
// spec. All optional properties are missing.
var minimalKeySystemConfiguration = {
keySystem: 'org.w3.clearkey',
};
// Config with bogus name not provided by any UA.
var bogusKeySystemConfiguration = {
keySystem: 'bogus',
};
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
keySystemConfiguration: minimalKeySystemConfiguration,
});
}, "Test that decodingInfo() accepts a stub key system configuration (w/video).");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
keySystemConfiguration: minimalKeySystemConfiguration,
});
}, "Test that decodingInfo() accepts a stub key system configuration (w/audio).");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
video: {
robustness: '',
},
},
});
}, "Test that decodingInfo() accepts a key system configuration with video info.");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
audio : {
robustness: '',
},
},
});
}, "Test that decodingInfo() accepts a key system configuration with audio info.");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
video: {
robustness: '',
},
},
}));
}, "Test that decodingInfo() rejects if robustness and configuration do not match (1).");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
audio : {
robustness: '',
},
},
}));
}, "Test that decodingInfo() rejects if robustness and configuration do not match (2).");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
audio : {
robustness: '',
},
video: {
robustness: '',
},
},
}));
}, "Test that decodingInfo() rejects if robustness and configuration do not match (3).");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
audio : {
robustness: '',
},
video: {
robustness: '',
},
persistentState: "foobar",
},
}));
}, "Test that decodingInfo() rejects if persistentState isn't valid.");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
audio : {
robustness: '',
},
video: {
robustness: '',
},
distinctiveIdentifier: "foobar",
},
}));
}, "Test that decodingInfo() rejects if distinctiveIdentifier isn't valid.");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'org.w3.clearkey',
audio : {
robustness: '',
},
video: {
robustness: '',
},
sessionTypes: "foobar",
},
}));
}, "Test that decodingInfo() rejects if sessionTypes isn't a sequence.");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
audio: minimalAudioConfiguration,
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: {},
initDataType: {},
audio : {
robustness: '',
},
video: {
robustness: '',
},
},
});
}, "Test that decodingInfo() does not reject when properties are set to unexpected values.");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
audio: minimalAudioConfiguration,
keySystemConfiguration: minimalKeySystemConfiguration,
}).then(ability => {
assert_equals(typeof ability.supported, "boolean");
assert_equals(typeof ability.smooth, "boolean");
assert_equals(typeof ability.powerEfficient, "boolean");
assert_equals(typeof ability.keySystemAccess, "object");
});
}, "Test that decodingInfo returns a valid MediaCapabilitiesDecodingInfo objects with encrypted media");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
keySystemConfiguration: {
keySystem: 'foobar',
video: {
robustness: '',
},
}
}).then(ability => {
assert_false(ability.supported);
assert_false(ability.smooth);
assert_false(ability.powerEfficient);
assert_equals(ability.keySystemAccess, null);
});
}, "Test that random key systems are reported as non supported.");
// TODO(mlamouri): this test could be split in two tests for which codec support
// across browsers is widely compatible: one when all browsers wouldn't support
// and one where all browsers do support. The current approach is to check that
// the answer is consistent to the spec.
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
audio: minimalAudioConfiguration,
keySystemConfiguration: minimalKeySystemConfiguration,
}).then(ability => {
if (ability.supported)
assert_not_equals(ability.keySystemAccess, null);
else
assert_equals(ability.keySystemAccess, null);
});
}, "Test that keySystemAccess is only null when not supported if keySystemConfiguration was used.");
promise_test(t => {
return navigator.mediaCapabilities.decodingInfo({
type: 'file',
video: minimalVideoConfiguration,
audio: minimalAudioConfiguration,
// Supply bogus config to reliably result in a null keySystemAccess.
keySystemConfiguration: bogusKeySystemConfiguration,
}).then(ability => {
assert_equals(ability.keySystemAccess, null);
assert_false(ability.supported);
});
}, "Test that supported=false when keySystemConfiguration is unsupported.");
promise_test(t => {
return promise_rejects_js(t, TypeError, navigator.mediaCapabilities.decodingInfo({
type: 'webrtc',
video: minimalVideoConfiguration,
keySystemConfiguration: minimalKeySystemConfiguration,
}));
}, "Test that decodingInfo() with type webrtc rejects key system configuration.");
</script>