mirror of
https://github.com/servo/servo.git
synced 2025-07-12 18:03:49 +01:00
1012 lines
46 KiB
HTML
1012 lines
46 KiB
HTML
<!DOCTYPE html>
|
|
<!-- Copyright © 2016 Chromium authors and World Wide Web Consortium, (Massachusetts Institute of Technology, ERCIM, Keio University, Beihang). -->
|
|
<html>
|
|
<head>
|
|
<title>Test EME syntax</title>
|
|
<script src="encrypted-media-utils.js"></script>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
</head>
|
|
<body>
|
|
<div id="log"></div>
|
|
<script>
|
|
// Since promises catch any exception and convert it into a
|
|
// rejected Promise, there is no current way to have the W3C
|
|
// test framework report a failed test. For now, simply force
|
|
// a timeout to indicate failure.
|
|
// FIXME: Once W3C test framework handles Promises, fix this.
|
|
|
|
// This function checks that calling |testCase.func| returns a
|
|
// rejected Promise with the error.name equal to
|
|
// |testCase.exception|.
|
|
function test_exception(testCase /*...*/)
|
|
{
|
|
var func = testCase.func;
|
|
var exception = testCase.exception;
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
|
|
// Currently blink throws for TypeErrors rather than returning
|
|
// a rejected promise (http://crbug.com/359386).
|
|
// FIXME: Remove try/catch once they become failed promises.
|
|
try {
|
|
return func.apply(null, args).then(
|
|
function(result)
|
|
{
|
|
assert_unreached(format_value(func));
|
|
},
|
|
function(error)
|
|
{
|
|
assert_equals(error.name, exception, format_value(func));
|
|
assert_not_equals(error.message, "", format_value(func));
|
|
}
|
|
);
|
|
} catch (e) {
|
|
// Only allow 'TypeError' exceptions to be thrown.
|
|
// Everything else should be a failed promise.
|
|
assert_equals('TypeError', exception, format_value(func));
|
|
assert_equals(e.name, exception, format_value(func));
|
|
}
|
|
}
|
|
|
|
var kRequestMediaKeySystemAccessExceptionsTestCases = [
|
|
// Too few parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess(); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3.clearkey'); }
|
|
},
|
|
// Invalid key systems. Note that JavaScript converts all these
|
|
// values into strings by calling toString(), so they fail due
|
|
// to the key system not being supported, not due to the type.
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess(null, [{}]); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess(undefined, [{}]); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess(1, [{}]); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess(new Uint8Array(0), [{}]); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('', [{}]); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('unsupported', [{}]); }
|
|
},
|
|
// Non-ASCII names.
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3\u263A.clearkey', [{}]); }
|
|
},
|
|
// Empty sequence of MediaKeySystemConfiguration.
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3.clearkey', []); }
|
|
},
|
|
// Invalid sequences of MediaKeySystemConfigurations.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3.clearkey', {}); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3.clearkey', "invalid"); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}, 6]); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function() { return navigator.requestMediaKeySystemAccess('org.w3.clearkey', ["invalid", "upsupported"]); }
|
|
}
|
|
];
|
|
|
|
async_test(function(test)
|
|
{
|
|
var createPromises = kRequestMediaKeySystemAccessExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase);
|
|
});
|
|
|
|
Promise.all(createPromises).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'requestMediaKeySystemAccess() tests failed');
|
|
});
|
|
}, 'Test Navigator.requestMediaKeySystemAccess() exceptions.');
|
|
|
|
async_test(function(test)
|
|
{
|
|
assert_equals(typeof navigator.requestMediaKeySystemAccess, 'function');
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
|
|
assert_not_equals(access, null);
|
|
assert_equals(typeof access, 'object');
|
|
assert_equals(access.keySystem, 'org.w3.clearkey');
|
|
assert_equals(typeof access.getConfiguration, 'function');
|
|
assert_equals(typeof access.createMediaKeys, 'function');
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'requestMediaKeySystemAccess() tests failed');
|
|
});
|
|
}, 'Test Navigator.requestMediaKeySystemAccess().');
|
|
|
|
async_test(function(test)
|
|
{
|
|
var access;
|
|
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(result) {
|
|
access = result;
|
|
assert_equals(access.keySystem, 'org.w3.clearkey');
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
assert_not_equals(mediaKeys, null);
|
|
assert_equals(typeof mediaKeys, 'object');
|
|
assert_equals(typeof mediaKeys.createSession, 'function');
|
|
assert_equals(typeof mediaKeys.setServerCertificate, 'function');
|
|
|
|
// Test creation of a second MediaKeys.
|
|
// The extra parameter is ignored.
|
|
return access.createMediaKeys('extra');
|
|
}).then(function(mediaKeys) {
|
|
assert_not_equals(mediaKeys, null);
|
|
assert_equals(typeof mediaKeys, 'object');
|
|
assert_equals(typeof mediaKeys.createSession, 'function');
|
|
assert_equals(typeof mediaKeys.setServerCertificate, 'function');
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'create() tests failed');
|
|
});
|
|
}, 'Test MediaKeys create().');
|
|
|
|
var kCreateSessionExceptionsTestCases = [
|
|
// Tests in this set use a shortened parameter name due to
|
|
// format_value() only returning the first 60 characters as the
|
|
// result. With a longer name the first 60 characters is not
|
|
// enough to determine which test failed.
|
|
|
|
// Invalid parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession(); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession(''); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession(null); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession(undefined); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession(1); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession(new Uint8Array(0)); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.createSession('TEMPORARY'); }
|
|
}
|
|
];
|
|
|
|
// This function checks that calling createSession() with an
|
|
// unsupported session type doesn't create a MediaKeySession object.
|
|
// Since requestMediaKeySystemAccess() is called without specifying
|
|
// persistent sessions, only temporary sessions will be allowed.
|
|
function test_unsupported_sessionType(mediaKeys)
|
|
{
|
|
var mediaKeySession = 'test';
|
|
|
|
try {
|
|
mediaKeySession = mediaKeys.createSession('persistent-license');
|
|
assert_unreached('Session should not be created.');
|
|
} catch (error) {
|
|
assert_equals(error.name, 'NotSupportedError');
|
|
assert_not_equals(error.message, "");
|
|
|
|
// Since createSession() failed, |mediaKeySession| is not
|
|
// touched.
|
|
assert_equals(mediaKeySession, 'test');
|
|
}
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var sessionPromises = kCreateSessionExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase, mediaKeys);
|
|
});
|
|
sessionPromises = sessionPromises.concat(test_unsupported_sessionType(mediaKeys));
|
|
|
|
assert_not_equals(sessionPromises.length, 0);
|
|
return Promise.all(sessionPromises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'createSession() tests failed');
|
|
});
|
|
}, 'Test MediaKeys createSession() exceptions.');
|
|
|
|
var kGenerateRequestExceptionsTestCases = [
|
|
// Tests in this set use a shortened parameter name due to
|
|
// format_value() only returning the first 60 characters as the
|
|
// result. With a longer name the first 60 characters is not
|
|
// enough to determine which test failed. Even with the
|
|
// shortened name, the error message for the last couple of
|
|
// tests is the same.
|
|
// Too few parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk1) { return mk1.createSession().generateRequest(); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk2) { return mk2.createSession().generateRequest(''); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk3) { return mk3.createSession().generateRequest(null); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk4) { return mk4.createSession().generateRequest(undefined); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk5) { return mk5.createSession().generateRequest(1); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk6) { return mk6.createSession().generateRequest(new Uint8Array(0)); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk7, _, initData) { return mk7.createSession().generateRequest(initData); }
|
|
},
|
|
// Invalid parameters.
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk8, _, initData) { return mk8.createSession().generateRequest('', initData); }
|
|
},
|
|
// Not supported initDataTypes.
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk9, _, initData) { return mk9.createSession().generateRequest(null, initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk10, _, initData) { return mk10.createSession().generateRequest(undefined, initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk11, _, initData) { return mk11.createSession().generateRequest(1, initData); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk12, _, initData) { return mk12.createSession().generateRequest(new Uint8Array(0), initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk13, _, initData) { return mk13.createSession().generateRequest('unsupported', initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk14, _, initData) { return mk14.createSession().generateRequest('video/webm', initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk15, _, initData) { return mk15.createSession().generateRequest('video/mp4', initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk16, _, initData) { return mk16.createSession().generateRequest('video/cenc', initData); }
|
|
},
|
|
{
|
|
exception: 'NotSupportedError',
|
|
func: function(mk17, _, initData) { return mk17.createSession().generateRequest('web\u263A', initData); }
|
|
}
|
|
];
|
|
|
|
var kTypeSpecificGenerateRequestExceptionsTestCases = [
|
|
// Tests in this set use a shortened parameter name due to
|
|
// format_value() only returning the first 60 characters as the
|
|
// result. With a longer name the first 60 characters is not
|
|
// enough to determine which test failed. Even with the
|
|
// shortened name, the error message for the last couple of
|
|
// tests is the same.
|
|
|
|
// Too few parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk1, type) { return mk1.createSession().generateRequest(type); }
|
|
},
|
|
// Invalid parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk2, type) { return mk2.createSession().generateRequest(type, ''); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk3, type) { return mk3.createSession().generateRequest(type, null); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk4, type) { return mk4.createSession().generateRequest(type, undefined); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk5, type) { return mk5.createSession().generateRequest(type, 1); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk6, type) { return mk6.createSession().generateRequest(type, new Uint8Array(0)); }
|
|
}
|
|
];
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var initData = stringToUint8Array('init data');
|
|
var sessionPromises = kGenerateRequestExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase, mediaKeys, '', initData);
|
|
});
|
|
|
|
// Test that WebM sessions generate the expected error, if
|
|
// supported.
|
|
if (isWebmSupported) {
|
|
var WebmSessionPromises = kTypeSpecificGenerateRequestExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase, mediaKeys, 'webm', getInitData('webm'));
|
|
});
|
|
sessionPromises = sessionPromises.concat(WebmSessionPromises);
|
|
}
|
|
|
|
// Repeat for MP4, if supported.
|
|
if (isCencSupported) {
|
|
var mp4SessionPromises = kTypeSpecificGenerateRequestExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase, mediaKeys, 'cenc', getInitData('cenc'));
|
|
});
|
|
sessionPromises = sessionPromises.concat(mp4SessionPromises);
|
|
}
|
|
|
|
assert_not_equals(sessionPromises.length, 0);
|
|
return Promise.all(sessionPromises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'generateRequest() tests failed');
|
|
});
|
|
}, 'Test MediaKeys generateRequest() exceptions.');
|
|
|
|
var kLoadExceptionsTestCases = [
|
|
// Too few parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk1) { return mk1.createSession('temporary').load(); }
|
|
},
|
|
// 'temporary' sessions are never allowed, so always return
|
|
// 'InvalidAccessError'.
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk3) { return mk3.createSession('temporary').load(''); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk4) { return mk4.createSession('temporary').load(1); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk5) { return mk5.createSession('temporary').load('!@#$%^&*()'); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk6) { return mk6.createSession('temporary').load('1234'); }
|
|
}
|
|
];
|
|
|
|
async_test(function(test)
|
|
{
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var initData = stringToUint8Array('init data');
|
|
var sessionPromises = kLoadExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase, mediaKeys);
|
|
});
|
|
|
|
assert_not_equals(sessionPromises.length, 0);
|
|
return Promise.all(sessionPromises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'load() tests failed');
|
|
});
|
|
}, 'Test MediaKeys load() exceptions.');
|
|
|
|
// All calls to |func| in this group are supposed to succeed.
|
|
// However, the spec notes that some things are optional for
|
|
// Clear Key. In particular, support for persistent sessions
|
|
// is optional. Since some implementations won't support some
|
|
// features, a NotSupportedError is treated as a success
|
|
// if |isNotSupportedAllowed| is true.
|
|
var kCreateSessionTestCases = [
|
|
// Use the default sessionType.
|
|
{
|
|
func: function(mk) { return mk.createSession(); },
|
|
isNotSupportedAllowed: false
|
|
},
|
|
// Try variations of sessionType.
|
|
{
|
|
func: function(mk) { return mk.createSession('temporary'); },
|
|
isNotSupportedAllowed: false
|
|
},
|
|
{
|
|
func: function(mk) { return mk.createSession(undefined); },
|
|
isNotSupportedAllowed: false
|
|
},
|
|
{
|
|
// Since this is optional, some Clear Key implementations
|
|
// will succeed, others will return a "NotSupportedError".
|
|
// Both are allowed results.
|
|
func: function(mk) { return mk.createSession('persistent-license'); },
|
|
isNotSupportedAllowed: true
|
|
},
|
|
// Try additional parameter, which should be ignored.
|
|
{
|
|
func: function(mk) { return mk.createSession('temporary', 'extra'); },
|
|
isNotSupportedAllowed: false
|
|
}
|
|
];
|
|
|
|
// This function checks that calling |testCase.func| creates a
|
|
// MediaKeySession object with some default values. It also
|
|
// allows for an NotSupportedError to be generated and treated as a
|
|
// success, if allowed. See comment above kCreateSessionTestCases.
|
|
function test_createSession(testCase, mediaKeys)
|
|
{
|
|
var mediaKeySession;
|
|
try {
|
|
mediaKeySession = testCase.func.call(null, mediaKeys);
|
|
} catch (e) {
|
|
assert_true(testCase.isNotSupportedAllowed);
|
|
return;
|
|
}
|
|
|
|
// FIXME: Update this set of tests when done
|
|
// implementing the latest spec.
|
|
assert_equals(typeof mediaKeySession, 'object');
|
|
assert_equals(typeof mediaKeySession.addEventListener, 'function');
|
|
assert_equals(typeof mediaKeySession.generateRequest, 'function');
|
|
assert_equals(typeof mediaKeySession.update, 'function');
|
|
assert_equals(typeof mediaKeySession.close, 'function');
|
|
assert_equals(typeof mediaKeySession.remove, 'function');
|
|
assert_equals(mediaKeySession.sessionId, '');
|
|
assert_equals(typeof mediaKeySession.sessionId, 'string');
|
|
assert_equals(typeof mediaKeySession.onopen, 'undefined');
|
|
assert_equals(typeof mediaKeySession.onmessage, 'undefined');
|
|
assert_equals(typeof mediaKeySession.onclose, 'undefined');
|
|
assert_equals(typeof mediaKeySession.onerror, 'undefined');
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
kCreateSessionTestCases.map(function(testCase) {
|
|
test_createSession(testCase, mediaKeys);
|
|
});
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'createSession() tests failed');
|
|
});
|
|
}, 'Test MediaKeys createSession().');
|
|
|
|
// This function checks that calling generateRequest() works for
|
|
// various sessions. |testCase.func| creates a MediaKeySession
|
|
// object, and then generateRequest() is called on that object. It
|
|
// allows for an NotSupportedError to be generated and treated as a
|
|
// success, if allowed. See comment above kCreateSessionTestCases.
|
|
function test_generateRequest(testCase, mediaKeys, type, initData)
|
|
{
|
|
try {
|
|
var mediaKeySession = testCase.func.call(null, mediaKeys);
|
|
return mediaKeySession.generateRequest(type, initData);
|
|
} catch (e) {
|
|
assert_true(testCase.isNotSupportedAllowed);
|
|
}
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var sessionPromises = [];
|
|
|
|
// Test that WebM sessions generate the expected error, if
|
|
// supported.
|
|
if (isWebmSupported) {
|
|
var WebmSessionPromises = kCreateSessionTestCases.map(function(testCase) {
|
|
return test_generateRequest(testCase, mediaKeys, 'webm', getInitData('webm'));
|
|
});
|
|
sessionPromises = sessionPromises.concat(WebmSessionPromises);
|
|
}
|
|
|
|
// Repeat for MP4, if supported.
|
|
if (isCencSupported) {
|
|
var mp4SessionPromises = kCreateSessionTestCases.map(function(testCase) {
|
|
return test_generateRequest(testCase, mediaKeys, 'cenc', getInitData('cenc'));
|
|
});
|
|
sessionPromises = sessionPromises.concat(mp4SessionPromises);
|
|
}
|
|
|
|
assert_not_equals(sessionPromises.length, 0);
|
|
return Promise.all(sessionPromises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'generateRequest() tests failed');
|
|
});
|
|
}, 'Test MediaKeys generateRequest().');
|
|
|
|
var kUpdateSessionExceptionsTestCases = [
|
|
// Tests in this set use a shortened parameter name due to
|
|
// format_value() only returning the first 60 characters as the
|
|
// result. With a longer name (mediaKeySession) the first 60
|
|
// characters is not enough to determine which test failed.
|
|
|
|
// Too few parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(s) { return s.update(); }
|
|
},
|
|
// Invalid parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(s) { return s.update(''); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(s) { return s.update(null); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(s) { return s.update(undefined); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(s) { return s.update(1); }
|
|
},
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(s) { return s.update(new Uint8Array(0)); }
|
|
}
|
|
];
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = [];
|
|
|
|
if (isWebmSupported) {
|
|
var WebmSessionPromises = kUpdateSessionExceptionsTestCases.map(function(testCase) {
|
|
var mediaKeySession = mediaKeys.createSession();
|
|
return mediaKeySession.generateRequest('webm', getInitData('webm')).then(function(result) {
|
|
return test_exception(testCase, mediaKeySession);
|
|
});
|
|
});
|
|
promises = promises.concat(WebmSessionPromises);
|
|
}
|
|
|
|
if (isCencSupported) {
|
|
var mp4SessionPromises = kUpdateSessionExceptionsTestCases.map(function(testCase) {
|
|
var mediaKeySession = mediaKeys.createSession();
|
|
return mediaKeySession.generateRequest('cenc', getInitData('cenc')).then(function(result) {
|
|
return test_exception(testCase, mediaKeySession);
|
|
});
|
|
});
|
|
promises = promises.concat(mp4SessionPromises);
|
|
}
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'update() tests failed');
|
|
});
|
|
}, 'Test MediaKeySession update() exceptions.');
|
|
|
|
function create_update_test(mediaKeys, type, initData)
|
|
{
|
|
var mediaKeySession = mediaKeys.createSession();
|
|
var promise = mediaKeySession.generateRequest(type, initData).then(function(result) {
|
|
var validLicense = stringToUint8Array(createJWKSet(createJWK(stringToUint8Array('123'), stringToUint8Array('1234567890abcdef'))));
|
|
return mediaKeySession.update(validLicense);
|
|
}).then(function(result) {
|
|
// Call update() with a different license and an extra
|
|
// parameter. The extra parameter is ignored.
|
|
var validLicense = stringToUint8Array(createJWKSet(createJWK(stringToUint8Array('4567890'), stringToUint8Array('01234567890abcde'))));
|
|
return mediaKeySession.update(validLicense, 'extra');
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = [];
|
|
|
|
if (isWebmSupported) {
|
|
promises.push(create_update_test(mediaKeys, 'webm', getInitData('webm')));
|
|
}
|
|
|
|
if (isCencSupported) {
|
|
promises.push(create_update_test(mediaKeys, 'cenc', getInitData('cenc')));
|
|
}
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'update() tests failed');
|
|
});
|
|
}, 'Test MediaKeySession update().');
|
|
|
|
function create_close_exception_test(mediaKeys, type, initData)
|
|
{
|
|
var mediaKeySession = mediaKeys.createSession();
|
|
return mediaKeySession.close().then(function(result) {
|
|
assert_unreached('close() should not succeed if session uninitialized');
|
|
}).catch(function(error) {
|
|
assert_equals(error.name, 'InvalidStateError');
|
|
// Return something so the promise resolves.
|
|
return Promise.resolve();
|
|
});
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = [];
|
|
|
|
if (isWebmSupported) {
|
|
promises.push(create_close_exception_test(mediaKeys, 'webm', getInitData('webm')));
|
|
}
|
|
|
|
if (isCencSupported) {
|
|
promises.push(create_close_exception_test(mediaKeys, 'cenc', getInitData('cenc')));
|
|
}
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'close() exception tests failed');
|
|
});
|
|
}, 'Test MediaKeySession close() exceptions.');
|
|
|
|
|
|
function create_close_test(mediaKeys, type, initData)
|
|
{
|
|
var mediaKeySession = mediaKeys.createSession();
|
|
var promise = mediaKeySession.generateRequest(type, initData).then(function(result) {
|
|
return mediaKeySession.close();
|
|
}).then(function(result) {
|
|
// Call close() again with an extra parameter. The extra
|
|
// parameter is ignored.
|
|
return mediaKeySession.close('extra');
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = [];
|
|
|
|
if (isWebmSupported) {
|
|
promises.push(create_close_test(mediaKeys, 'webm', getInitData('webm')));
|
|
}
|
|
|
|
if (isCencSupported) {
|
|
promises.push(create_close_test(mediaKeys, 'cenc', getInitData('cenc')));
|
|
}
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'close() tests failed');
|
|
});
|
|
}, 'Test MediaKeySession close().');
|
|
|
|
function create_remove_exception_test(mediaKeys, type, initData)
|
|
{
|
|
// remove() on an uninitialized session should fail.
|
|
var mediaKeySession = mediaKeys.createSession('temporary');
|
|
return mediaKeySession.remove().then(function(result) {
|
|
assert_unreached('remove() should not succeed if session uninitialized');
|
|
}, function(error) {
|
|
assert_equals(error.name, 'InvalidStateError');
|
|
|
|
// remove() on a temporary session should fail.
|
|
return mediaKeySession.generateRequest(type, initData);
|
|
}).then(function(result) {
|
|
return mediaKeySession.remove();
|
|
}).then(function(result) {
|
|
assert_unreached('remove() should not succeed for temporary sessions');
|
|
}, function(error) {
|
|
assert_equals(error.name, 'InvalidAccessError');
|
|
});
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = [];
|
|
|
|
if (isWebmSupported) {
|
|
promises.push(create_remove_exception_test(mediaKeys, 'webm', getInitData('webm')));
|
|
}
|
|
|
|
if (isCencSupported) {
|
|
promises.push(create_remove_exception_test(mediaKeys, 'cenc', getInitData('cenc')));
|
|
}
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'remove() exception tests failed');
|
|
});
|
|
}, 'Test MediaKeySession remove() exceptions.');
|
|
|
|
function create_remove_test(mediaKeys, type, initData)
|
|
{
|
|
// Clear Key may not support persistent-license sessions.
|
|
var mediaKeySession;
|
|
try {
|
|
mediaKeySession = mediaKeys.createSession('persistent-license');
|
|
} catch (error) {
|
|
// Not supported, so return a resolved promise.
|
|
assert_equals(error.name, 'NotSupportedError');
|
|
return Promise.resolve();
|
|
}
|
|
return mediaKeySession.generateRequest(type, initData).then(function(result) {
|
|
return mediaKeySession.remove();
|
|
});
|
|
}
|
|
|
|
async_test(function(test)
|
|
{
|
|
var isWebmSupported;
|
|
var isCencSupported;
|
|
|
|
isInitDataTypeSupported('webm').then(function(result) {
|
|
isWebmSupported = result;
|
|
return isInitDataTypeSupported('cenc');
|
|
}).then(function(result) {
|
|
isCencSupported = result;
|
|
return navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]);
|
|
}).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = [];
|
|
|
|
if (isWebmSupported) {
|
|
promises.push(create_remove_test(mediaKeys, 'webm', getInitData('webm')));
|
|
}
|
|
|
|
if (isCencSupported) {
|
|
promises.push(create_remove_test(mediaKeys, 'cenc', getInitData('cenc')));
|
|
}
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'remove() tests failed');
|
|
});
|
|
}, 'Test MediaKeySession remove().');
|
|
|
|
var kSetServerCertificateExceptionsTestCases = [
|
|
// Too few parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.setServerCertificate(); }
|
|
},
|
|
// Invalid parameters.
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.setServerCertificate(''); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.setServerCertificate(null); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.setServerCertificate(undefined); }
|
|
},
|
|
{
|
|
exception: 'TypeError',
|
|
func: function(mk) { return mk.setServerCertificate(1); }
|
|
},
|
|
// Empty array.
|
|
{
|
|
exception: 'InvalidAccessError',
|
|
func: function(mk) { return mk.setServerCertificate(new Uint8Array(0)); }
|
|
}
|
|
];
|
|
|
|
async_test(function(test)
|
|
{
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = kSetServerCertificateExceptionsTestCases.map(function(testCase) {
|
|
return test_exception(testCase, mediaKeys);
|
|
});
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'setServerCertificate() exception tests failed');
|
|
});
|
|
}, 'Test MediaKeys setServerCertificate() exceptions.');
|
|
|
|
// All calls to |func| in this group are expected to resolve.
|
|
var kSetServerCertificateTestCases = [
|
|
{
|
|
// Pass in ArrayBufferView
|
|
func: function(mk) {
|
|
var cert = new Uint8Array(200);
|
|
assert_true(ArrayBuffer.isView(cert));
|
|
return mk.setServerCertificate(cert);
|
|
},
|
|
expected: false,
|
|
},
|
|
{
|
|
// Pass in ArrayBuffer
|
|
func: function(mk) {
|
|
var buffer = new ArrayBuffer(200);
|
|
assert_false(ArrayBuffer.isView(buffer));
|
|
return mk.setServerCertificate(buffer);
|
|
},
|
|
expected: false,
|
|
}
|
|
];
|
|
|
|
async_test(function(test)
|
|
{
|
|
var expected_result;
|
|
navigator.requestMediaKeySystemAccess('org.w3.clearkey', [{}]).then(function(access) {
|
|
return access.createMediaKeys();
|
|
}).then(function(mediaKeys) {
|
|
var promises = kSetServerCertificateTestCases.map(function(testCase) {
|
|
return testCase.func.call(null, mediaKeys);
|
|
});
|
|
expected_result = kSetServerCertificateTestCases.map(function(testCase) {
|
|
return testCase.expected;
|
|
});
|
|
|
|
assert_not_equals(promises.length, 0);
|
|
return Promise.all(promises);
|
|
}).then(function(result) {
|
|
assert_array_equals(result, expected_result);
|
|
test.done();
|
|
}).catch(function(error) {
|
|
forceTestFailureFromPromise(test, error, 'setServerCertificate() test failed');
|
|
});
|
|
}, 'Test MediaKeys setServerCertificate().');
|
|
|
|
|
|
// FIXME: Add syntax checks for MediaKeys.IsTypeSupported().
|
|
// FIXME: Add syntax checks for MediaKeyError and MediaKeySession events.
|
|
// FIXME: Add HTMLMediaElement syntax checks, e.g. setMediaKeys, mediakeys, onencrypted.
|
|
</script>
|
|
</body>
|
|
</html>
|