tor-browser

eme.js (11930B)

---

/* import-globals-from manifest.js */

const CLEARKEY_KEYSYSTEM = "org.w3.clearkey";

const gCencMediaKeySystemConfig = [
 {
   initDataTypes: ["cenc"],
   videoCapabilities: [{ contentType: "video/mp4" }],
   audioCapabilities: [{ contentType: "audio/mp4" }],
 },
];

function bail(message) {
 return function (err) {
   if (err) {
     message += "; " + String(err);
   }
   ok(false, message);
   if (err) {
     info(String(err));
   }
   SimpleTest.finish();
 };
}

function ArrayBufferToString(arr) {
 var str = "";
 var view = new Uint8Array(arr);
 for (var i = 0; i < view.length; i++) {
   str += String.fromCharCode(view[i]);
 }
 return str;
}

function StringToArrayBuffer(str) {
 var arr = new ArrayBuffer(str.length);
 var view = new Uint8Array(arr);
 for (var i = 0; i < str.length; i++) {
   view[i] = str.charCodeAt(i);
 }
 return arr;
}

function StringToHex(str) {
 var res = "";
 for (var i = 0; i < str.length; ++i) {
   res += ("0" + str.charCodeAt(i).toString(16)).slice(-2);
 }
 return res;
}

function Base64ToHex(str) {
 var bin = window.atob(str.replace(/-/g, "+").replace(/_/g, "/"));
 var res = "";
 for (var i = 0; i < bin.length; i++) {
   res += ("0" + bin.charCodeAt(i).toString(16)).substr(-2);
 }
 return res;
}

