Source: lib/polyfill/patchedmediakeys_webkit.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.polyfill.PatchedMediaKeysWebkit');
  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.PublicPromise');
  18. goog.require('shaka.util.StringUtils');
  19. goog.require('shaka.util.Timer');
  20. goog.require('shaka.util.Uint8ArrayUtils');
  23. /**
  24.  * @summary A polyfill to implement
  25.  * {@link https://bit.ly/EmeMar15 EME draft 12 March 2015} on top of
  26.  * webkit-prefixed {@link https://bit.ly/Eme01b EME v0.1b}.
  27.  * @export
  28.  */
  29. shaka.polyfill.PatchedMediaKeysWebkit = class {
  30.   /**
  31.    * Installs the polyfill if needed.
  32.    * @export
  33.    */
  34.   static install() {
  35.     // Alias.
  36.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  38.     if (!window.HTMLVideoElement ||
  39.         (navigator.requestMediaKeySystemAccess &&
  40.          // eslint-disable-next-line no-restricted-syntax
  41.          MediaKeySystemAccess.prototype.getConfiguration)) {
  42.       return;
  43.     }
  44.     // eslint-disable-next-line no-restricted-syntax
  45.     if (HTMLMediaElement.prototype.webkitGenerateKeyRequest) {
  46.       shaka.log.info('Using webkit-prefixed EME v0.1b');
  47.       PatchedMediaKeysWebkit.prefix_ = 'webkit';
  48.       // eslint-disable-next-line no-restricted-syntax
  49.     } else if (HTMLMediaElement.prototype.generateKeyRequest) {
  50.       shaka.log.info('Using nonprefixed EME v0.1b');
  51.     } else {
  52.       return;
  53.     }
  55.     goog.asserts.assert(
  56.         // eslint-disable-next-line no-restricted-syntax
  57.         HTMLMediaElement.prototype[
  58.             PatchedMediaKeysWebkit.prefixApi_('generateKeyRequest')],
  59.         'PatchedMediaKeysWebkit APIs not available!');
  61.     // Install patches.
  62.     navigator.requestMediaKeySystemAccess =
  63.         PatchedMediaKeysWebkit.requestMediaKeySystemAccess;
  64.     // Delete mediaKeys to work around strict mode compatibility issues.
  65.     // eslint-disable-next-line no-restricted-syntax
  66.     delete HTMLMediaElement.prototype['mediaKeys'];
  67.     // Work around read-only declaration for mediaKeys by using a string.
  68.     // eslint-disable-next-line no-restricted-syntax
  69.     HTMLMediaElement.prototype['mediaKeys'] = null;
  70.     // eslint-disable-next-line no-restricted-syntax
  71.     HTMLMediaElement.prototype.setMediaKeys =
  72.         PatchedMediaKeysWebkit.setMediaKeys;
  73.     window.MediaKeys = PatchedMediaKeysWebkit.MediaKeys;
  74.     window.MediaKeySystemAccess = PatchedMediaKeysWebkit.MediaKeySystemAccess;
  76.     window.shakaMediaKeysPolyfill = PatchedMediaKeysWebkit.apiName_;
  77.   }
  79.   /**
  80.    * Prefix the api with the stored prefix.
  81.    *
  82.    * @param {string} api
  83.    * @return {string}
  84.    * @private
  85.    */
  86.   static prefixApi_(api) {
  87.     const prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  88.     if (prefix) {
  89.       return prefix + api.charAt(0).toUpperCase() + api.slice(1);
  90.     }
  91.     return api;
  92.   }
  94.   /**
  95.    * An implementation of navigator.requestMediaKeySystemAccess.
  96.    * Retrieves a MediaKeySystemAccess object.
  97.    *
  98.    * @this {!Navigator}
  99.    * @param {string} keySystem
  100.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  101.    * @return {!Promise.<!MediaKeySystemAccess>}
  102.    */
  103.   static requestMediaKeySystemAccess(keySystem, supportedConfigurations) {
  104.     shaka.log.debug('PatchedMediaKeysWebkit.requestMediaKeySystemAccess');
  105.     goog.asserts.assert(this == navigator,
  106.         'bad "this" for requestMediaKeySystemAccess');
  108.     // Alias.
  109.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  110.     try {
  111.       const access = new PatchedMediaKeysWebkit.MediaKeySystemAccess(
  112.           keySystem, supportedConfigurations);
  113.       return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  114.     } catch (exception) {
  115.       return Promise.reject(exception);
  116.     }
  117.   }
  119.   /**
  120.    * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  121.    * Attaches a MediaKeys object to the media element.
  122.    *
  123.    * @this {!HTMLMediaElement}
  124.    * @param {MediaKeys} mediaKeys
  125.    * @return {!Promise}
  126.    */
  127.   static setMediaKeys(mediaKeys) {
  128.     shaka.log.debug('PatchedMediaKeysWebkit.setMediaKeys');
  129.     goog.asserts.assert(this instanceof HTMLMediaElement,
  130.         'bad "this" for setMediaKeys');
  132.     // Alias.
  133.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  135.     const newMediaKeys =
  136.     /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  137.         mediaKeys);
  138.     const oldMediaKeys =
  139.     /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  140.         this.mediaKeys);
  142.     if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  143.       goog.asserts.assert(
  144.           oldMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  145.           'non-polyfill instance of oldMediaKeys');
  146.       // Have the old MediaKeys stop listening to events on the video tag.
  147.       oldMediaKeys.setMedia(null);
  148.     }
  150.     delete this['mediaKeys'];  // In case there is an existing getter.
  151.     this['mediaKeys'] = mediaKeys;  // Work around the read-only declaration.
  153.     if (newMediaKeys) {
  154.       goog.asserts.assert(
  155.           newMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  156.           'non-polyfill instance of newMediaKeys');
  157.       newMediaKeys.setMedia(this);
  158.     }
  160.     return Promise.resolve();
  161.   }
  163.   /**
  164.    * For some of this polyfill's implementation, we need to query a video
  165.    * element.  But for some embedded systems, it is memory-expensive to create
  166.    * multiple video elements.  Therefore, we check the document to see if we can
  167.    * borrow one to query before we fall back to creating one temporarily.
  168.    *
  169.    * @return {!HTMLVideoElement}
  170.    * @private
  171.    */
  172.   static getVideoElement_() {
  173.     const videos = document.getElementsByTagName('video');
  174.     const video = videos.length ? videos[0] : document.createElement('video');
  175.     return /** @type {!HTMLVideoElement} */(video);
  176.   }
  177. };
  180. /**
  181.  * An implementation of MediaKeySystemAccess.
  182.  *
  183.  * @implements {MediaKeySystemAccess}
  184.  */
  185. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess = class {
  186.   /**
  187.    * @param {string} keySystem
  188.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  189.    */
  190.   constructor(keySystem, supportedConfigurations) {
  191.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySystemAccess');
  193.     /** @type {string} */
  194.     this.keySystem = keySystem;
  196.     /** @private {string} */
  197.     this.internalKeySystem_ = keySystem;
  199.     /** @private {!MediaKeySystemConfiguration} */
  200.     this.configuration_;
  202.     // This is only a guess, since we don't really know from the prefixed API.
  203.     let allowPersistentState = false;
  205.     if (keySystem == 'org.w3.clearkey') {
  206.       // ClearKey's string must be prefixed in v0.1b.
  207.       this.internalKeySystem_ = 'webkit-org.w3.clearkey';
  208.       // ClearKey doesn't support persistence.
  209.       allowPersistentState = false;
  210.     }
  212.     let success = false;
  213.     const tmpVideo = shaka.polyfill.PatchedMediaKeysWebkit.getVideoElement_();
  214.     for (const cfg of supportedConfigurations) {
  215.       // Create a new config object and start adding in the pieces which we
  216.       // find support for.  We will return this from getConfiguration() if
  217.       // asked.
  218.       /** @type {!MediaKeySystemConfiguration} */
  219.       const newCfg = {
  220.         'audioCapabilities': [],
  221.         'videoCapabilities': [],
  222.         // It is technically against spec to return these as optional, but we
  223.         // don't truly know their values from the prefixed API:
  224.         'persistentState': 'optional',
  225.         'distinctiveIdentifier': 'optional',
  226.         // Pretend the requested init data types are supported, since we don't
  227.         // really know that either:
  228.         'initDataTypes': cfg.initDataTypes,
  229.         'sessionTypes': ['temporary'],
  230.         'label': cfg.label,
  231.       };
  233.       // v0.1b tests for key system availability with an extra argument on
  234.       // canPlayType.
  235.       let ranAnyTests = false;
  236.       if (cfg.audioCapabilities) {
  237.         for (const cap of cfg.audioCapabilities) {
  238.           if (cap.contentType) {
  239.             ranAnyTests = true;
  240.             // In Chrome <= 40, if you ask about Widevine-encrypted audio
  241.             // support, you get a false-negative when you specify codec
  242.             // information. Work around this by stripping codec info for audio
  243.             // types.
  244.             const contentType = cap.contentType.split(';')[0];
  245.             if (tmpVideo.canPlayType(contentType, this.internalKeySystem_)) {
  246.               newCfg.audioCapabilities.push(cap);
  247.               success = true;
  248.             }
  249.           }
  250.         }
  251.       }
  252.       if (cfg.videoCapabilities) {
  253.         for (const cap of cfg.videoCapabilities) {
  254.           if (cap.contentType) {
  255.             ranAnyTests = true;
  256.             if (tmpVideo.canPlayType(
  257.                 cap.contentType, this.internalKeySystem_)) {
  258.               newCfg.videoCapabilities.push(cap);
  259.               success = true;
  260.             }
  261.           }
  262.         }
  263.       }
  265.       if (!ranAnyTests) {
  266.         // If no specific types were requested, we check all common types to
  267.         // find out if the key system is present at all.
  268.         success =
  269.             tmpVideo.canPlayType('video/mp4', this.internalKeySystem_) ||
  270.             tmpVideo.canPlayType('video/webm', this.internalKeySystem_);
  271.       }
  272.       if (cfg.persistentState == 'required') {
  273.         if (allowPersistentState) {
  274.           newCfg.persistentState = 'required';
  275.           newCfg.sessionTypes = ['persistent-license'];
  276.         } else {
  277.           success = false;
  278.         }
  279.       }
  281.       if (success) {
  282.         this.configuration_ = newCfg;
  283.         return;
  284.       }
  285.     }  // for each cfg in supportedConfigurations
  287.     let message = 'Unsupported keySystem';
  288.     if (keySystem == 'org.w3.clearkey' || keySystem == 'com.widevine.alpha') {
  289.       message = 'None of the requested configurations were supported.';
  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 unsupportedError = new Error(message);
  295.     unsupportedError.name = 'NotSupportedError';
  296.     unsupportedError['code'] = DOMException.NOT_SUPPORTED_ERR;
  297.     throw unsupportedError;
  298.   }
  300.   /** @override */
  301.   createMediaKeys() {
  302.     shaka.log.debug(
  303.         'PatchedMediaKeysWebkit.MediaKeySystemAccess.createMediaKeys');
  305.     // Alias.
  306.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  307.     const mediaKeys =
  308.     new PatchedMediaKeysWebkit.MediaKeys(this.internalKeySystem_);
  309.     return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  310.   }
  312.   /** @override */
  313.   getConfiguration() {
  314.     shaka.log.debug(
  315.         'PatchedMediaKeysWebkit.MediaKeySystemAccess.getConfiguration');
  316.     return this.configuration_;
  317.   }
  318. };
  321. /**
  322.  * An implementation of MediaKeys.
  323.  *
  324.  * @implements {MediaKeys}
  325.  */
  326. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys = class {
  327.   /**
  328.    * @param {string} keySystem
  329.    */
  330.   constructor(keySystem) {
  331.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys');
  333.     /** @private {string} */
  334.     this.keySystem_ = keySystem;
  336.     /** @private {HTMLMediaElement} */
  337.     this.media_ = null;
  339.     /** @private {!shaka.util.EventManager} */
  340.     this.eventManager_ = new shaka.util.EventManager();
  342.     /**
  343.      * @private {Array.<!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  344.      */
  345.     this.newSessions_ = [];
  347.     /**
  348.      * @private {!Map.<string,
  349.      *                 !shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  350.      */
  351.     this.sessionMap_ = new Map();
  352.   }
  354.   /**
  355.    * @param {HTMLMediaElement} media
  356.    * @protected
  357.    */
  358.   setMedia(media) {
  359.     this.media_ = media;
  361.     // Remove any old listeners.
  362.     this.eventManager_.removeAll();
  364.     const prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  365.     if (media) {
  366.       // Intercept and translate these prefixed EME events.
  367.       this.eventManager_.listen(media, prefix + 'needkey',
  368.       /** @type {shaka.util.EventManager.ListenerType} */ (
  369.             (event) => this.onWebkitNeedKey_(event)));
  371.       this.eventManager_.listen(media, prefix + 'keymessage',
  372.       /** @type {shaka.util.EventManager.ListenerType} */ (
  373.             (event) => this.onWebkitKeyMessage_(event)));
  375.       this.eventManager_.listen(media, prefix + 'keyadded',
  376.       /** @type {shaka.util.EventManager.ListenerType} */ (
  377.             (event) => this.onWebkitKeyAdded_(event)));
  379.       this.eventManager_.listen(media, prefix + 'keyerror',
  380.       /** @type {shaka.util.EventManager.ListenerType} */ (
  381.             (event) => this.onWebkitKeyError_(event)));
  382.     }
  383.   }
  385.   /** @override */
  386.   createSession(sessionType) {
  387.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.createSession');
  389.     sessionType = sessionType || 'temporary';
  390.     if (sessionType != 'temporary' && sessionType != 'persistent-license') {
  391.       throw new TypeError('Session type ' + sessionType +
  392.                       ' is unsupported on this platform.');
  393.     }
  395.     // Alias.
  396.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  398.     // Unprefixed EME allows for session creation without a video tag or src.
  399.     // Prefixed EME requires both a valid HTMLMediaElement and a src.
  400.     const media = this.media_ || /** @type {!HTMLMediaElement} */(
  401.       document.createElement('video'));
  402.     if (!media.src) {
  403.       media.src = 'about:blank';
  404.     }
  406.     const session = new PatchedMediaKeysWebkit.MediaKeySession(
  407.         media, this.keySystem_, sessionType);
  408.     this.newSessions_.push(session);
  409.     return session;
  410.   }
  412.   /** @override */
  413.   setServerCertificate(serverCertificate) {
  414.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.setServerCertificate');
  416.     // There is no equivalent in v0.1b, so return failure.
  417.     return Promise.resolve(false);
  418.   }
  420.   /** @override */
  421.   getStatusForPolicy(policy) {
  422.     return Promise.resolve('usable');
  423.   }
  425.   /**
  426.    * @param {!MediaKeyEvent} event
  427.    * @suppress {constantProperty} We reassign what would be const on a real
  428.    *   MediaEncryptedEvent, but in our look-alike event.
  429.    * @private
  430.    */
  431.   onWebkitNeedKey_(event) {
  432.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitNeedKey_', event);
  433.     goog.asserts.assert(this.media_, 'media_ not set in onWebkitNeedKey_');
  435.     const event2 = new CustomEvent('encrypted');
  436.     const encryptedEvent =
  437.       /** @type {!MediaEncryptedEvent} */(/** @type {?} */(event2));
  438.     // initDataType is not used by v0.1b EME, so any valid value is fine here.
  439.     encryptedEvent.initDataType = 'cenc';
  440.     encryptedEvent.initData = shaka.util.BufferUtils.toArrayBuffer(
  441.         event.initData);
  443.     this.media_.dispatchEvent(event2);
  444.   }
  446.   /**
  447.    * @param {!MediaKeyEvent} event
  448.    * @private
  449.    */
  450.   onWebkitKeyMessage_(event) {
  451.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyMessage_', event);
  453.     const session = this.findSession_(event.sessionId);
  454.     if (!session) {
  455.       shaka.log.error('Session not found', event.sessionId);
  456.       return;
  457.     }
  459.     const isNew = session.keyStatuses.getStatus() == undefined;
  461.     const data = new Map()
  462.         .set('messageType', isNew ? 'licenserequest' : 'licenserenewal')
  463.         .set('message', event.message);
  464.     const event2 = new shaka.util.FakeEvent('message', data);
  466.     session.generated();
  467.     session.dispatchEvent(event2);
  468.   }
  470.   /**
  471.    * @param {!MediaKeyEvent} event
  472.    * @private
  473.    */
  474.   onWebkitKeyAdded_(event) {
  475.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyAdded_', event);
  477.     const session = this.findSession_(event.sessionId);
  478.     goog.asserts.assert(
  479.         session, 'unable to find session in onWebkitKeyAdded_');
  480.     if (session) {
  481.       session.ready();
  482.     }
  483.   }
  485.   /**
  486.    * @param {!MediaKeyEvent} event
  487.    * @private
  488.    */
  489.   onWebkitKeyError_(event) {
  490.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyError_', event);
  492.     const session = this.findSession_(event.sessionId);
  493.     goog.asserts.assert(
  494.         session, 'unable to find session in onWebkitKeyError_');
  495.     if (session) {
  496.       session.handleError(event);
  497.     }
  498.   }
  500.   /**
  501.    * @param {string} sessionId
  502.    * @return {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession}
  503.    * @private
  504.    */
  505.   findSession_(sessionId) {
  506.     let session = this.sessionMap_.get(sessionId);
  507.     if (session) {
  508.       shaka.log.debug(
  509.           'PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  510.       return session;
  511.     }
  513.     session = this.newSessions_.shift();
  514.     if (session) {
  515.       session.sessionId = sessionId;
  516.       this.sessionMap_.set(sessionId, session);
  517.       shaka.log.debug(
  518.           'PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  519.       return session;
  520.     }
  522.     return null;
  523.   }
  524. };
  527. /**
  528.  * An implementation of MediaKeySession.
  529.  *
  530.  * @implements {MediaKeySession}
  531.  */
  532. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession =
  533. class extends shaka.util.FakeEventTarget {
  534.   /**
  535.    * @param {!HTMLMediaElement} media
  536.    * @param {string} keySystem
  537.    * @param {string} sessionType
  538.    */
  539.   constructor(media, keySystem, sessionType) {
  540.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession');
  541.     super();
  543.     /** @private {!HTMLMediaElement} */
  544.     this.media_ = media;
  546.     /** @private {boolean} */
  547.     this.initialized_ = false;
  549.     /** @private {shaka.util.PublicPromise} */
  550.     this.generatePromise_ = null;
  552.     /** @private {shaka.util.PublicPromise} */
  553.     this.updatePromise_ = null;
  555.     /** @private {string} */
  556.     this.keySystem_ = keySystem;
  558.     /** @private {string} */
  559.     this.type_ = sessionType;
  561.     /** @type {string} */
  562.     this.sessionId = '';
  564.     /** @type {number} */
  565.     this.expiration = NaN;
  567.     /** @type {!shaka.util.PublicPromise} */
  568.     this.closed = new shaka.util.PublicPromise();
  570.     /** @type {!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap} */
  571.     this.keyStatuses =
  572.         new shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap();
  573.   }
  575.   /**
  576.    * Signals that the license request has been generated.  This resolves the
  577.    * 'generateRequest' promise.
  578.    *
  579.    * @protected
  580.    */
  581.   generated() {
  582.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generated');
  584.     if (this.generatePromise_) {
  585.       this.generatePromise_.resolve();
  586.       this.generatePromise_ = null;
  587.     }
  588.   }
  590.   /**
  591.    * Signals that the session is 'ready', which is the terminology used in older
  592.    * versions of EME.  The new signal is to resolve the 'update' promise.  This
  593.    * translates between the two.
  594.    *
  595.    * @protected
  596.    */
  597.   ready() {
  598.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.ready');
  600.     this.updateKeyStatus_('usable');
  602.     if (this.updatePromise_) {
  603.       this.updatePromise_.resolve();
  604.     }
  605.     this.updatePromise_ = null;
  606.   }
  608.   /**
  609.    * Either rejects a promise, or dispatches an error event, as appropriate.
  610.    *
  611.    * @param {!MediaKeyEvent} event
  612.    */
  613.   handleError(event) {
  614.     shaka.log.debug(
  615.         'PatchedMediaKeysWebkit.MediaKeySession.handleError', event);
  617.     // This does not match the DOMException we get in current WD EME, but it
  618.     // will at least provide some information which can be used to look into the
  619.     // problem.
  620.     const error = new Error('EME v0.1b key error');
  621.     const errorCode = event.errorCode;
  622.     errorCode.systemCode = event.systemCode;
  623.     error['errorCode'] = errorCode;
  625.     // The presence or absence of sessionId indicates whether this corresponds
  626.     // to generateRequest() or update().
  627.     if (!event.sessionId && this.generatePromise_) {
  628.       if (event.systemCode == 45) {
  629.         error.message = 'Unsupported session type.';
  630.       }
  631.       this.generatePromise_.reject(error);
  632.       this.generatePromise_ = null;
  633.     } else if (event.sessionId && this.updatePromise_) {
  634.       this.updatePromise_.reject(error);
  635.       this.updatePromise_ = null;
  636.     } else {
  637.       // This mapping of key statuses is imperfect at best.
  638.       const code = event.errorCode.code;
  639.       const systemCode = event.systemCode;
  640.       if (code == MediaKeyError['MEDIA_KEYERR_OUTPUT']) {
  641.         this.updateKeyStatus_('output-restricted');
  642.       } else if (systemCode == 1) {
  643.         this.updateKeyStatus_('expired');
  644.       } else {
  645.         this.updateKeyStatus_('internal-error');
  646.       }
  647.     }
  648.   }
  650.   /**
  651.    * Logic which is shared between generateRequest() and load(), both of which
  652.    * are ultimately implemented with webkitGenerateKeyRequest in prefixed EME.
  653.    *
  654.    * @param {?BufferSource} initData
  655.    * @param {?string} offlineSessionId
  656.    * @return {!Promise}
  657.    * @private
  658.    */
  659.   generate_(initData, offlineSessionId) {
  660.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  662.     if (this.initialized_) {
  663.       const error = new Error('The session is already initialized.');
  664.       return Promise.reject(error);
  665.     }
  667.     this.initialized_ = true;
  669.     /** @type {!Uint8Array} */
  670.     let mangledInitData;
  672.     try {
  673.       if (this.type_ == 'persistent-license') {
  674.         const StringUtils = shaka.util.StringUtils;
  675.         if (!offlineSessionId) {
  676.           goog.asserts.assert(initData, 'expecting init data');
  677.           // Persisting the initial license.
  678.           // Prefix the init data with a tag to indicate persistence.
  679.           const prefix = StringUtils.toUTF8('PERSISTENT|');
  680.           mangledInitData = shaka.util.Uint8ArrayUtils.concat(prefix, initData);
  681.         } else {
  682.           // Loading a stored license.
  683.           // Prefix the init data (which is really a session ID) with a tag to
  684.           // indicate that we are loading a persisted session.
  685.           mangledInitData = shaka.util.BufferUtils.toUint8(
  686.               StringUtils.toUTF8('LOAD_SESSION|' + offlineSessionId));
  687.         }
  688.       } else {
  689.         // Streaming.
  690.         goog.asserts.assert(this.type_ == 'temporary',
  691.             'expected temporary session');
  692.         goog.asserts.assert(!offlineSessionId,
  693.             'unexpected offline session ID');
  694.         goog.asserts.assert(initData, 'expecting init data');
  695.         mangledInitData = shaka.util.BufferUtils.toUint8(initData);
  696.       }
  698.       goog.asserts.assert(mangledInitData, 'init data not set!');
  699.     } catch (exception) {
  700.       return Promise.reject(exception);
  701.     }
  703.     goog.asserts.assert(this.generatePromise_ == null,
  704.         'generatePromise_ should be null');
  705.     this.generatePromise_ = new shaka.util.PublicPromise();
  707.     // Because we are hacking media.src in createSession to better emulate
  708.     // unprefixed EME's ability to create sessions and license requests without
  709.     // a video tag, we can get ourselves into trouble.  It seems that sometimes,
  710.     // the setting of media.src hasn't been processed by some other thread, and
  711.     // GKR can throw an exception.  If this occurs, wait 10 ms and try again at
  712.     // most once.  This situation should only occur when init data is available
  713.     // ahead of the 'needkey' event.
  715.     const generateKeyRequestName =
  716.         PatchedMediaKeysWebkit.prefixApi_('generateKeyRequest');
  717.     try {
  718.       this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  719.     } catch (exception) {
  720.       if (exception.name != 'InvalidStateError') {
  721.         this.generatePromise_ = null;
  722.         return Promise.reject(exception);
  723.       }
  725.       const timer = new shaka.util.Timer(() => {
  726.         try {
  727.           this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  728.         } catch (exception2) {
  729.           this.generatePromise_.reject(exception2);
  730.           this.generatePromise_ = null;
  731.         }
  732.       });
  734.       timer.tickAfter(/* seconds= */ 0.01);
  735.     }
  737.     return this.generatePromise_;
  738.   }
  740.   /**
  741.    * An internal version of update which defers new calls while old ones are in
  742.    * progress.
  743.    *
  744.    * @param {!shaka.util.PublicPromise} promise  The promise associated with
  745.    *   this call.
  746.    * @param {BufferSource} response
  747.    * @private
  748.    */
  749.   update_(promise, response) {
  750.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  752.     if (this.updatePromise_) {
  753.       // We already have an update in-progress, so defer this one until after
  754.       // the old one is resolved.  Execute this whether the original one
  755.       // succeeds or fails.
  756.       this.updatePromise_.then(() => this.update_(promise, response))
  757.           .catch(() => this.update_(promise, response));
  758.       return;
  759.     }
  761.     this.updatePromise_ = promise;
  763.     let key;
  764.     let keyId;
  766.     if (this.keySystem_ == 'webkit-org.w3.clearkey') {
  767.       // The current EME version of clearkey wants a structured JSON response.
  768.       // The v0.1b version wants just a raw key.  Parse the JSON response and
  769.       // extract the key and key ID.
  770.       const StringUtils = shaka.util.StringUtils;
  771.       const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  772.       const licenseString = StringUtils.fromUTF8(response);
  773.       const jwkSet = /** @type {JWKSet} */ (JSON.parse(licenseString));
  774.       const kty = jwkSet.keys[0].kty;
  775.       if (kty != 'oct') {
  776.         // Reject the promise.
  777.         this.updatePromise_.reject(new Error(
  778.             'Response is not a valid JSON Web Key Set.'));
  779.         this.updatePromise_ = null;
  780.       }
  781.       key = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].k);
  782.       keyId = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].kid);
  783.     } else {
  784.       // The key ID is not required.
  785.       key = shaka.util.BufferUtils.toUint8(response);
  786.       keyId = null;
  787.     }
  789.     const addKeyName = PatchedMediaKeysWebkit.prefixApi_('addKey');
  790.     try {
  791.       this.media_[addKeyName](this.keySystem_, key, keyId, this.sessionId);
  792.     } catch (exception) {
  793.       // Reject the promise.
  794.       this.updatePromise_.reject(exception);
  795.       this.updatePromise_ = null;
  796.     }
  797.   }
  799.   /**
  800.    * Update key status and dispatch a 'keystatuseschange' event.
  801.    *
  802.    * @param {string} status
  803.    * @private
  804.    */
  805.   updateKeyStatus_(status) {
  806.     this.keyStatuses.setStatus(status);
  807.     const event = new shaka.util.FakeEvent('keystatuseschange');
  808.     this.dispatchEvent(event);
  809.   }
  811.   /** @override */
  812.   generateRequest(initDataType, initData) {
  813.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generateRequest');
  814.     return this.generate_(initData, null);
  815.   }
  817.   /** @override */
  818.   load(sessionId) {
  819.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.load');
  820.     if (this.type_ == 'persistent-license') {
  821.       return this.generate_(null, sessionId);
  822.     } else {
  823.       return Promise.reject(new Error('Not a persistent session.'));
  824.     }
  825.   }
  827.   /** @override */
  828.   update(response) {
  829.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.update', response);
  830.     goog.asserts.assert(this.sessionId, 'update without session ID');
  832.     const nextUpdatePromise = new shaka.util.PublicPromise();
  833.     this.update_(nextUpdatePromise, response);
  834.     return nextUpdatePromise;
  835.   }
  837.   /** @override */
  838.   close() {
  839.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  841.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.close');
  843.     // This will remove a persistent session, but it's also the only way to free
  844.     // CDM resources on v0.1b.
  845.     if (this.type_ != 'persistent-license') {
  846.       // sessionId may reasonably be null if no key request has been generated
  847.       // yet.  Unprefixed EME will return a rejected promise in this case.  We
  848.       // will use the same error message that Chrome 41 uses in its EME
  849.       // implementation.
  850.       if (!this.sessionId) {
  851.         this.closed.reject(new Error('The session is not callable.'));
  852.         return this.closed;
  853.       }
  855.       // This may throw an exception, but we ignore it because we are only using
  856.       // it to clean up resources in v0.1b.  We still consider the session
  857.       // closed. We can't let the exception propagate because
  858.       // MediaKeySession.close() should not throw.
  859.       const cancelKeyRequestName =
  860.           PatchedMediaKeysWebkit.prefixApi_('cancelKeyRequest');
  861.       try {
  862.         this.media_[cancelKeyRequestName](this.keySystem_, this.sessionId);
  863.       } catch (exception) {
  864.         shaka.log.debug(`${cancelKeyRequestName} exception`, exception);
  865.       }
  866.     }
  868.     // Resolve the 'closed' promise and return it.
  869.     this.closed.resolve();
  870.     return this.closed;
  871.   }
  873.   /** @override */
  874.   remove() {
  875.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.remove');
  877.     if (this.type_ != 'persistent-license') {
  878.       return Promise.reject(new Error('Not a persistent session.'));
  879.     }
  881.     return this.close();
  882.   }
  883. };
  886. /**
  887.  * An implementation of MediaKeyStatusMap.
  888.  * This fakes a map with a single key ID.
  889.  *
  890.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  891.  * @implements {MediaKeyStatusMap}
  892.  */
  893. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap = class {
  894.   /** */
  895.   constructor() {
  896.     /**
  897.      * @type {number}
  898.      */
  899.     this.size = 0;
  901.     /**
  902.      * @private {string|undefined}
  903.      */
  904.     this.status_ = undefined;
  905.   }
  907.   /**
  908.    * An internal method used by the session to set key status.
  909.    * @param {string|undefined} status
  910.    */
  911.   setStatus(status) {
  912.     this.size = status == undefined ? 0 : 1;
  913.     this.status_ = status;
  914.   }
  916.   /**
  917.    * An internal method used by the session to get key status.
  918.    * @return {string|undefined}
  919.    */
  920.   getStatus() {
  921.     return this.status_;
  922.   }
  924.   /** @override */
  925.   forEach(fn) {
  926.     if (this.status_) {
  927.       fn(this.status_, shaka.util.DrmUtils.DUMMY_KEY_ID.value());
  928.     }
  929.   }
  931.   /** @override */
  932.   get(keyId) {
  933.     if (this.has(keyId)) {
  934.       return this.status_;
  935.     }
  936.     return undefined;
  937.   }
  939.   /** @override */
  940.   has(keyId) {
  941.     const fakeKeyId = shaka.util.DrmUtils.DUMMY_KEY_ID.value();
  942.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  943.       return true;
  944.     }
  945.     return false;
  946.   }
  948.   /**
  949.    * @suppress {missingReturn}
  950.    * @override
  951.    */
  952.   entries() {
  953.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  954.   }
  956.   /**
  957.    * @suppress {missingReturn}
  958.    * @override
  959.    */
  960.   keys() {
  961.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  962.   }
  964.   /**
  965.    * @suppress {missingReturn}
  966.    * @override
  967.    */
  968.   values() {
  969.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  970.   }
  971. };
  974. /**
  975.  * Store api prefix.
  976.  *
  977.  * @private {string}
  978.  */
  979. shaka.polyfill.PatchedMediaKeysWebkit.prefix_ = '';
  982. /**
  983.  * API name.
  984.  *
  985.  * @private {string}
  986.  */
  987. shaka.polyfill.PatchedMediaKeysWebkit.apiName_ = 'webkit';
  990. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysWebkit.install);