Index: third_party/WebKit/LayoutTests/imported/wpt/encrypted-media/scripts/syntax-mediakeysession.js |
diff --git a/third_party/WebKit/LayoutTests/imported/wpt/encrypted-media/scripts/syntax-mediakeysession.js b/third_party/WebKit/LayoutTests/imported/wpt/encrypted-media/scripts/syntax-mediakeysession.js |
new file mode 100644 |
index 0000000000000000000000000000000000000000..3663a7b930db8c8d66cc9345a394ee59aa85ae50 |
--- /dev/null |
+++ b/third_party/WebKit/LayoutTests/imported/wpt/encrypted-media/scripts/syntax-mediakeysession.js |
@@ -0,0 +1,445 @@ |
+function runTest(config) { |
+ var keysystem = config.keysystem; |
+ var testname = testnamePrefix(null, config.keysystem); |
+ var initDataType = config.initDataType; |
+ var initData = config.initData; |
+ var configuration = { |
+ initDataTypes: [config.initDataType], |
+ audioCapabilities: [{contentType: config.audioType}], |
+ videoCapabilities: [{contentType: config.videoType}], |
+ sessionTypes: ['temporary'] |
+ }; |
+ |
+ 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); |
+ } |
+ }, |
+ // (new Uint8Array(0)) returns empty array. So 'TypeError' should |
+ // be returned. |
+ { |
+ exception: 'TypeError', |
+ func: function (mk6, type) { |
+ return mk6.createSession().generateRequest(type, new Uint8Array(0)); |
+ } |
+ } |
+ ]; |
+ function generateRequestTestExceptions(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType not supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ var mp4SessionPromises = kTypeSpecificGenerateRequestExceptionsTestCases.map(function (testCase) { |
+ return test_exception(testCase, mediaKeys, initDataType, initData); |
+ }); |
+ assert_not_equals(mp4SessionPromises.length, 0); |
+ return Promise.all(mp4SessionPromises); |
+ }).then(function (result) { |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }) |
+ } |
+ promise_test(function() { |
+ return generateRequestTestExceptions(); |
+ }, testname + ' test MediaKeySession generateRequest() exceptions.'); |
+ |
+ var kLoadExceptionsTestCases = [ |
+ // Too few parameters. |
+ { |
+ exception: 'TypeError', |
+ func: function (mk1) { |
+ return mk1.createSession('temporary').load(); |
+ } |
+ }, |
+ { |
+ 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'); |
+ } |
+ } |
+ ]; |
+ function loadTestExceptions(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType not supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ var sessionPromises = kLoadExceptionsTestCases.map(function (testCase) { |
+ return test_exception(testCase, mediaKeys); |
+ }); |
+ assert_not_equals(sessionPromises.length, 0); |
+ return Promise.all(sessionPromises); |
+ }).then(function () { |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }) |
+ } |
+ promise_test(function() { |
+ return loadTestExceptions(); |
+ }, testname + ' test MediaKeySession 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 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) { |
+ var mediaKeySession; |
+ try { |
+ mediaKeySession = testCase.func.call(null, mediaKeys); |
+ } catch (e) { |
+ assert_true(testCase.isNotSupportedAllowed); |
+ assert_equals(e.name, 'NotSupportedError'); |
+ return Promise.resolve('not supported'); |
+ } |
+ return mediaKeySession.generateRequest(type, initData); |
+ } |
+ function generateRequestForVariousSessions(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType should be supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ var mp4SessionPromises = kCreateSessionTestCases.map(function (testCase) { |
+ return test_generateRequest(testCase, mediaKeys, initDataType, initData); |
+ }); |
+ assert_not_equals(mp4SessionPromises.length, 0); |
+ return Promise.all(mp4SessionPromises); |
+ }).then(function () { |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }) |
+ } |
+ promise_test(function() { |
+ return generateRequestForVariousSessions(); |
+ }, testname + ' test if MediaKeySession generateRequest() resolves for various sessions'); |
+ |
+ 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); |
+ } |
+ }, |
+ // (new Uint8Array(0)) returns empty array. So 'TypeError' should |
+ // be returned. |
+ { |
+ exception: 'TypeError', |
+ func: function (s) { |
+ return s.update(new Uint8Array(0)); |
+ } |
+ } |
+ ]; |
+ |
+ function updateTestExceptions(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType not supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ var mp4SessionPromises = kUpdateSessionExceptionsTestCases.map(function (testCase) { |
+ var mediaKeySession = mediaKeys.createSession(); |
+ return mediaKeySession.generateRequest(initDataType, initData).then(function (result) { |
+ return test_exception(testCase, mediaKeySession); |
+ }); |
+ }); |
+ assert_not_equals(mp4SessionPromises.length, 0); |
+ return Promise.all(mp4SessionPromises); |
+ }).then(function () { |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }) |
+ } |
+ promise_test(function() { |
+ return updateTestExceptions(); |
+ }, testname + ' test MediaKeySession update() exceptions.'); |
+ |
+ function create_close_exception_test(mediaKeys) { |
+ 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(); |
+ }); |
+ } |
+ function closeTestExceptions(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType not supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ return create_close_exception_test(mediaKeys); |
+ }).then(function () { |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }); |
+ } |
+ promise_test(function() { |
+ return closeTestExceptions(); |
+ }, testname + ' test MediaKeySession close() exceptions.'); |
+ |
+ 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'); |
+ }); |
+ } |
+ function removeTestException(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType not supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ return create_remove_exception_test(mediaKeys, initDataType, initData); |
+ }).then(function () { |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }); |
+ } |
+ promise_test(function() { |
+ return removeTestException(); |
+ }, testname + ' test MediaKeySession remove() 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, ''); |
+ } |
+ function createSessionTest(){ |
+ return new Promise(function(resolve, reject){ |
+ isInitDataTypeSupported(keysystem, initDataType).then(function (isTypeSupported) { |
+ assert_true(isTypeSupported, "initDataType not supported"); |
+ return navigator.requestMediaKeySystemAccess(keysystem, [configuration]); |
+ }).then(function (access) { |
+ return access.createMediaKeys(); |
+ }).then(function (mediaKeys) { |
+ kCreateSessionTestCases.map(function (testCase) { |
+ test_createSession(testCase, mediaKeys); |
+ }); |
+ resolve(); |
+ }).catch(function (error) { |
+ reject(error); |
+ }); |
+ }) |
+ } |
+ promise_test(function() { |
+ return createSessionTest(); |
+ }, testname + ' test MediaKeySession attribute syntax.'); |
+ |
+ |
+} |