Source: lib/polyfill/patchedmediakeys_ms.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.polyfill.PatchedMediaKeysMs');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.polyfill.register');
  23. goog.require('shaka.util.ArrayUtils');
  24. goog.require('shaka.util.EventManager');
  25. goog.require('shaka.util.FakeEvent');
  26. goog.require('shaka.util.FakeEventTarget');
  27. goog.require('shaka.util.Pssh');
  28. goog.require('shaka.util.PublicPromise');
  29. goog.require('shaka.util.Uint8ArrayUtils');
  32. /**
  33.  * @namespace shaka.polyfill.PatchedMediaKeysMs
  34.  *
  35.  * @summary A polyfill to implement
  36.  * {@link http://goo.gl/blgtZZ EME draft 12 March 2015}
  37.  * on top of ms-prefixed
  38.  * {@link http://www.w3.org/TR/2014/WD-encrypted-media-20140218/ EME v20140218}.
  39.  */
  42. /**
  43.  * Installs the polyfill if needed.
  44.  */
  45. shaka.polyfill.PatchedMediaKeysMs.install = function() {
  46.   if (!window.HTMLVideoElement || !window.MSMediaKeys ||
  47.       (navigator.requestMediaKeySystemAccess &&
  48.        MediaKeySystemAccess.prototype.getConfiguration)) {
  49.     return;
  50.   }
  51.   shaka.log.info('Using ms-prefixed EME v20140218');
  53.   // Alias
  54.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  56.   // Construct a fake key ID.  This is not done at load-time to avoid exceptions
  57.   // on unsupported browsers.  This particular fake key ID was suggested in
  58.   // w3c/encrypted-media#32.
  59.   PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_ = (new Uint8Array([0])).buffer;
  61.   // Delete mediaKeys to work around strict mode compatibility issues.
  62.   delete HTMLMediaElement.prototype['mediaKeys'];
  63.   // Work around read-only declaration for mediaKeys by using a string.
  64.   HTMLMediaElement.prototype['mediaKeys'] = null;
  65.   HTMLMediaElement.prototype.setMediaKeys = PatchedMediaKeysMs.setMediaKeys;
  67.   // Install patches
  68.   window.MediaKeys = PatchedMediaKeysMs.MediaKeys;
  69.   window.MediaKeySystemAccess = PatchedMediaKeysMs.MediaKeySystemAccess;
  70.   navigator.requestMediaKeySystemAccess =
  71.       PatchedMediaKeysMs.requestMediaKeySystemAccess;
  72. };
  75. /**
  76.  * An implementation of navigator.requestMediaKeySystemAccess.
  77.  * Retrieves a MediaKeySystemAccess object.
  78.  *
  79.  * @this {!Navigator}
  80.  * @param {string} keySystem
  81.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  82.  * @return {!Promise.<!MediaKeySystemAccess>}
  83.  */
  84. shaka.polyfill.PatchedMediaKeysMs.requestMediaKeySystemAccess =
  85.     function(keySystem, supportedConfigurations) {
  86.   shaka.log.debug('PatchedMediaKeysMs.requestMediaKeySystemAccess');
  87.   goog.asserts.assert(this == navigator,
  88.                       'bad "this" for requestMediaKeySystemAccess');
  90.   // Alias.
  91.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  92.   try {
  93.     let access = new PatchedMediaKeysMs.MediaKeySystemAccess(
  94.         keySystem, supportedConfigurations);
  95.     return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  96.   } catch (exception) {
  97.     return Promise.reject(exception);
  98.   }
  99. };
  103. /**
  104.  * An implementation of MediaKeySystemAccess.
  105.  *
  106.  * @constructor
  107.  * @struct
  108.  * @param {string} keySystem
  109.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  110.  * @implements {MediaKeySystemAccess}
  111.  * @throws {Error} if the key system is not supported.
  112.  */
  113. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess =
  114.     function(keySystem, supportedConfigurations) {
  115.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess');
  117.   /** @type {string} */
  118.   this.keySystem = keySystem;
  120.   /** @private {!MediaKeySystemConfiguration} */
  121.   this.configuration_;
  123.   let allowPersistentState = false;
  125.   let success = false;
  126.   for (let i = 0; i < supportedConfigurations.length; ++i) {
  127.     let cfg = supportedConfigurations[i];
  129.     // Create a new config object and start adding in the pieces which we
  130.     // find support for.  We will return this from getConfiguration() if asked.
  131.     /** @type {!MediaKeySystemConfiguration} */
  132.     let newCfg = {
  133.       'audioCapabilities': [],
  134.       'videoCapabilities': [],
  135.       // It is technically against spec to return these as optional, but we
  136.       // don't truly know their values from the prefixed API:
  137.       'persistentState': 'optional',
  138.       'distinctiveIdentifier': 'optional',
  139.       // Pretend the requested init data types are supported, since we don't
  140.       // really know that either:
  141.       'initDataTypes': cfg.initDataTypes,
  142.       'sessionTypes': ['temporary'],
  143.       'label': cfg.label
  144.     };
  146.     // PatchedMediaKeysMs tests for key system availability through
  147.     // MSMediaKeys.isTypeSupported
  148.     let ranAnyTests = false;
  149.     if (cfg.audioCapabilities) {
  150.       for (let j = 0; j < cfg.audioCapabilities.length; ++j) {
  151.         let cap = cfg.audioCapabilities[j];
  152.         if (cap.contentType) {
  153.           ranAnyTests = true;
  154.           let contentType = cap.contentType.split(';')[0];
  155.           if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  156.             newCfg.audioCapabilities.push(cap);
  157.             success = true;
  158.           }
  159.         }
  160.       }
  161.     }
  162.     if (cfg.videoCapabilities) {
  163.       for (let j = 0; j < cfg.videoCapabilities.length; ++j) {
  164.         let cap = cfg.videoCapabilities[j];
  165.         if (cap.contentType) {
  166.           ranAnyTests = true;
  167.           let contentType = cap.contentType.split(';')[0];
  168.           if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  169.             newCfg.videoCapabilities.push(cap);
  170.             success = true;
  171.           }
  172.         }
  173.       }
  174.     }
  176.     if (!ranAnyTests) {
  177.       // If no specific types were requested, we check all common types to find
  178.       // out if the key system is present at all.
  179.       success = MSMediaKeys.isTypeSupported(this.keySystem, 'video/mp4');
  180.     }
  181.     if (cfg.persistentState == 'required') {
  182.       if (allowPersistentState) {
  183.         newCfg.persistentState = 'required';
  184.         newCfg.sessionTypes = ['persistent-license'];
  185.       } else {
  186.         success = false;
  187.       }
  188.     }
  190.     if (success) {
  191.       this.configuration_ = newCfg;
  192.       return;
  193.     }
  194.   }  // for each cfg in supportedConfigurations
  196.   // As per the spec, this should be a DOMException, but there is not a public
  197.   // constructor for this.
  198.   let unsupportedKeySystemError = new Error('Unsupported keySystem');
  199.   unsupportedKeySystemError.name = 'NotSupportedError';
  200.   unsupportedKeySystemError.code = DOMException.NOT_SUPPORTED_ERR;
  201.   throw unsupportedKeySystemError;
  202. };
  205. /** @override */
  206. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess.prototype.
  207.     createMediaKeys = function() {
  208.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess.createMediaKeys');
  210.   // Alias
  211.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  213.   let mediaKeys = new PatchedMediaKeysMs.MediaKeys(this.keySystem);
  214.   return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  215. };
  218. /** @override */
  219. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess.prototype.
  220.     getConfiguration = function() {
  221.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess.getConfiguration');
  222.   return this.configuration_;
  223. };
  226. /**
  227.  * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  228.  * Attaches a MediaKeys object to the media element.
  229.  *
  230.  * @this {!HTMLMediaElement}
  231.  * @param {MediaKeys} mediaKeys
  232.  * @return {!Promise}
  233.  */
  234. shaka.polyfill.PatchedMediaKeysMs.setMediaKeys = function(mediaKeys) {
  235.   shaka.log.debug('PatchedMediaKeysMs.setMediaKeys');
  236.   goog.asserts.assert(this instanceof HTMLMediaElement,
  237.                       'bad "this" for setMediaKeys');
  239.   // Alias
  240.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  242.   let newMediaKeys =
  243.       /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  244.       mediaKeys);
  245.   let oldMediaKeys =
  246.       /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  247.       this.mediaKeys);
  249.   if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  250.     goog.asserts.assert(oldMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  251.                         'non-polyfill instance of oldMediaKeys');
  252.     // Have the old MediaKeys stop listening to events on the video tag.
  253.     oldMediaKeys.setMedia(null);
  254.   }
  256.   delete this['mediaKeys'];  // in case there is an existing getter
  257.   this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  259.   if (newMediaKeys) {
  260.     goog.asserts.assert(newMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  261.                         'non-polyfill instance of newMediaKeys');
  262.     return newMediaKeys.setMedia(this);
  263.   }
  265.   return Promise.resolve();
  266. };
  270. /**
  271.  * An implementation of MediaKeys.
  272.  *
  273.  * @constructor
  274.  * @struct
  275.  * @param {string} keySystem
  276.  * @implements {MediaKeys}
  277.  */
  278. shaka.polyfill.PatchedMediaKeysMs.MediaKeys = function(keySystem) {
  279.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys');
  281.   /** @private {!MSMediaKeys} */
  282.   this.nativeMediaKeys_ = new MSMediaKeys(keySystem);
  284.   /** @private {!shaka.util.EventManager} */
  285.   this.eventManager_ = new shaka.util.EventManager();
  286. };
  289. /** @override */
  290. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  291.     createSession = function(opt_sessionType) {
  292.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys.createSession');
  294.   let sessionType = opt_sessionType || 'temporary';
  295.   // For now, only the 'temporary' type is supported.
  296.   if (sessionType != 'temporary') {
  297.     throw new TypeError('Session type ' + opt_sessionType +
  298.         ' is unsupported on this platform.');
  299.   }
  301.   // Alias
  302.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  304.   return new PatchedMediaKeysMs.MediaKeySession(
  305.       this.nativeMediaKeys_, sessionType);
  306. };
  309. /** @override */
  310. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  311.     setServerCertificate = function(serverCertificate) {
  312.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys.setServerCertificate');
  314.   // There is no equivalent in PatchedMediaKeysMs, so return failure.
  315.   return Promise.resolve(false);
  316. };
  319. /**
  320.  * @param {HTMLMediaElement} media
  321.  * @protected
  322.  * @return {!Promise}
  323.  */
  324. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  325.     setMedia = function(media) {
  327.   // Alias
  328.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  330.   // Remove any old listeners.
  331.   this.eventManager_.removeAll();
  333.   // It is valid for media to be null; null is used to flag that event handlers
  334.   // need to be cleaned up.
  335.   if (!media) {
  336.     return Promise.resolve();
  337.   }
  339.   // Intercept and translate these prefixed EME events.
  340.   this.eventManager_.listen(media, 'msneedkey',
  341.       /** @type {shaka.util.EventManager.ListenerType} */
  342.       (PatchedMediaKeysMs.onMsNeedKey_));
  344.   let self = this;
  345.   function setMediaKeysDeferred() {
  346.     media.msSetMediaKeys(self.nativeMediaKeys_);
  347.     media.removeEventListener('loadedmetadata', setMediaKeysDeferred);
  348.   }
  350.   // Wrap native HTMLMediaElement.msSetMediaKeys with a Promise.
  351.   try {
  352.     // IE11/Edge requires that readyState >=1 before mediaKeys can be set, so
  353.     // check this and wait for loadedmetadata if we are not in the correct state
  354.     if (media.readyState >= 1) {
  355.       media.msSetMediaKeys(this.nativeMediaKeys_);
  356.     } else {
  357.       media.addEventListener('loadedmetadata', setMediaKeysDeferred);
  358.     }
  360.     return Promise.resolve();
  362.   } catch (exception) {
  363.     return Promise.reject(exception);
  364.   }
  365. };
  369. /**
  370.  * An implementation of MediaKeySession.
  371.  *
  372.  * @constructor
  373.  * @struct
  374.  * @param {MSMediaKeys} nativeMediaKeys
  375.  * @param {string} sessionType
  376.  * @implements {MediaKeySession}
  377.  * @extends {shaka.util.FakeEventTarget}
  378.  */
  379. shaka.polyfill.PatchedMediaKeysMs.
  380.     MediaKeySession = function(nativeMediaKeys, sessionType) {
  381.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession');
  382.   shaka.util.FakeEventTarget.call(this);
  384.   // The native MediaKeySession, which will be created in generateRequest.
  385.   /** @private {MSMediaKeySession} */
  386.   this.nativeMediaKeySession_ = null;
  388.   /** @private {MSMediaKeys} */
  389.   this.nativeMediaKeys_ = nativeMediaKeys;
  391.   // Promises that are resolved later
  392.   /** @private {shaka.util.PublicPromise} */
  393.   this.generateRequestPromise_ = null;
  395.   /** @private {shaka.util.PublicPromise} */
  396.   this.updatePromise_ = null;
  398.   /** @private {!shaka.util.EventManager} */
  399.   this.eventManager_ = new shaka.util.EventManager();
  401.   /** @type {string} */
  402.   this.sessionId = '';
  404.   /** @type {number} */
  405.   this.expiration = NaN;
  407.   /** @type {!shaka.util.PublicPromise} */
  408.   this.closed = new shaka.util.PublicPromise();
  410.   /** @type {!shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap} */
  411.   this.keyStatuses =
  412.       new shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap();
  413. };
  414. goog.inherits(shaka.polyfill.PatchedMediaKeysMs.MediaKeySession,
  415.     shaka.util.FakeEventTarget);
  418. /** @override */
  419. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  420.     generateRequest = function(initDataType, initData) {
  421.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.generateRequest');
  423.   this.generateRequestPromise_ = new shaka.util.PublicPromise();
  425.   try {
  426.     // This EME spec version requires a MIME content type as the 1st param
  427.     // to createSession, but doesn't seem to matter what the value is.
  429.     // NOTE: IE11 takes either Uint8Array or ArrayBuffer, but Edge 12 only
  430.     // accepts Uint8Array.
  431.     this.nativeMediaKeySession_ = this.nativeMediaKeys_
  432.         .createSession('video/mp4', new Uint8Array(initData), null);
  434.     // Attach session event handlers here.
  435.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeymessage',
  436.         /** @type {shaka.util.EventManager.ListenerType} */
  437.         (this.onMsKeyMessage_.bind(this)));
  438.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyadded',
  439.         /** @type {shaka.util.EventManager.ListenerType} */
  440.         (this.onMsKeyAdded_.bind(this)));
  441.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyerror',
  442.         /** @type {shaka.util.EventManager.ListenerType} */
  443.         (this.onMsKeyError_.bind(this)));
  445.     this.updateKeyStatus_('status-pending');
  446.   } catch (exception) {
  447.     this.generateRequestPromise_.reject(exception);
  448.   }
  450.   return this.generateRequestPromise_;
  451. };
  454. /** @override */
  455. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  456.     load = function() {
  457.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.load');
  459.   return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  460. };
  463. /** @override */
  464. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  465.     update = function(response) {
  466.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.update');
  468.   this.updatePromise_ = new shaka.util.PublicPromise();
  470.   try {
  471.     // Pass through to the native session.
  472.     // NOTE: IE11 takes either Uint8Array or ArrayBuffer, but Edge 12 only
  473.     // accepts Uint8Array.
  474.     this.nativeMediaKeySession_.update(new Uint8Array(response));
  475.   } catch (exception) {
  476.     this.updatePromise_.reject(exception);
  477.   }
  479.   return this.updatePromise_;
  480. };
  483. /** @override */
  484. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  485.     close = function() {
  486.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.close');
  488.   try {
  489.     // Pass through to the native session.
  490.     // NOTE: IE seems to have a spec discrepancy here - v2010218 should have
  491.     // MediaKeySession.release, but actually uses "close". The next version
  492.     // of the spec is the initial Promise based one, so it's not the target spec
  493.     // either.
  494.     this.nativeMediaKeySession_.close();
  496.     this.closed.resolve();
  497.     this.eventManager_.removeAll();
  498.   } catch (exception) {
  499.     this.closed.reject(exception);
  500.   }
  502.   return this.closed;
  503. };
  506. /** @override */
  507. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  508.     remove = function() {
  509.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.remove');
  511.   return Promise.reject(new Error('MediaKeySession.remove is only ' +
  512.       'applicable for persistent licenses, which are not supported on ' +
  513.       'this platform'));
  514. };
  517. /**
  518.  * Handler for the native media elements msNeedKey event.
  519.  *
  520.  * @this {!HTMLMediaElement}
  521.  * @param {!MediaKeyEvent} event
  522.  * @private
  523.  */
  524. shaka.polyfill.PatchedMediaKeysMs.onMsNeedKey_ = function(event) {
  525.   shaka.log.debug('PatchedMediaKeysMs.onMsNeedKey_', event);
  526.   if (!event.initData) {
  527.     return;
  528.   }
  530.   // Alias
  531.   const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  533.   // NOTE: Because "this" is a real EventTarget, on IE, the event we dispatch
  534.   // here must also be a real Event.
  535.   let event2 = /** @type {!CustomEvent} */(document.createEvent('CustomEvent'));
  536.   event2.initCustomEvent('encrypted', false, false, null);
  537.   event2.initDataType = 'cenc';
  538.   event2.initData = PatchedMediaKeysMs.NormaliseInitData_(event.initData);
  540.   this.dispatchEvent(event2);
  541. };
  544. /**
  545.  * Normalise the initData array. This is to apply browser specific work-arounds,
  546.  * e.g. removing duplicates which appears to occur intermittently when the
  547.  * native msneedkey event fires (i.e. event.initData contains dupes).
  548.  *
  549.  * @param {?Uint8Array} initData
  550.  * @private
  551.  * @return {?Uint8Array}
  552.  */
  553. shaka.polyfill.PatchedMediaKeysMs.
  554.     NormaliseInitData_ = function(initData) {
  555.   if (!initData) {
  556.     return initData;
  557.   }
  559.   let pssh = new shaka.util.Pssh(initData);
  561.   // If there is only a single pssh, return the original array.
  562.   if (pssh.dataBoundaries.length <= 1) {
  563.     return initData;
  564.   }
  566.   let unfilteredInitDatas = [];
  567.   for (let i = 0; i < pssh.dataBoundaries.length; i++) {
  568.     let currPssh = initData.subarray(
  569.         pssh.dataBoundaries[i].start,
  570.         pssh.dataBoundaries[i].end + 1); // End is exclusive, hence the +1.
  572.     unfilteredInitDatas.push(currPssh);
  573.   }
  575.   // Dedupe psshData.
  576.   let dedupedInitDatas = shaka.util.ArrayUtils.removeDuplicates(
  577.       unfilteredInitDatas,
  578.       shaka.polyfill.PatchedMediaKeysMs.compareInitDatas_);
  580.   let targetLength = 0;
  581.   for (let i = 0; i < dedupedInitDatas.length; i++) {
  582.     targetLength += dedupedInitDatas[i].length;
  583.   }
  585.   // Flatten the array of Uint8Arrays back into a single Uint8Array.
  586.   let normalisedInitData = new Uint8Array(targetLength);
  587.   let offset = 0;
  588.   for (let i = 0; i < dedupedInitDatas.length; i++) {
  589.     normalisedInitData.set(dedupedInitDatas[i], offset);
  590.     offset += dedupedInitDatas[i].length;
  591.   }
  593.   return normalisedInitData;
  594. };
  597. /**
  598.  * @param {!Uint8Array} initDataA
  599.  * @param {!Uint8Array} initDataB
  600.  * @return {boolean}
  601.  * @private
  602.  */
  603. shaka.polyfill.PatchedMediaKeysMs.compareInitDatas_ =
  604.     function(initDataA, initDataB) {
  605.   return shaka.util.Uint8ArrayUtils.equal(initDataA, initDataB);
  606. };
  609. /**
  610.  * Handler for the native keymessage event on MSMediaKeySession.
  611.  *
  612.  * @param {!MediaKeyEvent} event
  613.  * @private
  614.  */
  615. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  616.     onMsKeyMessage_ = function(event) {
  617.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyMessage_', event);
  619.   // We can now resolve this.generateRequestPromise, which should be non-null.
  620.   goog.asserts.assert(this.generateRequestPromise_,
  621.                       'generateRequestPromise_ not set in onMsKeyMessage_');
  622.   if (this.generateRequestPromise_) {
  623.     this.generateRequestPromise_.resolve();
  624.     this.generateRequestPromise_ = null;
  625.   }
  627.   let isNew = this.keyStatuses.getStatus() == undefined;
  629.   let event2 = new shaka.util.FakeEvent('message', {
  630.     messageType: isNew ? 'license-request' : 'license-renewal',
  631.     message: event.message.buffer,
  632.   });
  634.   this.dispatchEvent(event2);
  635. };
  638. /**
  639.  * Handler for the native keyadded event on MSMediaKeySession.
  640.  *
  641.  * @param {!MediaKeyEvent} event
  642.  * @private
  643.  */
  644. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  645.     onMsKeyAdded_ = function(event) {
  646.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyAdded_', event);
  648.   // PlayReady's concept of persistent licenses makes emulation difficult here.
  649.   // A license policy can say that the license persists, which causes the CDM to
  650.   // store it for use in a later session.  The result is that in IE11, the CDM
  651.   // fires 'mskeyadded' without ever firing 'mskeymessage'.
  652.   if (this.generateRequestPromise_) {
  653.     shaka.log.debug('Simulating completion for a PR persistent license.');
  654.     goog.asserts.assert(!this.updatePromise_,
  655.         'updatePromise_ and generateRequestPromise_ set in onMsKeyAdded_');
  656.     this.updateKeyStatus_('usable');
  657.     this.generateRequestPromise_.resolve();
  658.     this.generateRequestPromise_ = null;
  659.     return;
  660.   }
  662.   // We can now resolve this.updatePromise, which should be non-null.
  663.   goog.asserts.assert(this.updatePromise_,
  664.                       'updatePromise_ not set in onMsKeyAdded_');
  665.   if (this.updatePromise_) {
  666.     this.updateKeyStatus_('usable');
  667.     this.updatePromise_.resolve();
  668.     this.updatePromise_ = null;
  669.   }
  670. };
  673. /**
  674.  * Handler for the native keyerror event on MSMediaKeySession.
  675.  *
  676.  * @param {!MediaKeyEvent} event
  677.  * @private
  678.  */
  679. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  680.     onMsKeyError_ = function(event) {
  681.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyError_', event);
  683.   let error = new Error('EME PatchedMediaKeysMs key error');
  684.   error.errorCode = this.nativeMediaKeySession_.error;
  686.   if (this.generateRequestPromise_ != null) {
  687.     this.generateRequestPromise_.reject(error);
  688.     this.generateRequestPromise_ = null;
  689.   } else if (this.updatePromise_ != null) {
  690.     this.updatePromise_.reject(error);
  691.     this.updatePromise_ = null;
  692.   } else {
  693.     // Unexpected error - map native codes to standardised key statuses.
  694.     // Possible values of this.nativeMediaKeySession_.error.code:
  695.     // MS_MEDIA_KEYERR_UNKNOWN        = 1
  696.     // MS_MEDIA_KEYERR_CLIENT         = 2
  697.     // MS_MEDIA_KEYERR_SERVICE        = 3
  698.     // MS_MEDIA_KEYERR_OUTPUT         = 4
  699.     // MS_MEDIA_KEYERR_HARDWARECHANGE = 5
  700.     // MS_MEDIA_KEYERR_DOMAIN         = 6
  702.     switch (this.nativeMediaKeySession_.error.code) {
  703.       case MSMediaKeyError.MS_MEDIA_KEYERR_OUTPUT:
  704.       case MSMediaKeyError.MS_MEDIA_KEYERR_HARDWARECHANGE:
  705.         this.updateKeyStatus_('output-not-allowed');
  706.         break;
  707.       default:
  708.         this.updateKeyStatus_('internal-error');
  709.         break;
  710.     }
  711.   }
  712. };
  715. /**
  716.  * Updates key status and dispatch a 'keystatuseschange' event.
  717.  *
  718.  * @param {string} status
  719.  * @private
  720.  */
  721. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  722.     updateKeyStatus_ = function(status) {
  723.   this.keyStatuses.setStatus(status);
  724.   let event = new shaka.util.FakeEvent('keystatuseschange');
  725.   this.dispatchEvent(event);
  726. };
  730. /**
  731.  * An implementation of MediaKeyStatusMap.
  732.  * This fakes a map with a single key ID.
  733.  *
  734.  * @constructor
  735.  * @struct
  736.  * @implements {MediaKeyStatusMap}
  737.  */
  738. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap = function() {
  739.   /**
  740.    * @type {number}
  741.    */
  742.   this.size = 0;
  744.   /**
  745.    * @private {string|undefined}
  746.    */
  747.   this.status_ = undefined;
  748. };
  751. /**
  752.  * @const {!ArrayBuffer}
  753.  * @private
  754.  */
  755. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  758. /**
  759.  * An internal method used by the session to set key status.
  760.  * @param {string|undefined} status
  761.  */
  762. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  763.     setStatus = function(status) {
  764.   this.size = status == undefined ? 0 : 1;
  765.   this.status_ = status;
  766. };
  769. /**
  770.  * An internal method used by the session to get key status.
  771.  * @return {string|undefined}
  772.  */
  773. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  774.     getStatus = function() {
  775.   return this.status_;
  776. };
  779. /** @override */
  780. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  781.     forEach = function(fn) {
  782.   if (this.status_) {
  783.     let fakeKeyId =
  784.         shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  785.     fn(this.status_, fakeKeyId);
  786.   }
  787. };
  790. /** @override */
  791. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  792.     get = function(keyId) {
  793.   if (this.has(keyId)) {
  794.     return this.status_;
  795.   }
  796.   return undefined;
  797. };
  800. /** @override */
  801. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  802.     has = function(keyId) {
  803.   let fakeKeyId =
  804.       shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  805.   if (this.status_ &&
  806.       shaka.util.Uint8ArrayUtils.equal(
  807.           new Uint8Array(keyId), new Uint8Array(fakeKeyId))) {
  808.     return true;
  809.   }
  810.   return false;
  811. };
  814. /**
  815.  * @suppress {missingReturn}
  816.  * @override
  817.  */
  818. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  819.     entries = function() {
  820.   goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  821. };
  824. /**
  825.  * @suppress {missingReturn}
  826.  * @override
  827.  */
  828. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  829.     keys = function() {
  830.   goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  831. };
  834. /**
  835.  * @suppress {missingReturn}
  836.  * @override
  837.  */
  838. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  839.     values = function() {
  840.   goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  841. };
  844. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysMs.install);