function runTest(config)
{
// For debugging timeouts, keep track of the number of the
// various events received.
var debugEncryptedEventFired = false;
var debugWaitingForKeyEventFired = false;
var debugTimeUpdateEventCount = 0;
var debugMessage = '';
// Set global option explicit_timeout to true and control
// the timeout in the promise test below.
setup({
explicit_timeout: true
});
promise_test(function (test) {
var video = config.video;
var keysystem = config.keysystem;
var configuration = {
initDataTypes: [config.initDataType],
audioCapabilities: [{
contentType: config.audioType
}],
videoCapabilities: [{
contentType: config.videoType
}],
sessionTypes: ['temporary']
};
var initData;
var initDataType;
var mediaKeySession;
// As this code doesn't wait for the 'message' event for clearkey to avoid
// race conditions with 'waitingforkey', specify the key ID and
// key used by the encrypted content.
var keyId = new Uint8Array(config.content.keys[0].kid);
var rawKey = new Uint8Array(config.content.keys[0].key);
// Use the message handler for non clearkey drm
var handler = config.messageHandler || null;
// Override timeout() to use custom message instead of default
// message "Test timed out"
test.timeout = function () {
var message = 'timeout. message = ' + debugMessage
+ ', encrypted: ' + debugEncryptedEventFired
+ ', waitingforkey: ' + debugWaitingForKeyEventFired
+ ', timeupdate count: ' + debugTimeUpdateEventCount;
this.timeout_id = null;
this.set_status(this.TIMEOUT, message);
this.phase = this.phases.HAS_RESULT;
this.done();
};
return navigator.requestMediaKeySystemAccess(keysystem, [configuration]).then(function (access) {
debugMessage = 'createMediaKeys()';
return access.createMediaKeys();
}).then(function (mediaKeys) {
debugMessage = 'setMediaKeys()';
return video.setMediaKeys(mediaKeys);
}).then(function () {
return testmediasource(config);
}).then(function (source) {
debugMessage = 'wait_for_encrypted_event()';
mediaSource = source;
video.src = URL.createObjectURL(mediaSource);
video.play();
return wait_for_encrypted_event(video);
}).then(function (e) {
// Received the 'encrypted' event(s), so keep a copy of
// the initdata for use when creating the session later.
initDataType = config.initData ? config.initDataType : e.initDataType;
initData = config.initData || e.initData;
// Wait until the video indicates that it needs a key to
// continue.
debugMessage = 'wait_for_waitingforkey_event()';
return wait_for_waitingforkey_event(video);
}).then(function () {
// Make sure the video is NOT paused and not progressing
// before a key is provided. This requires the video
// to NOT have a clear lead.
assert_false(video.paused);
assert_less_than(video.currentTime, 0.2);
// Create a session.
mediaKeySession = video.mediaKeys.createSession('temporary');
debugMessage = 'generateRequest()';
return mediaKeySession.generateRequest(initDataType, initData);
}).then(function () {
// generateRequest() will cause a 'message' event to
// occur specifying the keyId that is needed
// Add the key needed to decrypt.
return wait_for_message_event(mediaKeySession, handler);
}).then(function () {
// Video should start playing now that it can decrypt the
// streams, so wait until a little bit of the video has
// played.
debugMessage = 'wait_for_timeupdate_event()';
return wait_for_timeupdate_event(video);
}).catch(function (error) {
assert_unreached('Error: ' + error.name);
});
// Typical test duration is 6 seconds on release builds
// (12 seconds on debug).
}, 'Waiting for a key.');
// Wait for an 'encrypted' event
function wait_for_encrypted_event(video)
{
return new Promise(function (resolve) {
video.addEventListener('encrypted', function listener(e) {
assert_equals(e.target, video);
assert_true(e instanceof window.MediaEncryptedEvent);
assert_equals(e.type, 'encrypted');
debugEncryptedEventFired = true;
video.removeEventListener('encrypted', listener);
resolve(e);
});
});
};
// Wait for a 'waitingforkey' event. Promise resolved when the
// event is received.
function wait_for_waitingforkey_event(video)
{
return new Promise(function (resolve) {
video.addEventListener('waitingforkey', function listener(e) {
assert_equals(e.target, video);
assert_equals(e.type, 'waitingforkey');
debugWaitingForKeyEventFired = true;
video.removeEventListener('waitingforkey', listener);
resolve(e);
});
});
};
// Wait for a 'timeupdate' event. Promise resolved if |video| has
// played for more than 0.2 seconds.
function wait_for_timeupdate_event(video)
{
return new Promise(function (resolve) {
video.addEventListener('timeupdate', function listener(e) {
assert_equals(e.target, video);
++debugTimeUpdateEventCount;
if (video.currentTime < 0.2)
return;
video.removeEventListener('timeupdate', listener);
resolve(e);
});
});
};
// We need to wait for the message even if for non clearkey DRMs.
function wait_for_message_event(mediaKeySession, handler)
{
return new Promise(function (resolve, reject) {
mediaKeySession.addEventListener('message', function listener(e) {
assert_equals(e.target, mediaKeySession);
assert_equals(e.type, 'message');
video.removeEventListener('message', listener);
return handler(e.messageType, e.message).then(function (response) {
return e.target.update(response)
}).then(resolve, reject);
});
});
}
}
Codebase Browser
chromium