Source: lib/polyfill/patchedmediakeys_apple.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.PatchedMediaKeysApple');
  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.PublicPromise');
  19. goog.require('shaka.util.StringUtils');
  22. /**
  23.  * @summary A polyfill to implement modern, standardized EME on top of Apple's
  24.  * prefixed EME in Safari.
  25.  * @export
  26.  */
  27. shaka.polyfill.PatchedMediaKeysApple = class {
  28.   /**
  29.    * Installs the polyfill if needed.
  30.    * @param {boolean=} enableUninstall enables uninstalling the polyfill
  31.    * @export
  32.    */
  33.   static install(enableUninstall = false) {
  34.     // Alias
  35.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  37.     if (!window.HTMLVideoElement || !window.WebKitMediaKeys) {
  38.       // No HTML5 video or no prefixed EME.
  39.       return;
  40.     }
  42.     if (enableUninstall) {
  43.       PatchedMediaKeysApple.enableUninstall = true;
  44.       PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys =
  45.         /** @type {!Object} */ (
  46.           Object.getOwnPropertyDescriptor(
  47.               // eslint-disable-next-line no-restricted-syntax
  48.               HTMLMediaElement.prototype, 'mediaKeys',
  49.           )
  50.         );
  51.       PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys =
  52.           // eslint-disable-next-line no-restricted-syntax
  53.           HTMLMediaElement.prototype.setMediaKeys;
  54.       PatchedMediaKeysApple.originalWindowMediaKeys = window.MediaKeys;
  55.       PatchedMediaKeysApple.originalWindowMediaKeySystemAccess =
  56.           window.MediaKeySystemAccess;
  57.       PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess =
  58.           navigator.requestMediaKeySystemAccess;
  59.     }
  61.     shaka.log.info('Using Apple-prefixed EME');
  63.     // Delete mediaKeys to work around strict mode compatibility issues.
  64.     // eslint-disable-next-line no-restricted-syntax
  65.     delete HTMLMediaElement.prototype['mediaKeys'];
  66.     // Work around read-only declaration for mediaKeys by using a string.
  67.     // eslint-disable-next-line no-restricted-syntax
  68.     HTMLMediaElement.prototype['mediaKeys'] = null;
  69.     // eslint-disable-next-line no-restricted-syntax
  70.     HTMLMediaElement.prototype.setMediaKeys =
  71.         PatchedMediaKeysApple.setMediaKeys;
  73.     // Install patches
  74.     window.MediaKeys = PatchedMediaKeysApple.MediaKeys;
  75.     window.MediaKeySystemAccess = PatchedMediaKeysApple.MediaKeySystemAccess;
  76.     navigator.requestMediaKeySystemAccess =
  77.         PatchedMediaKeysApple.requestMediaKeySystemAccess;
  79.     window.shakaMediaKeysPolyfill = true;
  80.   }
  82.   /**
  83.    * Uninstalls the polyfill if needed and enabled.
  84.    * @export
  85.    */
  86.   static uninstall() {
  87.     // Alias
  88.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  90.     if (!PatchedMediaKeysApple.enableUninstall) {
  91.       return;
  92.     }
  94.     shaka.log.info('Un-installing Apple-prefixed EME');
  96.     PatchedMediaKeysApple.enableUninstall = false;
  97.     Object.defineProperty(
  98.         // eslint-disable-next-line no-restricted-syntax
  99.         HTMLMediaElement.prototype,
  100.         'mediaKeys',
  101.         PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys,
  102.     );
  103.     // eslint-disable-next-line no-restricted-syntax
  104.     HTMLMediaElement.prototype.setMediaKeys =
  105.         PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys;
  106.     window.MediaKeys = PatchedMediaKeysApple.originalWindowMediaKeys;
  107.     window.MediaKeySystemAccess =
  108.         PatchedMediaKeysApple.originalWindowMediaKeySystemAccess;
  109.     navigator.requestMediaKeySystemAccess =
  110.         PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess;
  112.     PatchedMediaKeysApple.originalWindowMediaKeys = null;
  113.     PatchedMediaKeysApple.originalWindowMediaKeySystemAccess = null;
  114.     PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys = null;
  115.     PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess = null;
  116.     PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys = null;
  118.     window.shakaMediaKeysPolyfill = false;
  119.   }
  121.   /**
  122.    * An implementation of navigator.requestMediaKeySystemAccess.
  123.    * Retrieves a MediaKeySystemAccess object.
  124.    *
  125.    * @this {!Navigator}
  126.    * @param {string} keySystem
  127.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  128.    * @return {!Promise.<!MediaKeySystemAccess>}
  129.    */
  130.   static requestMediaKeySystemAccess(keySystem, supportedConfigurations) {
  131.     shaka.log.debug('PatchedMediaKeysApple.requestMediaKeySystemAccess');
  132.     goog.asserts.assert(this == navigator,
  133.         'bad "this" for requestMediaKeySystemAccess');
  135.     // Alias.
  136.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  137.     try {
  138.       const access = new PatchedMediaKeysApple.MediaKeySystemAccess(
  139.           keySystem, supportedConfigurations);
  140.       return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  141.     } catch (exception) {
  142.       return Promise.reject(exception);
  143.     }
  144.   }
  146.   /**
  147.    * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  148.    * Attaches a MediaKeys object to the media element.
  149.    *
  150.    * @this {!HTMLMediaElement}
  151.    * @param {MediaKeys} mediaKeys
  152.    * @return {!Promise}
  153.    */
  154.   static setMediaKeys(mediaKeys) {
  155.     shaka.log.debug('PatchedMediaKeysApple.setMediaKeys');
  156.     goog.asserts.assert(this instanceof HTMLMediaElement,
  157.         'bad "this" for setMediaKeys');
  159.     // Alias
  160.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  162.     const newMediaKeys =
  163.     /** @type {shaka.polyfill.PatchedMediaKeysApple.MediaKeys} */ (
  164.         mediaKeys);
  165.     const oldMediaKeys =
  166.     /** @type {shaka.polyfill.PatchedMediaKeysApple.MediaKeys} */ (
  167.         this.mediaKeys);
  169.     if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  170.       goog.asserts.assert(
  171.           oldMediaKeys instanceof PatchedMediaKeysApple.MediaKeys,
  172.           'non-polyfill instance of oldMediaKeys');
  173.       // Have the old MediaKeys stop listening to events on the video tag.
  174.       oldMediaKeys.setMedia(null);
  175.     }
  177.     delete this['mediaKeys'];  // in case there is an existing getter
  178.     this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  180.     if (newMediaKeys) {
  181.       goog.asserts.assert(
  182.           newMediaKeys instanceof PatchedMediaKeysApple.MediaKeys,
  183.           'non-polyfill instance of newMediaKeys');
  184.       return newMediaKeys.setMedia(this);
  185.     }
  187.     return Promise.resolve();
  188.   }
  190.   /**
  191.    * Handler for the native media elements webkitneedkey event.
  192.    *
  193.    * @this {!HTMLMediaElement}
  194.    * @param {!MediaKeyEvent} event
  195.    * @suppress {constantProperty} We reassign what would be const on a real
  196.    *   MediaEncryptedEvent, but in our look-alike event.
  197.    * @private
  198.    */
  199.   static onWebkitNeedKey_(event) {
  200.     shaka.log.debug('PatchedMediaKeysApple.onWebkitNeedKey_', event);
  202.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  203.     const mediaKeys =
  204.     /** @type {shaka.polyfill.PatchedMediaKeysApple.MediaKeys} */(
  205.         this.mediaKeys);
  206.     goog.asserts.assert(mediaKeys instanceof PatchedMediaKeysApple.MediaKeys,
  207.         'non-polyfill instance of newMediaKeys');
  209.     goog.asserts.assert(event.initData != null, 'missing init data!');
  211.     // Convert the prefixed init data to match the native 'encrypted' event.
  212.     const uint8 = shaka.util.BufferUtils.toUint8(event.initData);
  213.     const dataview = shaka.util.BufferUtils.toDataView(uint8);
  214.     // The first part is a 4 byte little-endian int, which is the length of
  215.     // the second part.
  216.     const length = dataview.getUint32(
  217.         /* position= */ 0, /* littleEndian= */ true);
  218.     if (length + 4 != uint8.byteLength) {
  219.       throw new RangeError('Malformed FairPlay init data');
  220.     }
  221.     // The remainder is a UTF-16 skd URL.  Convert this to UTF-8 and pass on.
  222.     const str = shaka.util.StringUtils.fromUTF16(
  223.         uint8.subarray(4), /* littleEndian= */ true);
  224.     const initData = shaka.util.StringUtils.toUTF8(str);
  226.     // NOTE: Because "this" is a real EventTarget, the event we dispatch here
  227.     // must also be a real Event.
  228.     const event2 = new Event('encrypted');
  230.     const encryptedEvent =
  231.       /** @type {!MediaEncryptedEvent} */(/** @type {?} */(event2));
  232.     encryptedEvent.initDataType = 'skd';
  233.     encryptedEvent.initData = shaka.util.BufferUtils.toArrayBuffer(initData);
  235.     this.dispatchEvent(event2);
  236.   }
  237. };
  240. /**
  241.  * An implementation of MediaKeySystemAccess.
  242.  *
  243.  * @implements {MediaKeySystemAccess}
  244.  */
  245. shaka.polyfill.PatchedMediaKeysApple.MediaKeySystemAccess = class {
  246.   /**
  247.    * @param {string} keySystem
  248.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  249.    */
  250.   constructor(keySystem, supportedConfigurations) {
  251.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySystemAccess');
  253.     /** @type {string} */
  254.     this.keySystem = keySystem;
  256.     /** @private {!MediaKeySystemConfiguration} */
  257.     this.configuration_;
  259.     // Optimization: WebKitMediaKeys.isTypeSupported delays responses by a
  260.     // significant amount of time, possibly to discourage fingerprinting.
  261.     // Since we know only FairPlay is supported here, let's skip queries for
  262.     // anything else to speed up the process.
  263.     if (keySystem.startsWith('com.apple.fps')) {
  264.       for (const cfg of supportedConfigurations) {
  265.         const newCfg = this.checkConfig_(cfg);
  266.         if (newCfg) {
  267.           this.configuration_ = newCfg;
  268.           return;
  269.         }
  270.       }
  271.     }
  273.     // According to the spec, this should be a DOMException, but there is not a
  274.     // public constructor for that.  So we make this look-alike instead.
  275.     const unsupportedKeySystemError = new Error('Unsupported keySystem');
  276.     unsupportedKeySystemError.name = 'NotSupportedError';
  277.     unsupportedKeySystemError['code'] = DOMException.NOT_SUPPORTED_ERR;
  278.     throw unsupportedKeySystemError;
  279.   }
  281.   /**
  282.    * Check a single config for MediaKeySystemAccess.
  283.    *
  284.    * @param {MediaKeySystemConfiguration} cfg The requested config.
  285.    * @return {?MediaKeySystemConfiguration} A matching config we can support, or
  286.    *   null if the input is not supportable.
  287.    * @private
  288.    */
  289.   checkConfig_(cfg) {
  290.     if (cfg.persistentState == 'required') {
  291.       // Not supported by the prefixed API.
  292.       return null;
  293.     }
  295.     // Create a new config object and start adding in the pieces which we find
  296.     // support for.  We will return this from getConfiguration() later if
  297.     // asked.
  299.     /** @type {!MediaKeySystemConfiguration} */
  300.     const newCfg = {
  301.       'audioCapabilities': [],
  302.       'videoCapabilities': [],
  303.       // It is technically against spec to return these as optional, but we
  304.       // don't truly know their values from the prefixed API:
  305.       'persistentState': 'optional',
  306.       'distinctiveIdentifier': 'optional',
  307.       // Pretend the requested init data types are supported, since we don't
  308.       // really know that either:
  309.       'initDataTypes': cfg.initDataTypes,
  310.       'sessionTypes': ['temporary'],
  311.       'label': cfg.label,
  312.     };
  314.     // PatchedMediaKeysApple tests for key system availability through
  315.     // WebKitMediaKeys.isTypeSupported.
  316.     let ranAnyTests = false;
  317.     let success = false;
  319.     if (cfg.audioCapabilities) {
  320.       for (const cap of cfg.audioCapabilities) {
  321.         if (cap.contentType) {
  322.           ranAnyTests = true;
  324.           const contentType = cap.contentType.split(';')[0];
  325.           if (WebKitMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  326.             newCfg.audioCapabilities.push(cap);
  327.             success = true;
  328.           }
  329.         }
  330.       }
  331.     }
  333.     if (cfg.videoCapabilities) {
  334.       for (const cap of cfg.videoCapabilities) {
  335.         if (cap.contentType) {
  336.           ranAnyTests = true;
  338.           const contentType = cap.contentType.split(';')[0];
  339.           if (WebKitMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  340.             newCfg.videoCapabilities.push(cap);
  341.             success = true;
  342.           }
  343.         }
  344.       }
  345.     }
  347.     if (!ranAnyTests) {
  348.       // If no specific types were requested, we check all common types to
  349.       // find out if the key system is present at all.
  350.       success = WebKitMediaKeys.isTypeSupported(this.keySystem, 'video/mp4');
  351.     }
  353.     if (success) {
  354.       return newCfg;
  355.     }
  356.     return null;
  357.   }
  359.   /** @override */
  360.   createMediaKeys() {
  361.     shaka.log.debug(
  362.         'PatchedMediaKeysApple.MediaKeySystemAccess.createMediaKeys');
  364.     // Alias
  365.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  367.     const mediaKeys = new PatchedMediaKeysApple.MediaKeys(this.keySystem);
  368.     return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  369.   }
  371.   /** @override */
  372.   getConfiguration() {
  373.     shaka.log.debug(
  374.         'PatchedMediaKeysApple.MediaKeySystemAccess.getConfiguration');
  375.     return this.configuration_;
  376.   }
  377. };
  380. /**
  381.  * An implementation of MediaKeys.
  382.  *
  383.  * @implements {MediaKeys}
  384.  */
  385. shaka.polyfill.PatchedMediaKeysApple.MediaKeys = class {
  386.   /** @param {string} keySystem */
  387.   constructor(keySystem) {
  388.     shaka.log.debug('PatchedMediaKeysApple.MediaKeys');
  390.     /** @private {!WebKitMediaKeys} */
  391.     this.nativeMediaKeys_ = new WebKitMediaKeys(keySystem);
  393.     /** @private {!shaka.util.EventManager} */
  394.     this.eventManager_ = new shaka.util.EventManager();
  395.   }
  397.   /** @override */
  398.   createSession(sessionType) {
  399.     shaka.log.debug('PatchedMediaKeysApple.MediaKeys.createSession');
  401.     sessionType = sessionType || 'temporary';
  402.     // For now, only the 'temporary' type is supported.
  403.     if (sessionType != 'temporary') {
  404.       throw new TypeError('Session type ' + sessionType +
  405.       ' is unsupported on this platform.');
  406.     }
  408.     // Alias
  409.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  411.     return new PatchedMediaKeysApple.MediaKeySession(
  412.         this.nativeMediaKeys_, sessionType);
  413.   }
  415.   /** @override */
  416.   setServerCertificate(serverCertificate) {
  417.     shaka.log.debug('PatchedMediaKeysApple.MediaKeys.setServerCertificate');
  418.     return Promise.resolve(false);
  419.   }
  421.   /**
  422.    * @param {HTMLMediaElement} media
  423.    * @protected
  424.    * @return {!Promise}
  425.    */
  426.   setMedia(media) {
  427.     // Alias
  428.     const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
  430.     // Remove any old listeners.
  431.     this.eventManager_.removeAll();
  433.     // It is valid for media to be null; null is used to flag that event
  434.     // handlers need to be cleaned up.
  435.     if (!media) {
  436.       return Promise.resolve();
  437.     }
  439.     // Intercept and translate these prefixed EME events.
  440.     this.eventManager_.listen(media, 'webkitneedkey',
  441.     /** @type {shaka.util.EventManager.ListenerType} */
  442.         (PatchedMediaKeysApple.onWebkitNeedKey_));
  444.     // Wrap native HTMLMediaElement.webkitSetMediaKeys with a Promise.
  445.     try {
  446.       // Some browsers require that readyState >=1 before mediaKeys can be
  447.       // set, so check this and wait for loadedmetadata if we are not in the
  448.       // correct state
  449.       shaka.util.MediaReadyState.waitForReadyState(media,
  450.           HTMLMediaElement.HAVE_METADATA,
  451.           this.eventManager_, () => {
  452.             media.webkitSetMediaKeys(this.nativeMediaKeys_);
  453.           });
  455.       return Promise.resolve();
  456.     } catch (exception) {
  457.       return Promise.reject(exception);
  458.     }
  459.   }
  460. };
  463. /**
  464.  * An implementation of MediaKeySession.
  465.  *
  466.  * @implements {MediaKeySession}
  467.  */
  468. shaka.polyfill.PatchedMediaKeysApple.MediaKeySession =
  469. class extends shaka.util.FakeEventTarget {
  470.   /**
  471.    * @param {WebKitMediaKeys} nativeMediaKeys
  472.    * @param {string} sessionType
  473.    */
  474.   constructor(nativeMediaKeys, sessionType) {
  475.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession');
  476.     super();
  478.     /**
  479.      * The native MediaKeySession, which will be created in generateRequest.
  480.      * @private {WebKitMediaKeySession}
  481.      */
  482.     this.nativeMediaKeySession_ = null;
  484.     /** @private {WebKitMediaKeys} */
  485.     this.nativeMediaKeys_ = nativeMediaKeys;
  487.     // Promises that are resolved later
  488.     /** @private {shaka.util.PublicPromise} */
  489.     this.generateRequestPromise_ = null;
  491.     /** @private {shaka.util.PublicPromise} */
  492.     this.updatePromise_ = null;
  494.     /** @private {!shaka.util.EventManager} */
  495.     this.eventManager_ = new shaka.util.EventManager();
  497.     /** @type {string} */
  498.     this.sessionId = '';
  500.     /** @type {number} */
  501.     this.expiration = NaN;
  503.     /** @type {!shaka.util.PublicPromise} */
  504.     this.closed = new shaka.util.PublicPromise();
  506.     /** @type {!shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap} */
  507.     this.keyStatuses =
  508.         new shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap();
  509.   }
  511.   /** @override */
  512.   generateRequest(initDataType, initData) {
  513.     shaka.log.debug(
  514.         'PatchedMediaKeysApple.MediaKeySession.generateRequest');
  516.     this.generateRequestPromise_ = new shaka.util.PublicPromise();
  518.     try {
  519.       // This EME spec version requires a MIME content type as the 1st param to
  520.       // createSession, but doesn't seem to matter what the value is.
  521.       // It also only accepts Uint8Array, not ArrayBuffer, so explicitly make
  522.       // initData into a Uint8Array.
  523.       const session = this.nativeMediaKeys_.createSession(
  524.           'video/mp4', shaka.util.BufferUtils.toUint8(initData));
  525.       this.nativeMediaKeySession_ = session;
  526.       this.sessionId = session.sessionId || '';
  528.       // Attach session event handlers here.
  529.       this.eventManager_.listen(
  530.           this.nativeMediaKeySession_, 'webkitkeymessage',
  531.           /** @type {shaka.util.EventManager.ListenerType} */
  532.           ((event) => this.onWebkitKeyMessage_(event)));
  533.       this.eventManager_.listen(session, 'webkitkeyadded',
  534.           /** @type {shaka.util.EventManager.ListenerType} */
  535.           ((event) => this.onWebkitKeyAdded_(event)));
  536.       this.eventManager_.listen(session, 'webkitkeyerror',
  537.           /** @type {shaka.util.EventManager.ListenerType} */
  538.           ((event) => this.onWebkitKeyError_(event)));
  540.       this.updateKeyStatus_('status-pending');
  541.     } catch (exception) {
  542.       this.generateRequestPromise_.reject(exception);
  543.     }
  545.     return this.generateRequestPromise_;
  546.   }
  548.   /** @override */
  549.   load() {
  550.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.load');
  552.     return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  553.   }
  555.   /** @override */
  556.   update(response) {
  557.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.update');
  559.     this.updatePromise_ = new shaka.util.PublicPromise();
  561.     try {
  562.       // Pass through to the native session.
  563.       this.nativeMediaKeySession_.update(
  564.           shaka.util.BufferUtils.toUint8(response));
  565.     } catch (exception) {
  566.       this.updatePromise_.reject(exception);
  567.     }
  569.     return this.updatePromise_;
  570.   }
  572.   /** @override */
  573.   close() {
  574.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.close');
  576.     try {
  577.       // Pass through to the native session.
  578.       this.nativeMediaKeySession_.close();
  580.       this.closed.resolve();
  581.       this.eventManager_.removeAll();
  582.     } catch (exception) {
  583.       this.closed.reject(exception);
  584.     }
  586.     return this.closed;
  587.   }
  589.   /** @override */
  590.   remove() {
  591.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.remove');
  593.     return Promise.reject(new Error(
  594.         'MediaKeySession.remove is only applicable for persistent licenses, ' +
  595.         'which are not supported on this platform'));
  596.   }
  598.   /**
  599.    * Handler for the native keymessage event on WebKitMediaKeySession.
  600.    *
  601.    * @param {!MediaKeyEvent} event
  602.    * @private
  603.    */
  604.   onWebkitKeyMessage_(event) {
  605.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyMessage_', event);
  607.     // We can now resolve this.generateRequestPromise, which should be non-null.
  608.     goog.asserts.assert(this.generateRequestPromise_,
  609.         'generateRequestPromise_ should be set before now!');
  610.     if (this.generateRequestPromise_) {
  611.       this.generateRequestPromise_.resolve();
  612.       this.generateRequestPromise_ = null;
  613.     }
  615.     const isNew = this.keyStatuses.getStatus() == undefined;
  617.     const data = new Map()
  618.         .set('messageType', isNew ? 'license-request' : 'license-renewal')
  619.         .set('message', shaka.util.BufferUtils.toArrayBuffer(event.message));
  620.     const event2 = new shaka.util.FakeEvent('message', data);
  622.     this.dispatchEvent(event2);
  623.   }
  625.   /**
  626.    * Handler for the native keyadded event on WebKitMediaKeySession.
  627.    *
  628.    * @param {!MediaKeyEvent} event
  629.    * @private
  630.    */
  631.   onWebkitKeyAdded_(event) {
  632.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyAdded_', event);
  634.     // This shouldn't fire while we're in the middle of generateRequest,
  635.     // but if it does, we will need to change the logic to account for it.
  636.     goog.asserts.assert(!this.generateRequestPromise_,
  637.         'Key added during generate!');
  639.     // We can now resolve this.updatePromise, which should be non-null.
  640.     goog.asserts.assert(this.updatePromise_,
  641.         'updatePromise_ should be set before now!');
  642.     if (this.updatePromise_) {
  643.       this.updateKeyStatus_('usable');
  644.       this.updatePromise_.resolve();
  645.       this.updatePromise_ = null;
  646.     }
  647.   }
  649.   /**
  650.    * Handler for the native keyerror event on WebKitMediaKeySession.
  651.    *
  652.    * @param {!MediaKeyEvent} event
  653.    * @private
  654.    */
  655.   onWebkitKeyError_(event) {
  656.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyError_', event);
  658.     const error = new Error('EME PatchedMediaKeysApple key error');
  659.     error['errorCode'] = this.nativeMediaKeySession_.error;
  661.     if (this.generateRequestPromise_ != null) {
  662.       this.generateRequestPromise_.reject(error);
  663.       this.generateRequestPromise_ = null;
  664.     } else if (this.updatePromise_ != null) {
  665.       this.updatePromise_.reject(error);
  666.       this.updatePromise_ = null;
  667.     } else {
  668.       // Unexpected error - map native codes to standardised key statuses.
  669.       // Possible values of this.nativeMediaKeySession_.error.code:
  670.       // MEDIA_KEYERR_UNKNOWN        = 1
  671.       // MEDIA_KEYERR_CLIENT         = 2
  672.       // MEDIA_KEYERR_SERVICE        = 3
  673.       // MEDIA_KEYERR_OUTPUT         = 4
  674.       // MEDIA_KEYERR_HARDWARECHANGE = 5
  675.       // MEDIA_KEYERR_DOMAIN         = 6
  677.       switch (this.nativeMediaKeySession_.error.code) {
  678.         case WebKitMediaKeyError.MEDIA_KEYERR_OUTPUT:
  679.         case WebKitMediaKeyError.MEDIA_KEYERR_HARDWARECHANGE:
  680.           this.updateKeyStatus_('output-not-allowed');
  681.           break;
  682.         default:
  683.           this.updateKeyStatus_('internal-error');
  684.           break;
  685.       }
  686.     }
  687.   }
  689.   /**
  690.    * Updates key status and dispatch a 'keystatuseschange' event.
  691.    *
  692.    * @param {string} status
  693.    * @private
  694.    */
  695.   updateKeyStatus_(status) {
  696.     this.keyStatuses.setStatus(status);
  697.     const event = new shaka.util.FakeEvent('keystatuseschange');
  698.     this.dispatchEvent(event);
  699.   }
  700. };
  703. /**
  704.  * @summary An implementation of MediaKeyStatusMap.
  705.  * This fakes a map with a single key ID.
  706.  *
  707.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  708.  * @implements {MediaKeyStatusMap}
  709.  */
  710. shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap = class {
  711.   /** */
  712.   constructor() {
  713.     /**
  714.      * @type {number}
  715.      */
  716.     this.size = 0;
  718.     /**
  719.      * @private {string|undefined}
  720.      */
  721.     this.status_ = undefined;
  722.   }
  724.   /**
  725.    * An internal method used by the session to set key status.
  726.    * @param {string|undefined} status
  727.    */
  728.   setStatus(status) {
  729.     this.size = status == undefined ? 0 : 1;
  730.     this.status_ = status;
  731.   }
  733.   /**
  734.    * An internal method used by the session to get key status.
  735.    * @return {string|undefined}
  736.    */
  737.   getStatus() {
  738.     return this.status_;
  739.   }
  741.   /** @override */
  742.   forEach(fn) {
  743.     if (this.status_) {
  744.       fn(this.status_, shaka.media.DrmEngine.DUMMY_KEY_ID.value());
  745.     }
  746.   }
  748.   /** @override */
  749.   get(keyId) {
  750.     if (this.has(keyId)) {
  751.       return this.status_;
  752.     }
  753.     return undefined;
  754.   }
  756.   /** @override */
  757.   has(keyId) {
  758.     const fakeKeyId = shaka.media.DrmEngine.DUMMY_KEY_ID.value();
  759.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  760.       return true;
  761.     }
  762.     return false;
  763.   }
  765.   /**
  766.    * @suppress {missingReturn}
  767.    * @override
  768.    */
  769.   entries() {
  770.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  771.   }
  773.   /**
  774.    * @suppress {missingReturn}
  775.    * @override
  776.    */
  777.   keys() {
  778.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  779.   }
  781.   /**
  782.    * @suppress {missingReturn}
  783.    * @override
  784.    */
  785.   values() {
  786.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  787.   }
  788. };