Source: lib/polyfill/patchedmediakeys_ms.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.PatchedMediaKeysMs');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.media.DrmEngine');
  12. goog.require('shaka.polyfill');
  13. goog.require('shaka.util.BufferUtils');
  14. goog.require('shaka.util.EventManager');
  15. goog.require('shaka.util.FakeEvent');
  16. goog.require('shaka.util.FakeEventTarget');
  17. goog.require('shaka.util.MediaReadyState');
  18. goog.require('shaka.util.Pssh');
  19. goog.require('shaka.util.PublicPromise');
  22. /**
  23.  * @summary A polyfill to implement
  24.  * {@link https://bit.ly/EmeMar15 EME draft 12 March 2015}
  25.  * on top of ms-prefixed
  26.  * {@link https://www.w3.org/TR/2014/WD-encrypted-media-20140218/ EME v20140218}
  27.  * @export
  28.  */
  29. shaka.polyfill.PatchedMediaKeysMs = class {
  30.   /**
  31.    * Installs the polyfill if needed.
  32.    * @export
  33.    */
  34.   static install() {
  35.     if (!window.HTMLVideoElement || !window.MSMediaKeys ||
  36.         (navigator.requestMediaKeySystemAccess &&
  37.          // eslint-disable-next-line no-restricted-syntax
  38.          MediaKeySystemAccess.prototype.getConfiguration)) {
  39.       return;
  40.     }
  41.     shaka.log.info('Using ms-prefixed EME v20140218');
  43.     // Alias
  44.     const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  46.     // Delete mediaKeys to work around strict mode compatibility issues.
  47.     // eslint-disable-next-line no-restricted-syntax
  48.     delete HTMLMediaElement.prototype['mediaKeys'];
  49.     // Work around read-only declaration for mediaKeys by using a string.
  50.     // eslint-disable-next-line no-restricted-syntax
  51.     HTMLMediaElement.prototype['mediaKeys'] = null;
  53.     // Install patches
  54.     window.MediaKeys = PatchedMediaKeysMs.MediaKeys;
  55.     window.MediaKeySystemAccess = PatchedMediaKeysMs.MediaKeySystemAccess;
  56.     navigator.requestMediaKeySystemAccess =
  57.         PatchedMediaKeysMs.requestMediaKeySystemAccess;
  58.     // eslint-disable-next-line no-restricted-syntax
  59.     HTMLMediaElement.prototype.setMediaKeys =
  60.         PatchedMediaKeysMs.MediaKeySystemAccess.setMediaKeys;
  61.   }
  63.   /**
  64.    * An implementation of navigator.requestMediaKeySystemAccess.
  65.    * Retrieves a MediaKeySystemAccess object.
  66.    *
  67.    * @this {!Navigator}
  68.    * @param {string} keySystem
  69.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  70.    * @return {!Promise.<!MediaKeySystemAccess>}
  71.    */
  72.   static requestMediaKeySystemAccess(keySystem, supportedConfigurations) {
  73.     shaka.log.debug('PatchedMediaKeysMs.requestMediaKeySystemAccess');
  74.     goog.asserts.assert(this == navigator,
  75.         'bad "this" for requestMediaKeySystemAccess');
  77.     // Alias.
  78.     const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  79.     try {
  80.       const access = new PatchedMediaKeysMs.MediaKeySystemAccess(
  81.           keySystem, supportedConfigurations);
  82.       return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  83.     } catch (exception) {
  84.       return Promise.reject(exception);
  85.     }
  86.   }
  88.   /**
  89.    * Handler for the native media elements msNeedKey event.
  90.    *
  91.    * @this {!HTMLMediaElement}
  92.    * @param {!MediaKeyEvent} event
  93.    * @suppress {constantProperty} We reassign what would be const on a real
  94.    *   MediaEncryptedEvent, but in our look-alike event.
  95.    * @private
  96.    */
  97.   static onMsNeedKey_(event) {
  98.     shaka.log.debug('PatchedMediaKeysMs.onMsNeedKey_', event);
  99.     if (!event.initData) {
  100.       return;
  101.     }
  103.     const event2 = new CustomEvent('encrypted');
  104.     const encryptedEvent =
  105.       /** @type {!MediaEncryptedEvent} */(/** @type {?} */(event2));
  106.     encryptedEvent.initDataType = 'cenc';
  107.     encryptedEvent.initData = shaka.util.BufferUtils.toArrayBuffer(
  108.         shaka.util.Pssh.normaliseInitData(event.initData));
  110.     this.dispatchEvent(event2);
  111.   }
  112. };
  115. /**
  116.  * An implementation of MediaKeySystemAccess.
  117.  *
  118.  * @implements {MediaKeySystemAccess}
  119.  */
  120. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess = class {
  121.   /**
  122.    * @param {string} keySystem
  123.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  124.    */
  125.   constructor(keySystem, supportedConfigurations) {
  126.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess');
  128.     /** @type {string} */
  129.     this.keySystem = keySystem;
  131.     /** @private {!MediaKeySystemConfiguration} */
  132.     this.configuration_;
  134.     const allowPersistentState = false;
  136.     let success = false;
  137.     for (const cfg of supportedConfigurations) {
  138.       // Create a new config object and start adding in the pieces which we
  139.       // find support for.  We will return this from getConfiguration() if
  140.       // asked.
  141.       /** @type {!MediaKeySystemConfiguration} */
  142.       const newCfg = {
  143.         'audioCapabilities': [],
  144.         'videoCapabilities': [],
  145.         // It is technically against spec to return these as optional, but we
  146.         // don't truly know their values from the prefixed API:
  147.         'persistentState': 'optional',
  148.         'distinctiveIdentifier': 'optional',
  149.         // Pretend the requested init data types are supported, since we don't
  150.         // really know that either:
  151.         'initDataTypes': cfg.initDataTypes,
  152.         'sessionTypes': ['temporary'],
  153.         'label': cfg.label,
  154.       };
  156.       // PatchedMediaKeysMs tests for key system availability through
  157.       // MSMediaKeys.isTypeSupported
  158.       let ranAnyTests = false;
  159.       if (cfg.audioCapabilities) {
  160.         for (const cap of cfg.audioCapabilities) {
  161.           if (cap.contentType) {
  162.             ranAnyTests = true;
  163.             const contentType = cap.contentType.split(';')[0];
  164.             if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  165.               newCfg.audioCapabilities.push(cap);
  166.               success = true;
  167.             }
  168.           }
  169.         }
  170.       }
  171.       if (cfg.videoCapabilities) {
  172.         for (const cap of cfg.videoCapabilities) {
  173.           if (cap.contentType) {
  174.             ranAnyTests = true;
  175.             const contentType = cap.contentType.split(';')[0];
  176.             if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  177.               newCfg.videoCapabilities.push(cap);
  178.               success = true;
  179.             }
  180.           }
  181.         }
  182.       }
  184.       if (!ranAnyTests) {
  185.         // If no specific types were requested, we check all common types to
  186.         // find out if the key system is present at all.
  187.         success = MSMediaKeys.isTypeSupported(this.keySystem, 'video/mp4');
  188.       }
  189.       if (cfg.persistentState == 'required') {
  190.         if (allowPersistentState) {
  191.           newCfg.persistentState = 'required';
  192.           newCfg.sessionTypes = ['persistent-license'];
  193.         } else {
  194.           success = false;
  195.         }
  196.       }
  198.       if (success) {
  199.         this.configuration_ = newCfg;
  200.         return;
  201.       }
  202.     }  // for each cfg in supportedConfigurations
  204.     // According to the spec, this should be a DOMException, but there is not a
  205.     // public constructor for that.  So we make this look-alike instead.
  206.     const unsupportedKeySystemError = new Error('Unsupported keySystem');
  207.     unsupportedKeySystemError.name = 'NotSupportedError';
  208.     unsupportedKeySystemError['code'] = DOMException.NOT_SUPPORTED_ERR;
  209.     throw unsupportedKeySystemError;
  210.   }
  212.   /** @override */
  213.   createMediaKeys() {
  214.     shaka.log.debug(
  215.         'PatchedMediaKeysMs.MediaKeySystemAccess.createMediaKeys');
  217.     // Alias
  218.     const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  220.     const mediaKeys = new PatchedMediaKeysMs.MediaKeys(this.keySystem);
  221.     return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  222.   }
  224.   /** @override */
  225.   getConfiguration() {
  226.     shaka.log.debug(
  227.         'PatchedMediaKeysMs.MediaKeySystemAccess.getConfiguration');
  228.     return this.configuration_;
  229.   }
  231.   /**
  232.    * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  233.    * Attaches a MediaKeys object to the media element.
  234.    *
  235.    * @this {!HTMLMediaElement}
  236.    * @param {MediaKeys} mediaKeys
  237.    * @return {!Promise}
  238.    */
  239.   static setMediaKeys(mediaKeys) {
  240.     shaka.log.debug('PatchedMediaKeysMs.setMediaKeys');
  241.     goog.asserts.assert(this instanceof HTMLMediaElement,
  242.         'bad "this" for setMediaKeys');
  244.     // Alias
  245.     const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  247.     const newMediaKeys =
  248.     /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  249.         mediaKeys);
  250.     const oldMediaKeys =
  251.     /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  252.         this.mediaKeys);
  254.     if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  255.       goog.asserts.assert(oldMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  256.           'non-polyfill instance of oldMediaKeys');
  257.       // Have the old MediaKeys stop listening to events on the video tag.
  258.       oldMediaKeys.setMedia(null);
  259.     }
  261.     delete this['mediaKeys'];  // in case there is an existing getter
  262.     this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  264.     if (newMediaKeys) {
  265.       goog.asserts.assert(newMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  266.           'non-polyfill instance of newMediaKeys');
  267.       return newMediaKeys.setMedia(this);
  268.     }
  270.     return Promise.resolve();
  271.   }
  272. };
  275. /**
  276.  * An implementation of MediaKeys.
  277.  *
  278.  * @implements {MediaKeys}
  279.  */
  280. shaka.polyfill.PatchedMediaKeysMs.MediaKeys = class {
  281.   /** @param {string} keySystem */
  282.   constructor(keySystem) {
  283.     shaka.log.debug('PatchedMediaKeysMs.MediaKeys');
  285.     /** @private {!MSMediaKeys} */
  286.     this.nativeMediaKeys_ = new MSMediaKeys(keySystem);
  288.     /** @private {!shaka.util.EventManager} */
  289.     this.eventManager_ = new shaka.util.EventManager();
  290.   }
  292.   /** @override */
  293.   createSession(sessionType) {
  294.     shaka.log.debug('PatchedMediaKeysMs.MediaKeys.createSession');
  296.     sessionType = sessionType || 'temporary';
  297.     // For now, only the 'temporary' type is supported.
  298.     if (sessionType != 'temporary') {
  299.       throw new TypeError('Session type ' + sessionType +
  300.       ' is unsupported on this platform.');
  301.     }
  303.     // Alias
  304.     const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  306.     return new PatchedMediaKeysMs.MediaKeySession(
  307.         this.nativeMediaKeys_, sessionType);
  308.   }
  310.   /** @override */
  311.   setServerCertificate(serverCertificate) {
  312.     shaka.log.debug('PatchedMediaKeysMs.MediaKeys.setServerCertificate');
  314.     // There is no equivalent in PatchedMediaKeysMs, so return failure.
  315.     return Promise.resolve(false);
  316.   }
  318.   /**
  319.    * @param {HTMLMediaElement} media
  320.    * @protected
  321.    * @return {!Promise}
  322.    */
  323.   setMedia(media) {
  324.     // Alias
  325.     const PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  327.     // Remove any old listeners.
  328.     this.eventManager_.removeAll();
  330.     // It is valid for media to be null; null is used to flag that event
  331.     // handlers need to be cleaned up.
  332.     if (!media) {
  333.       return Promise.resolve();
  334.     }
  336.     // Intercept and translate these prefixed EME events.
  337.     this.eventManager_.listen(media, 'msneedkey',
  338.     /** @type {shaka.util.EventManager.ListenerType} */
  339.         (PatchedMediaKeysMs.onMsNeedKey_));
  341.     // Wrap native HTMLMediaElement.msSetMediaKeys with a Promise.
  342.     try {
  343.       // Edge requires that readyState >=1 before mediaKeys can be set,
  344.       // so check this and wait for loadedmetadata if we are not in the
  345.       // correct state
  346.       shaka.util.MediaReadyState.waitForReadyState(media,
  347.           HTMLMediaElement.HAVE_METADATA,
  348.           this.eventManager_, () => {
  349.             media.msSetMediaKeys(this.nativeMediaKeys_);
  350.           });
  352.       return Promise.resolve();
  353.     } catch (exception) {
  354.       return Promise.reject(exception);
  355.     }
  356.   }
  357. };
  360. /**
  361.  * An implementation of MediaKeySession.
  362.  *
  363.  * @implements {MediaKeySession}
  364.  */
  365. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession =
  366. class extends shaka.util.FakeEventTarget {
  367.   /**
  368.    * @param {MSMediaKeys} nativeMediaKeys
  369.    * @param {string} sessionType
  370.    */
  371.   constructor(nativeMediaKeys, sessionType) {
  372.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySession');
  373.     super();
  375.     /**
  376.      * The native MediaKeySession, which will be created in generateRequest.
  377.      * @private {MSMediaKeySession}
  378.      */
  379.     this.nativeMediaKeySession_ = null;
  381.     /** @private {MSMediaKeys} */
  382.     this.nativeMediaKeys_ = nativeMediaKeys;
  384.     // Promises that are resolved later
  385.     /** @private {shaka.util.PublicPromise} */
  386.     this.generateRequestPromise_ = null;
  388.     /** @private {shaka.util.PublicPromise} */
  389.     this.updatePromise_ = null;
  391.     /** @private {!shaka.util.EventManager} */
  392.     this.eventManager_ = new shaka.util.EventManager();
  394.     /** @type {string} */
  395.     this.sessionId = '';
  397.     /** @type {number} */
  398.     this.expiration = NaN;
  400.     /** @type {!shaka.util.PublicPromise} */
  401.     this.closed = new shaka.util.PublicPromise();
  403.     /** @type {!shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap} */
  404.     this.keyStatuses =
  405.         new shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap();
  406.   }
  408.   /** @override */
  409.   generateRequest(initDataType, initData) {
  410.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.generateRequest');
  412.     this.generateRequestPromise_ = new shaka.util.PublicPromise();
  414.     try {
  415.       // This EME spec version requires a MIME content type as the 1st param to
  416.       // createSession, but doesn't seem to matter what the value is.
  418.       // NOTE: Edge 12 only accepts Uint8Array.
  419.       this.nativeMediaKeySession_ = this.nativeMediaKeys_.createSession(
  420.           'video/mp4', shaka.util.BufferUtils.toUint8(initData), null);
  422.       // Attach session event handlers here.
  423.       this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeymessage',
  424.       /** @type {shaka.util.EventManager.ListenerType} */
  425.           ((event) => this.onMsKeyMessage_(event)));
  426.       this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyadded',
  427.       /** @type {shaka.util.EventManager.ListenerType} */
  428.           ((event) => this.onMsKeyAdded_(event)));
  429.       this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyerror',
  430.       /** @type {shaka.util.EventManager.ListenerType} */
  431.           ((event) => this.onMsKeyError_(event)));
  433.       this.updateKeyStatus_('status-pending');
  434.     } catch (exception) {
  435.       this.generateRequestPromise_.reject(exception);
  436.     }
  438.     return this.generateRequestPromise_;
  439.   }
  441.   /** @override */
  442.   load() {
  443.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.load');
  445.     return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  446.   }
  448.   /** @override */
  449.   update(response) {
  450.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.update');
  452.     this.updatePromise_ = new shaka.util.PublicPromise();
  454.     try {
  455.       // Pass through to the native session.
  456.       // NOTE: Edge 12 only accepts Uint8Array.
  457.       this.nativeMediaKeySession_.update(
  458.           shaka.util.BufferUtils.toUint8(response));
  459.     } catch (exception) {
  460.       this.updatePromise_.reject(exception);
  461.     }
  463.     return this.updatePromise_;
  464.   }
  466.   /** @override */
  467.   close() {
  468.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.close');
  470.     try {
  471.       // Pass through to the native session.
  472.       // NOTE: IE seems to have a spec discrepancy here - v2010218 should have
  473.       // MediaKeySession.release, but actually uses "close". The next version of
  474.       // the spec is the initial Promise based one, so it's not the target spec
  475.       // either.
  476.       this.nativeMediaKeySession_.close();
  478.       this.closed.resolve();
  479.       this.eventManager_.removeAll();
  480.     } catch (exception) {
  481.       this.closed.reject(exception);
  482.     }
  484.     return this.closed;
  485.   }
  487.   /** @override */
  488.   remove() {
  489.     shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.remove');
  491.     return Promise.reject(new Error(
  492.         'MediaKeySession.remove is only applicable for persistent licenses, ' +
  493.         'which are not supported on this platform'));
  494.   }
  496.   /**
  497.    * Handler for the native keymessage event on MSMediaKeySession.
  498.    *
  499.    * @param {!MediaKeyEvent} event
  500.    * @private
  501.    */
  502.   onMsKeyMessage_(event) {
  503.     shaka.log.debug('PatchedMediaKeysMs.onMsKeyMessage_', event);
  505.     // We can now resolve this.generateRequestPromise, which should be non-null.
  506.     goog.asserts.assert(this.generateRequestPromise_,
  507.         'generateRequestPromise_ not set in onMsKeyMessage_');
  508.     if (this.generateRequestPromise_) {
  509.       this.generateRequestPromise_.resolve();
  510.       this.generateRequestPromise_ = null;
  511.     }
  513.     const isNew = this.keyStatuses.getStatus() == undefined;
  515.     const data = new Map()
  516.         .set('messageType', isNew ? 'license-request' : 'license-renewal')
  517.         .set('message', shaka.util.BufferUtils.toArrayBuffer(event.message));
  518.     const event2 = new shaka.util.FakeEvent('message', data);
  520.     this.dispatchEvent(event2);
  521.   }
  523.   /**
  524.    * Handler for the native keyadded event on MSMediaKeySession.
  525.    *
  526.    * @param {!MediaKeyEvent} event
  527.    * @private
  528.    */
  529.   onMsKeyAdded_(event) {
  530.     shaka.log.debug('PatchedMediaKeysMs.onMsKeyAdded_', event);
  532.     // PlayReady's concept of persistent licenses makes emulation difficult
  533.     // here. A license policy can say that the license persists, which causes
  534.     // the CDM to store it for use in a later session.  The result is that in
  535.     // IE11, the CDM fires 'mskeyadded' without ever firing 'mskeymessage'.
  536.     if (this.generateRequestPromise_) {
  537.       shaka.log.debug('Simulating completion for a PR persistent license.');
  538.       goog.asserts.assert(!this.updatePromise_,
  539.           'updatePromise_ and generateRequestPromise_ set in onMsKeyAdded_');
  540.       this.updateKeyStatus_('usable');
  541.       this.generateRequestPromise_.resolve();
  542.       this.generateRequestPromise_ = null;
  543.       return;
  544.     }
  546.     // We can now resolve this.updatePromise, which should be non-null.
  547.     goog.asserts.assert(this.updatePromise_,
  548.         'updatePromise_ not set in onMsKeyAdded_');
  549.     if (this.updatePromise_) {
  550.       this.updateKeyStatus_('usable');
  551.       this.updatePromise_.resolve();
  552.       this.updatePromise_ = null;
  553.     }
  554.   }
  556.   /**
  557.    * Handler for the native keyerror event on MSMediaKeySession.
  558.    *
  559.    * @param {!MediaKeyEvent} event
  560.    * @private
  561.    */
  562.   onMsKeyError_(event) {
  563.     shaka.log.debug('PatchedMediaKeysMs.onMsKeyError_', event);
  565.     const error = new Error('EME PatchedMediaKeysMs key error');
  566.     error['errorCode'] = this.nativeMediaKeySession_.error;
  568.     if (this.generateRequestPromise_ != null) {
  569.       this.generateRequestPromise_.reject(error);
  570.       this.generateRequestPromise_ = null;
  571.     } else if (this.updatePromise_ != null) {
  572.       this.updatePromise_.reject(error);
  573.       this.updatePromise_ = null;
  574.     } else {
  575.       // Unexpected error - map native codes to standardised key statuses.
  576.       // Possible values of this.nativeMediaKeySession_.error.code:
  577.       // MS_MEDIA_KEYERR_UNKNOWN        = 1
  578.       // MS_MEDIA_KEYERR_CLIENT         = 2
  579.       // MS_MEDIA_KEYERR_SERVICE        = 3
  580.       // MS_MEDIA_KEYERR_OUTPUT         = 4
  581.       // MS_MEDIA_KEYERR_HARDWARECHANGE = 5
  582.       // MS_MEDIA_KEYERR_DOMAIN         = 6
  584.       switch (this.nativeMediaKeySession_.error.code) {
  585.         case MSMediaKeyError.MS_MEDIA_KEYERR_OUTPUT:
  586.         case MSMediaKeyError.MS_MEDIA_KEYERR_HARDWARECHANGE:
  587.           this.updateKeyStatus_('output-not-allowed');
  588.           break;
  589.         default:
  590.           this.updateKeyStatus_('internal-error');
  591.           break;
  592.       }
  593.     }
  594.   }
  596.   /**
  597.    * Updates key status and dispatch a 'keystatuseschange' event.
  598.    *
  599.    * @param {string} status
  600.    * @private
  601.    */
  602.   updateKeyStatus_(status) {
  603.     this.keyStatuses.setStatus(status);
  604.     const event = new shaka.util.FakeEvent('keystatuseschange');
  605.     this.dispatchEvent(event);
  606.   }
  607. };
  610. /**
  611.  * @summary An implementation of MediaKeyStatusMap.
  612.  * This fakes a map with a single key ID.
  613.  *
  614.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  615.  * @implements {MediaKeyStatusMap}
  616.  */
  617. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap = class {
  618.   /** */
  619.   constructor() {
  620.     /**
  621.      * @type {number}
  622.      */
  623.     this.size = 0;
  625.     /**
  626.      * @private {string|undefined}
  627.      */
  628.     this.status_ = undefined;
  629.   }
  631.   /**
  632.    * An internal method used by the session to set key status.
  633.    * @param {string|undefined} status
  634.    */
  635.   setStatus(status) {
  636.     this.size = status == undefined ? 0 : 1;
  637.     this.status_ = status;
  638.   }
  640.   /**
  641.    * An internal method used by the session to get key status.
  642.    * @return {string|undefined}
  643.    */
  644.   getStatus() {
  645.     return this.status_;
  646.   }
  648.   /** @override */
  649.   forEach(fn) {
  650.     if (this.status_) {
  651.       fn(this.status_, shaka.media.DrmEngine.DUMMY_KEY_ID.value());
  652.     }
  653.   }
  655.   /** @override */
  656.   get(keyId) {
  657.     if (this.has(keyId)) {
  658.       return this.status_;
  659.     }
  660.     return undefined;
  661.   }
  663.   /** @override */
  664.   has(keyId) {
  665.     const fakeKeyId = shaka.media.DrmEngine.DUMMY_KEY_ID.value();
  666.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  667.       return true;
  668.     }
  669.     return false;
  670.   }
  672.   /**
  673.    * @suppress {missingReturn}
  674.    * @override
  675.    */
  676.   entries() {
  677.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  678.   }
  680.   /**
  681.    * @suppress {missingReturn}
  682.    * @override
  683.    */
  684.   keys() {
  685.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  686.   }
  688.   /**
  689.    * @suppress {missingReturn}
  690.    * @override
  691.    */
  692.   values() {
  693.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  694.   }
  695. };
  698. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysMs.install);