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