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