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.polyfill');
  12. goog.require('shaka.util.BufferUtils');
  13. goog.require('shaka.util.DrmUtils');
  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 = PatchedMediaKeysApple.apiName_;
  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 = '';
  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.   }
  461.   /** @override */
  462.   getStatusForPolicy(policy) {
  463.     return Promise.resolve('usable');
  464.   }
  465. };
  468. /**
  469.  * An implementation of MediaKeySession.
  470.  *
  471.  * @implements {MediaKeySession}
  472.  */
  473. shaka.polyfill.PatchedMediaKeysApple.MediaKeySession =
  474. class extends shaka.util.FakeEventTarget {
  475.   /**
  476.    * @param {WebKitMediaKeys} nativeMediaKeys
  477.    * @param {string} sessionType
  478.    */
  479.   constructor(nativeMediaKeys, sessionType) {
  480.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession');
  481.     super();
  483.     /**
  484.      * The native MediaKeySession, which will be created in generateRequest.
  485.      * @private {WebKitMediaKeySession}
  486.      */
  487.     this.nativeMediaKeySession_ = null;
  489.     /** @private {WebKitMediaKeys} */
  490.     this.nativeMediaKeys_ = nativeMediaKeys;
  492.     // Promises that are resolved later
  493.     /** @private {shaka.util.PublicPromise} */
  494.     this.generateRequestPromise_ = null;
  496.     /** @private {shaka.util.PublicPromise} */
  497.     this.updatePromise_ = null;
  499.     /** @private {!shaka.util.EventManager} */
  500.     this.eventManager_ = new shaka.util.EventManager();
  502.     /** @type {string} */
  503.     this.sessionId = '';
  505.     /** @type {number} */
  506.     this.expiration = NaN;
  508.     /** @type {!shaka.util.PublicPromise} */
  509.     this.closed = new shaka.util.PublicPromise();
  511.     /** @type {!shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap} */
  512.     this.keyStatuses =
  513.         new shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap();
  514.   }
  516.   /** @override */
  517.   generateRequest(initDataType, initData) {
  518.     shaka.log.debug(
  519.         'PatchedMediaKeysApple.MediaKeySession.generateRequest');
  521.     this.generateRequestPromise_ = new shaka.util.PublicPromise();
  523.     try {
  524.       // This EME spec version requires a MIME content type as the 1st param to
  525.       // createSession, but doesn't seem to matter what the value is.
  526.       // It also only accepts Uint8Array, not ArrayBuffer, so explicitly make
  527.       // initData into a Uint8Array.
  528.       const session = this.nativeMediaKeys_.createSession(
  529.           'video/mp4', shaka.util.BufferUtils.toUint8(initData));
  530.       this.nativeMediaKeySession_ = session;
  531.       this.sessionId = session.sessionId || '';
  533.       // Attach session event handlers here.
  534.       this.eventManager_.listen(
  535.           this.nativeMediaKeySession_, 'webkitkeymessage',
  536.           /** @type {shaka.util.EventManager.ListenerType} */
  537.           ((event) => this.onWebkitKeyMessage_(event)));
  538.       this.eventManager_.listen(session, 'webkitkeyadded',
  539.           /** @type {shaka.util.EventManager.ListenerType} */
  540.           ((event) => this.onWebkitKeyAdded_(event)));
  541.       this.eventManager_.listen(session, 'webkitkeyerror',
  542.           /** @type {shaka.util.EventManager.ListenerType} */
  543.           ((event) => this.onWebkitKeyError_(event)));
  545.       this.updateKeyStatus_('status-pending');
  546.     } catch (exception) {
  547.       this.generateRequestPromise_.reject(exception);
  548.     }
  550.     return this.generateRequestPromise_;
  551.   }
  553.   /** @override */
  554.   load() {
  555.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.load');
  557.     return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  558.   }
  560.   /** @override */
  561.   update(response) {
  562.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.update');
  564.     this.updatePromise_ = new shaka.util.PublicPromise();
  566.     try {
  567.       // Pass through to the native session.
  568.       this.nativeMediaKeySession_.update(
  569.           shaka.util.BufferUtils.toUint8(response));
  570.     } catch (exception) {
  571.       this.updatePromise_.reject(exception);
  572.     }
  574.     return this.updatePromise_;
  575.   }
  577.   /** @override */
  578.   close() {
  579.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.close');
  581.     try {
  582.       // Pass through to the native session.
  583.       this.nativeMediaKeySession_.close();
  585.       this.closed.resolve();
  586.       this.eventManager_.removeAll();
  587.     } catch (exception) {
  588.       this.closed.reject(exception);
  589.     }
  591.     return this.closed;
  592.   }
  594.   /** @override */
  595.   remove() {
  596.     shaka.log.debug('PatchedMediaKeysApple.MediaKeySession.remove');
  598.     return Promise.reject(new Error(
  599.         'MediaKeySession.remove is only applicable for persistent licenses, ' +
  600.         'which are not supported on this platform'));
  601.   }
  603.   /**
  604.    * Handler for the native keymessage event on WebKitMediaKeySession.
  605.    *
  606.    * @param {!MediaKeyEvent} event
  607.    * @private
  608.    */
  609.   onWebkitKeyMessage_(event) {
  610.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyMessage_', event);
  612.     // We can now resolve this.generateRequestPromise, which should be non-null.
  613.     goog.asserts.assert(this.generateRequestPromise_,
  614.         'generateRequestPromise_ should be set before now!');
  615.     if (this.generateRequestPromise_) {
  616.       this.generateRequestPromise_.resolve();
  617.       this.generateRequestPromise_ = null;
  618.     }
  620.     const isNew = this.keyStatuses.getStatus() == undefined;
  622.     const data = new Map()
  623.         .set('messageType', isNew ? 'license-request' : 'license-renewal')
  624.         .set('message', shaka.util.BufferUtils.toArrayBuffer(event.message));
  625.     const event2 = new shaka.util.FakeEvent('message', data);
  627.     this.dispatchEvent(event2);
  628.   }
  630.   /**
  631.    * Handler for the native keyadded event on WebKitMediaKeySession.
  632.    *
  633.    * @param {!MediaKeyEvent} event
  634.    * @private
  635.    */
  636.   onWebkitKeyAdded_(event) {
  637.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyAdded_', event);
  639.     // This shouldn't fire while we're in the middle of generateRequest,
  640.     // but if it does, we will need to change the logic to account for it.
  641.     goog.asserts.assert(!this.generateRequestPromise_,
  642.         'Key added during generate!');
  644.     // We can now resolve this.updatePromise, which should be non-null.
  645.     goog.asserts.assert(this.updatePromise_,
  646.         'updatePromise_ should be set before now!');
  647.     if (this.updatePromise_) {
  648.       this.updateKeyStatus_('usable');
  649.       this.updatePromise_.resolve();
  650.       this.updatePromise_ = null;
  651.     }
  652.   }
  654.   /**
  655.    * Handler for the native keyerror event on WebKitMediaKeySession.
  656.    *
  657.    * @param {!MediaKeyEvent} event
  658.    * @private
  659.    */
  660.   onWebkitKeyError_(event) {
  661.     shaka.log.debug('PatchedMediaKeysApple.onWebkitKeyError_', event);
  663.     const error = new Error('EME PatchedMediaKeysApple key error');
  664.     error['errorCode'] = this.nativeMediaKeySession_.error;
  666.     if (this.generateRequestPromise_ != null) {
  667.       this.generateRequestPromise_.reject(error);
  668.       this.generateRequestPromise_ = null;
  669.     } else if (this.updatePromise_ != null) {
  670.       this.updatePromise_.reject(error);
  671.       this.updatePromise_ = null;
  672.     } else {
  673.       // Unexpected error - map native codes to standardised key statuses.
  674.       // Possible values of this.nativeMediaKeySession_.error.code:
  675.       // MEDIA_KEYERR_UNKNOWN        = 1
  676.       // MEDIA_KEYERR_CLIENT         = 2
  677.       // MEDIA_KEYERR_SERVICE        = 3
  678.       // MEDIA_KEYERR_OUTPUT         = 4
  679.       // MEDIA_KEYERR_HARDWARECHANGE = 5
  680.       // MEDIA_KEYERR_DOMAIN         = 6
  682.       switch (this.nativeMediaKeySession_.error.code) {
  683.         case WebKitMediaKeyError.MEDIA_KEYERR_OUTPUT:
  684.         case WebKitMediaKeyError.MEDIA_KEYERR_HARDWARECHANGE:
  685.           this.updateKeyStatus_('output-not-allowed');
  686.           break;
  687.         default:
  688.           this.updateKeyStatus_('internal-error');
  689.           break;
  690.       }
  691.     }
  692.   }
  694.   /**
  695.    * Updates key status and dispatch a 'keystatuseschange' event.
  696.    *
  697.    * @param {string} status
  698.    * @private
  699.    */
  700.   updateKeyStatus_(status) {
  701.     this.keyStatuses.setStatus(status);
  702.     const event = new shaka.util.FakeEvent('keystatuseschange');
  703.     this.dispatchEvent(event);
  704.   }
  705. };
  708. /**
  709.  * @summary An implementation of MediaKeyStatusMap.
  710.  * This fakes a map with a single key ID.
  711.  *
  712.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  713.  * @implements {MediaKeyStatusMap}
  714.  */
  715. shaka.polyfill.PatchedMediaKeysApple.MediaKeyStatusMap = class {
  716.   /** */
  717.   constructor() {
  718.     /**
  719.      * @type {number}
  720.      */
  721.     this.size = 0;
  723.     /**
  724.      * @private {string|undefined}
  725.      */
  726.     this.status_ = undefined;
  727.   }
  729.   /**
  730.    * An internal method used by the session to set key status.
  731.    * @param {string|undefined} status
  732.    */
  733.   setStatus(status) {
  734.     this.size = status == undefined ? 0 : 1;
  735.     this.status_ = status;
  736.   }
  738.   /**
  739.    * An internal method used by the session to get key status.
  740.    * @return {string|undefined}
  741.    */
  742.   getStatus() {
  743.     return this.status_;
  744.   }
  746.   /** @override */
  747.   forEach(fn) {
  748.     if (this.status_) {
  749.       fn(this.status_, shaka.util.DrmUtils.DUMMY_KEY_ID.value());
  750.     }
  751.   }
  753.   /** @override */
  754.   get(keyId) {
  755.     if (this.has(keyId)) {
  756.       return this.status_;
  757.     }
  758.     return undefined;
  759.   }
  761.   /** @override */
  762.   has(keyId) {
  763.     const fakeKeyId = shaka.util.DrmUtils.DUMMY_KEY_ID.value();
  764.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  765.       return true;
  766.     }
  767.     return false;
  768.   }
  770.   /**
  771.    * @suppress {missingReturn}
  772.    * @override
  773.    */
  774.   entries() {
  775.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  776.   }
  778.   /**
  779.    * @suppress {missingReturn}
  780.    * @override
  781.    */
  782.   keys() {
  783.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  784.   }
  786.   /**
  787.    * @suppress {missingReturn}
  788.    * @override
  789.    */
  790.   values() {
  791.     goog.asserts.assert(false, 'Not used!  Provided only for the compiler.');
  792.   }
  793. };
  795. /**
  796.  * API name.
  797.  *
  798.  * @private {string}
  799.  */
  800. shaka.polyfill.PatchedMediaKeysApple.apiName_ = 'apple';