function HexToBase64(hex) {
 var bin = "";
 for (var i = 0; i < hex.length; i += 2) {
   bin += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
 }
 return window
   .btoa(bin)
   .replace(/=/g, "")
   .replace(/\+/g, "-")
   .replace(/\//g, "_");
}

function TimeRangesToString(trs) {
 var l = trs.length;
 if (l === 0) {
   return "-";
 }
 var s = "";
 var i = 0;
 for (;;) {
   s += trs.start(i) + "-" + trs.end(i);
   if (++i === l) {
     return s;
   }
   s += ",";
 }
}

function SourceBufferToString(sb) {
 return (
   "SourceBuffer{" +
   "AppendMode=" +
   (sb.AppendMode || "-") +
   ", updating=" +
   (sb.updating ? "true" : "false") +
   ", buffered=" +
   TimeRangesToString(sb.buffered) +
   ", audioTracks=" +
   (sb.audioTracks ? sb.audioTracks.length : "-") +
   ", videoTracks=" +
   (sb.videoTracks ? sb.videoTracks.length : "-") +
   "}"
 );
}

function SourceBufferListToString(sbl) {
 return "SourceBufferList[" + sbl.map(SourceBufferToString).join(", ") + "]";
}

function GenerateClearKeyLicense(licenseRequest, keyStore) {
 var msgStr = ArrayBufferToString(licenseRequest);
 var msg = JSON.parse(msgStr);

 var keys = [];
 for (var i = 0; i < msg.kids.length; i++) {
   var id64 = msg.kids[i];
   var idHex = Base64ToHex(msg.kids[i]).toLowerCase();
   var key = keyStore[idHex];

   if (key) {
     keys.push({
       kty: "oct",
       kid: id64,
       k: HexToBase64(key),
     });
   }
 }

 return new TextEncoder().encode(
   JSON.stringify({
     keys,
     type: msg.type || "temporary",
   })
 );
}

function UpdateSessionFunc(test, token, sessionType, resolve, reject) {
 return function (ev) {
   var license = GenerateClearKeyLicense(ev.message, test.keys);
   Log(
     token,
     "sending update message to CDM: " + new TextDecoder().decode(license)
   );
   ev.target
     .update(license)
     .then(function () {
       Log(token, "MediaKeySession update ok!");
       resolve(ev.target);
     })
     .catch(function (reason) {
       reject(`${token} MediaKeySession update failed: ${reason}`);
     });
 };
}

function MaybeCrossOriginURI(test, uri) {
 if (test.crossOrigin) {
   return "https://example.com:443/tests/dom/media/test/allowed.sjs?" + uri;
 }
 return uri;
}

function AppendTrack(test, ms, track, token) {
 return new Promise(function (resolve, reject) {
   var sb;
   var curFragment = 0;
   var fragments = track.fragments;
   var fragmentFile;

   function addNextFragment() {
     if (curFragment >= fragments.length) {
       Log(token, track.name + ": end of track");
       resolve();
       return;
     }

     fragmentFile = MaybeCrossOriginURI(test, fragments[curFragment++]);

     var req = new XMLHttpRequest();
     req.open("GET", fragmentFile);
     req.responseType = "arraybuffer";

     req.addEventListener("load", function () {
       Log(
         token,
         track.name + ": fetch of " + fragmentFile + " complete, appending"
       );
       sb.appendBuffer(new Uint8Array(req.response));
     });

     req.addEventListener("error", function () {
       reject(`${token} - ${track.name}: error fetching ${fragmentFile}`);
     });
     req.addEventListener("abort", function () {
       reject(`${token} - ${track.name}: aborted fetching ${fragmentFile}`);
     });

     Log(
       token,
       track.name +
         ": addNextFragment() fetching next fragment " +
         fragmentFile
     );
     req.send(null);
   }

   Log(token, track.name + ": addSourceBuffer(" + track.type + ")");
   sb = ms.addSourceBuffer(track.type);
   sb.addEventListener("updateend", function () {
     Log(
       token,
       track.name +
         ": updateend for " +
         fragmentFile +
         ", " +
         SourceBufferToString(sb)
     );
     addNextFragment();
   });

   addNextFragment();
 });
}

//Returns a promise that is resolved when the media element is ready to have
//its play() function called; when it's loaded MSE fragments.
function LoadTest(test, elem, token, endOfStream = true) {
 if (!test.tracks) {
   ok(false, token + " test does not have a tracks list");
   return Promise.reject();
 }

 var ms = new MediaSource();
 elem.src = URL.createObjectURL(ms);
 elem.crossOrigin = test.crossOrigin || false;

 return new Promise(function (resolve, reject) {
   ms.addEventListener(
     "sourceopen",
     function () {
       Log(token, "sourceopen");
       Promise.all(
         test.tracks.map(function (track) {
           return AppendTrack(test, ms, track, token);
         })
       )
         .then(function () {
           Log(token, "Tracks loaded, calling MediaSource.endOfStream()");
           if (endOfStream) {
             ms.endOfStream();
           }
           resolve();
         })
         .catch(reject);
     },
     { once: true }
   );
 });
}

function EMEPromise() {
 var self = this;
 self.promise = new Promise(function (resolve, reject) {
   self.resolve = resolve;
   self.reject = reject;
 });
}

/*
* Create a new MediaKeys object.
* Return a promise which will be resolved with a new MediaKeys object,
* or will be rejected with a string that describes the failure.
*/
function CreateMediaKeys(v, test, token) {
 let p = new EMEPromise();

 function streamType(type) {
   var x = test.tracks.find(o => o.name == type);
   return x ? x.type : undefined;
 }

 function onencrypted(ev) {
   var options = { initDataTypes: [ev.initDataType] };
   if (streamType("video")) {
     options.videoCapabilities = [{ contentType: streamType("video") }];
   }
   if (streamType("audio")) {
     options.audioCapabilities = [{ contentType: streamType("audio") }];
   }
   navigator.requestMediaKeySystemAccess(CLEARKEY_KEYSYSTEM, [options]).then(
     keySystemAccess => {
       keySystemAccess
         .createMediaKeys()
         .then(p.resolve, () =>
           p.reject(`${token} Failed to create MediaKeys object.`)
         );
     },
     () => p.reject(`${token} Failed to request key system access.`)
   );
 }

 v.addEventListener("encrypted", onencrypted, { once: true });
 return p.promise;
}

/*
* Create a new MediaKeys object and provide it to the media element.
* Return a promise which will be resolved if succeeded, or will be rejected
* with a string that describes the failure.
*/
function CreateAndSetMediaKeys(v, test, token) {
 let p = new EMEPromise();

 CreateMediaKeys(v, test, token).then(mediaKeys => {
   v.setMediaKeys(mediaKeys).then(p.resolve, () =>
     p.reject(`${token} Failed to set MediaKeys on <video> element.`)
   );
 }, p.reject);

 return p.promise;
}

/*
* Collect the init data from 'encrypted' events.
* Return a promise which will be resolved with the init data when collection
* is completed (specified by test.sessionCount).
*/
function LoadInitData(v, test, token) {
 let p = new EMEPromise();
 let initDataQueue = [];

 // Call SimpleTest._originalSetTimeout() to bypass the flaky timeout checker.
 let timer = SimpleTest._originalSetTimeout.call(
   window,
   () => {
     p.reject(`${token} Timed out in waiting for the init data.`);
   },
   60000
 );

 function onencrypted(ev) {
   initDataQueue.push(ev);
   Log(
     token,
     `got encrypted(${ev.initDataType}, ` +
       `${StringToHex(ArrayBufferToString(ev.initData))}) event.`
   );
   if (test.sessionCount == initDataQueue.length) {
     p.resolve(initDataQueue);
     clearTimeout(timer);
   }
 }

 v.addEventListener("encrypted", onencrypted);
 return p.promise;
}

/*
* Generate a license request and update the session.
* Return a promsise which will be resolved with the updated session
* or rejected with a string that describes the failure.
*/
function MakeRequest(test, token, ev, session, sessionType) {
 sessionType = sessionType || "temporary";
 let p = new EMEPromise();
 let str =
   `session[${session.sessionId}].generateRequest(` +
   `${ev.initDataType}, ${StringToHex(ArrayBufferToString(ev.initData))})`;

 session.addEventListener(
   "message",
   UpdateSessionFunc(test, token, sessionType, p.resolve, p.reject)
 );

 Log(token, str);
 session.generateRequest(ev.initDataType, ev.initData).catch(reason => {
   // Reject the promise if generateRequest() failed.
   // Otherwise it will be resolved in UpdateSessionFunc().
   p.reject(`${token}: ${str} failed; ${reason}`);
 });

 return p.promise;
}

/*
* Process the init data by calling MakeRequest().
* Return a promise which will be resolved with the updated sessions
* when all init data are processed or rejected if any failure.
*/
function ProcessInitData(v, test, token, initData, sessionType) {
 return Promise.all(
   initData.map(ev => {
     let session = v.mediaKeys.createSession(sessionType);
     return MakeRequest(test, token, ev, session, sessionType);
   })
 );
}

/*
* Clean up the |v| element.
*/
function CleanUpMedia(v) {
 v.setMediaKeys(null);
 v.remove();
 v.removeAttribute("src");
 v.load();
}

/*
* Close all sessions and clean up the |v| element.
*/
function CloseSessions(v, sessions) {
 return Promise.all(sessions.map(s => s.close())).then(CleanUpMedia(v));
}

/*
* Set up media keys and source buffers for the media element.
* Return a promise resolved when all key sessions are updated or rejected
* if any failure.
*/
function SetupEME(v, test, token) {
 let p = new EMEPromise();

 v.onerror = function () {
   p.reject(`${token} got an error event.`);
 };

 Promise.all([
   LoadInitData(v, test, token),
   CreateAndSetMediaKeys(v, test, token),
   LoadTest(test, v, token),
 ])
   .then(values => {
     let initData = values[0];
     return ProcessInitData(v, test, token, initData);
   })
   .then(p.resolve, p.reject);

 return p.promise;
}

function fetchWithXHR(uri, onLoadFunction) {
 var p = new Promise(function (resolve) {
   var xhr = new XMLHttpRequest();
   xhr.open("GET", uri, true);
   xhr.responseType = "arraybuffer";
   xhr.addEventListener("load", function () {
     is(
       xhr.status,
       200,
       "fetchWithXHR load uri='" + uri + "' status=" + xhr.status
     );
     resolve(xhr.response);
   });
   xhr.send();
 });

 if (onLoadFunction) {
   p.then(onLoadFunction);
 }

 return p;
}

function once(target, name, cb) {
 var p = new Promise(function (resolve) {
   target.addEventListener(
     name,
     function (arg) {
       resolve(arg);
     },
     { once: true }
   );
 });
 if (cb) {
   p.then(cb);
 }
 return p;
}