| <!DOCTYPE html> |
| <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> |
| <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: 'TypeError', |
| func: function() { return navigator.requestMediaKeySystemAccess(new Uint8Array(0), [{}]); } |
| }, |
| { |
| exception: 'TypeError', |
| 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: 'TypeError', |
| 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', getSimpleConfiguration()).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', getSimpleConfiguration()).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 MediaKeySystemAccess createMediaKeys().'); |
| |
| 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', getSimpleConfiguration()).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: 'TypeError', |
| 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: 'TypeError', |
| 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: 'TypeError', |
| 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', getSimpleConfiguration()); |
| }).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 |
| // 'TypeError'. |
| { |
| exception: 'TypeError', |
| func: function(mk3) { return mk3.createSession('temporary').load(''); } |
| }, |
| { |
| exception: 'TypeError', |
| func: function(mk4) { return mk4.createSession('temporary').load(1); } |
| }, |
| { |
| exception: 'TypeError', |
| func: function(mk5) { return mk5.createSession('temporary').load('!@#$%^&*()'); } |
| }, |
| { |
| exception: 'TypeError', |
| func: function(mk6) { return mk6.createSession('temporary').load('1234'); } |
| } |
| ]; |
| |
| async_test(function(test) |
| { |
| navigator.requestMediaKeySystemAccess('org.w3.clearkey', getSimpleConfiguration()).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; |
| } |
| |
| assert_equals(typeof mediaKeySession, 'object'); |
| assert_equals(typeof mediaKeySession.addEventListener, 'function'); |
| assert_equals(typeof mediaKeySession.sessionId, 'string'); |
| assert_equals(typeof mediaKeySession.expiration, 'number'); |
| assert_equals(typeof mediaKeySession.closed, 'object'); |
| assert_equals(typeof mediaKeySession.keyStatuses, 'object'); |
| assert_equals(typeof mediaKeySession.onkeystatuseschange, 'object'); |
| assert_equals(typeof mediaKeySession.onmessage, 'object'); |
| assert_equals(typeof mediaKeySession.generateRequest, 'function'); |
| assert_equals(typeof mediaKeySession.load, 'function'); |
| assert_equals(typeof mediaKeySession.update, 'function'); |
| assert_equals(typeof mediaKeySession.close, 'function'); |
| assert_equals(typeof mediaKeySession.remove, 'function'); |
| assert_equals(mediaKeySession.sessionId, ''); |
| } |
| |
| async_test(function(test) |
| { |
| navigator.requestMediaKeySystemAccess('org.w3.clearkey', getSimpleConfiguration()).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', getSimpleConfiguration()); |
| }).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: 'TypeError', |
| 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', getSimpleConfiguration()); |
| }).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', getSimpleConfiguration()); |
| }).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', getSimpleConfiguration()); |
| }).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', getSimpleConfiguration()); |
| }).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'); |
| }); |
| } |
| |
| 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', getSimpleConfiguration()); |
| }).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) |
| { |
| var mediaKeySession = mediaKeys.createSession(); |
| var promise = mediaKeySession.generateRequest(type, initData).then(function(result) { |
| return mediaKeySession.remove(); |
| }).then(function() { |
| // remove() doesn't close the session, so must call close(). |
| return mediaKeySession.close(); |
| }).then(function() { |
| try { |
| // Clear Key may not support persistent-license sessions. |
| mediaKeySession = mediaKeys.createSession('persistent-license'); |
| return mediaKeySession.generateRequest(type, initData).then(function(result) { |
| return mediaKeySession.remove(); |
| }).then(function() { |
| return mediaKeySession.close(); |
| }); |
| } catch (error) { |
| // Not supported, so return a resolved promise. |
| assert_equals(error.name, 'NotSupportedError'); |
| 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', getSimpleConfiguration()); |
| }).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: 'TypeError', |
| func: function(mk) { return mk.setServerCertificate(new Uint8Array(0)); } |
| } |
| ]; |
| |
| async_test(function(test) |
| { |
| navigator.requestMediaKeySystemAccess('org.w3.clearkey', getSimpleConfiguration()).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', getSimpleConfiguration()).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().'); |
| |
| function test_valid_message_type(message_type) |
| { |
| var event = new MediaKeyMessageEvent('eventType', { messageType: message_type, message: new ArrayBuffer(0) } ); |
| assert_equals(event.messageType, message_type); |
| } |
| |
| test(function(test) |
| { |
| // Valid MediaKeyMessageType values. |
| test_valid_message_type('license-request'); |
| test_valid_message_type('license-renewal'); |
| test_valid_message_type('license-release'); |
| // TODO(jrummell): Add 'individualization-request' if the final |
| // spec includes it. http://crbug.com/628437. |
| |
| // Invalid MediaKeyMessageType values should throw a TypeError. |
| assert_throws_js(TypeError, function() { |
| new MediaKeyMessageEvent('eventType', { messageType: 'something-else', message: new ArrayBuffer(0) } ); |
| }); |
| |
| // Missing required values should throw a TypeError. |
| assert_throws_js(TypeError, function() { |
| new MediaKeyMessageEvent('eventType', { message: new ArrayBuffer(0) } ); |
| }); |
| assert_throws_js(TypeError, function() { |
| new MediaKeyMessageEvent('eventType', { messageType: 'license-request' } ); |
| }); |
| }, 'Test MediaKeyMessageEvent.'); |
| |
| // 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> |
