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