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.media.DrmEngine');
  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.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;
  75.   }
  77.   /**
  78.    * Prefix the api with the stored prefix.
  79.    *
  80.    * @param {string} api
  81.    * @return {string}
  82.    * @private
  83.    */
  84.   static prefixApi_(api) {
  85.     const prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  86.     if (prefix) {
  87.       return prefix + api.charAt(0).toUpperCase() + api.slice(1);
  88.     }
  89.     return api;
  90.   }
  92.   /**
  93.    * An implementation of navigator.requestMediaKeySystemAccess.
  94.    * Retrieves a MediaKeySystemAccess object.
  95.    *
  96.    * @this {!Navigator}
  97.    * @param {string} keySystem
  98.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  99.    * @return {!Promise.<!MediaKeySystemAccess>}
  100.    */
  101.   static requestMediaKeySystemAccess(keySystem, supportedConfigurations) {
  102.     shaka.log.debug('PatchedMediaKeysWebkit.requestMediaKeySystemAccess');
  103.     goog.asserts.assert(this == navigator,
  104.         'bad "this" for requestMediaKeySystemAccess');
  106.     // Alias.
  107.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  108.     try {
  109.       const access = new PatchedMediaKeysWebkit.MediaKeySystemAccess(
  110.           keySystem, supportedConfigurations);
  111.       return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  112.     } catch (exception) {
  113.       return Promise.reject(exception);
  114.     }
  115.   }
  117.   /**
  118.    * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  119.    * Attaches a MediaKeys object to the media element.
  120.    *
  121.    * @this {!HTMLMediaElement}
  122.    * @param {MediaKeys} mediaKeys
  123.    * @return {!Promise}
  124.    */
  125.   static setMediaKeys(mediaKeys) {
  126.     shaka.log.debug('PatchedMediaKeysWebkit.setMediaKeys');
  127.     goog.asserts.assert(this instanceof HTMLMediaElement,
  128.         'bad "this" for setMediaKeys');
  130.     // Alias.
  131.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  133.     const newMediaKeys =
  134.     /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  135.         mediaKeys);
  136.     const oldMediaKeys =
  137.     /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  138.         this.mediaKeys);
  140.     if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  141.       goog.asserts.assert(
  142.           oldMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  143.           'non-polyfill instance of oldMediaKeys');
  144.       // Have the old MediaKeys stop listening to events on the video tag.
  145.       oldMediaKeys.setMedia(null);
  146.     }
  148.     delete this['mediaKeys'];  // In case there is an existing getter.
  149.     this['mediaKeys'] = mediaKeys;  // Work around the read-only declaration.
  151.     if (newMediaKeys) {
  152.       goog.asserts.assert(
  153.           newMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  154.           'non-polyfill instance of newMediaKeys');
  155.       newMediaKeys.setMedia(this);
  156.     }
  158.     return Promise.resolve();
  159.   }
  161.   /**
  162.    * For some of this polyfill's implementation, we need to query a video
  163.    * element.  But for some embedded systems, it is memory-expensive to create
  164.    * multiple video elements.  Therefore, we check the document to see if we can
  165.    * borrow one to query before we fall back to creating one temporarily.
  166.    *
  167.    * @return {!HTMLVideoElement}
  168.    * @private
  169.    */
  170.   static getVideoElement_() {
  171.     const videos = document.getElementsByTagName('video');
  172.     const video = videos.length ? videos[0] : document.createElement('video');
  173.     return /** @type {!HTMLVideoElement} */(video);
  174.   }
  175. };
  178. /**
  179.  * An implementation of MediaKeySystemAccess.
  180.  *
  181.  * @implements {MediaKeySystemAccess}
  182.  */
  183. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess = class {
  184.   /**
  185.    * @param {string} keySystem
  186.    * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  187.    */
  188.   constructor(keySystem, supportedConfigurations) {
  189.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySystemAccess');
  191.     /** @type {string} */
  192.     this.keySystem = keySystem;
  194.     /** @private {string} */
  195.     this.internalKeySystem_ = keySystem;
  197.     /** @private {!MediaKeySystemConfiguration} */
  198.     this.configuration_;
  200.     // This is only a guess, since we don't really know from the prefixed API.
  201.     let allowPersistentState = false;
  203.     if (keySystem == 'org.w3.clearkey') {
  204.       // ClearKey's string must be prefixed in v0.1b.
  205.       this.internalKeySystem_ = 'webkit-org.w3.clearkey';
  206.       // ClearKey doesn't support persistence.
  207.       allowPersistentState = false;
  208.     }
  210.     let success = false;
  211.     const tmpVideo = shaka.polyfill.PatchedMediaKeysWebkit.getVideoElement_();
  212.     for (const cfg of supportedConfigurations) {
  213.       // Create a new config object and start adding in the pieces which we
  214.       // find support for.  We will return this from getConfiguration() if
  215.       // asked.
  216.       /** @type {!MediaKeySystemConfiguration} */
  217.       const newCfg = {
  218.         'audioCapabilities': [],
  219.         'videoCapabilities': [],
  220.         // It is technically against spec to return these as optional, but we
  221.         // don't truly know their values from the prefixed API:
  222.         'persistentState': 'optional',
  223.         'distinctiveIdentifier': 'optional',
  224.         // Pretend the requested init data types are supported, since we don't
  225.         // really know that either:
  226.         'initDataTypes': cfg.initDataTypes,
  227.         'sessionTypes': ['temporary'],
  228.         'label': cfg.label,
  229.       };
  231.       // v0.1b tests for key system availability with an extra argument on
  232.       // canPlayType.
  233.       let ranAnyTests = false;
  234.       if (cfg.audioCapabilities) {
  235.         for (const cap of cfg.audioCapabilities) {
  236.           if (cap.contentType) {
  237.             ranAnyTests = true;
  238.             // In Chrome <= 40, if you ask about Widevine-encrypted audio
  239.             // support, you get a false-negative when you specify codec
  240.             // information. Work around this by stripping codec info for audio
  241.             // types.
  242.             const contentType = cap.contentType.split(';')[0];
  243.             if (tmpVideo.canPlayType(contentType, this.internalKeySystem_)) {
  244.               newCfg.audioCapabilities.push(cap);
  245.               success = true;
  246.             }
  247.           }
  248.         }
  249.       }
  250.       if (cfg.videoCapabilities) {
  251.         for (const cap of cfg.videoCapabilities) {
  252.           if (cap.contentType) {
  253.             ranAnyTests = true;
  254.             if (tmpVideo.canPlayType(
  255.                 cap.contentType, this.internalKeySystem_)) {
  256.               newCfg.videoCapabilities.push(cap);
  257.               success = true;
  258.             }
  259.           }
  260.         }
  261.       }
  263.       if (!ranAnyTests) {
  264.         // If no specific types were requested, we check all common types to
  265.         // find out if the key system is present at all.
  266.         success =
  267.             tmpVideo.canPlayType('video/mp4', this.internalKeySystem_) ||
  268.             tmpVideo.canPlayType('video/webm', this.internalKeySystem_);
  269.       }
  270.       if (cfg.persistentState == 'required') {
  271.         if (allowPersistentState) {
  272.           newCfg.persistentState = 'required';
  273.           newCfg.sessionTypes = ['persistent-license'];
  274.         } else {
  275.           success = false;
  276.         }
  277.       }
  279.       if (success) {
  280.         this.configuration_ = newCfg;
  281.         return;
  282.       }
  283.     }  // for each cfg in supportedConfigurations
  285.     let message = 'Unsupported keySystem';
  286.     if (keySystem == 'org.w3.clearkey' || keySystem == 'com.widevine.alpha') {
  287.       message = 'None of the requested configurations were supported.';
  288.     }
  290.     // According to the spec, this should be a DOMException, but there is not a
  291.     // public constructor for that.  So we make this look-alike instead.
  292.     const unsupportedError = new Error(message);
  293.     unsupportedError.name = 'NotSupportedError';
  294.     unsupportedError['code'] = DOMException.NOT_SUPPORTED_ERR;
  295.     throw unsupportedError;
  296.   }
  298.   /** @override */
  299.   createMediaKeys() {
  300.     shaka.log.debug(
  301.         'PatchedMediaKeysWebkit.MediaKeySystemAccess.createMediaKeys');
  303.     // Alias.
  304.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  305.     const mediaKeys =
  306.     new PatchedMediaKeysWebkit.MediaKeys(this.internalKeySystem_);
  307.     return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  308.   }
  310.   /** @override */
  311.   getConfiguration() {
  312.     shaka.log.debug(
  313.         'PatchedMediaKeysWebkit.MediaKeySystemAccess.getConfiguration');
  314.     return this.configuration_;
  315.   }
  316. };
  319. /**
  320.  * An implementation of MediaKeys.
  321.  *
  322.  * @implements {MediaKeys}
  323.  */
  324. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys = class {
  325.   /**
  326.    * @param {string} keySystem
  327.    */
  328.   constructor(keySystem) {
  329.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys');
  331.     /** @private {string} */
  332.     this.keySystem_ = keySystem;
  334.     /** @private {HTMLMediaElement} */
  335.     this.media_ = null;
  337.     /** @private {!shaka.util.EventManager} */
  338.     this.eventManager_ = new shaka.util.EventManager();
  340.     /**
  341.      * @private {Array.<!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  342.      */
  343.     this.newSessions_ = [];
  345.     /**
  346.      * @private {!Map.<string,
  347.      *                 !shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  348.      */
  349.     this.sessionMap_ = new Map();
  350.   }
  352.   /**
  353.    * @param {HTMLMediaElement} media
  354.    * @protected
  355.    */
  356.   setMedia(media) {
  357.     this.media_ = media;
  359.     // Remove any old listeners.
  360.     this.eventManager_.removeAll();
  362.     const prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  363.     if (media) {
  364.       // Intercept and translate these prefixed EME events.
  365.       this.eventManager_.listen(media, prefix + 'needkey',
  366.       /** @type {shaka.util.EventManager.ListenerType} */ (
  367.             (event) => this.onWebkitNeedKey_(event)));
  369.       this.eventManager_.listen(media, prefix + 'keymessage',
  370.       /** @type {shaka.util.EventManager.ListenerType} */ (
  371.             (event) => this.onWebkitKeyMessage_(event)));
  373.       this.eventManager_.listen(media, prefix + 'keyadded',
  374.       /** @type {shaka.util.EventManager.ListenerType} */ (
  375.             (event) => this.onWebkitKeyAdded_(event)));
  377.       this.eventManager_.listen(media, prefix + 'keyerror',
  378.       /** @type {shaka.util.EventManager.ListenerType} */ (
  379.             (event) => this.onWebkitKeyError_(event)));
  380.     }
  381.   }
  383.   /** @override */
  384.   createSession(sessionType) {
  385.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.createSession');
  387.     sessionType = sessionType || 'temporary';
  388.     if (sessionType != 'temporary' && sessionType != 'persistent-license') {
  389.       throw new TypeError('Session type ' + sessionType +
  390.                       ' is unsupported on this platform.');
  391.     }
  393.     // Alias.
  394.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  396.     // Unprefixed EME allows for session creation without a video tag or src.
  397.     // Prefixed EME requires both a valid HTMLMediaElement and a src.
  398.     const media = this.media_ || /** @type {!HTMLMediaElement} */(
  399.       document.createElement('video'));
  400.     if (!media.src) {
  401.       media.src = 'about:blank';
  402.     }
  404.     const session = new PatchedMediaKeysWebkit.MediaKeySession(
  405.         media, this.keySystem_, sessionType);
  406.     this.newSessions_.push(session);
  407.     return session;
  408.   }
  410.   /** @override */
  411.   setServerCertificate(serverCertificate) {
  412.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.setServerCertificate');
  414.     // There is no equivalent in v0.1b, so return failure.
  415.     return Promise.resolve(false);
  416.   }
  418.   /**
  419.    * @param {!MediaKeyEvent} event
  420.    * @suppress {constantProperty} We reassign what would be const on a real
  421.    *   MediaEncryptedEvent, but in our look-alike event.
  422.    * @private
  423.    */
  424.   onWebkitNeedKey_(event) {
  425.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitNeedKey_', event);
  426.     goog.asserts.assert(this.media_, 'media_ not set in onWebkitNeedKey_');
  428.     const event2 = new CustomEvent('encrypted');
  429.     const encryptedEvent =
  430.       /** @type {!MediaEncryptedEvent} */(/** @type {?} */(event2));
  431.     // initDataType is not used by v0.1b EME, so any valid value is fine here.
  432.     encryptedEvent.initDataType = 'cenc';
  433.     encryptedEvent.initData = shaka.util.BufferUtils.toArrayBuffer(
  434.         event.initData);
  436.     this.media_.dispatchEvent(event2);
  437.   }
  439.   /**
  440.    * @param {!MediaKeyEvent} event
  441.    * @private
  442.    */
  443.   onWebkitKeyMessage_(event) {
  444.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyMessage_', event);
  446.     const session = this.findSession_(event.sessionId);
  447.     if (!session) {
  448.       shaka.log.error('Session not found', event.sessionId);
  449.       return;
  450.     }
  452.     const isNew = session.keyStatuses.getStatus() == undefined;
  454.     const data = new Map()
  455.         .set('messageType', isNew ? 'licenserequest' : 'licenserenewal')
  456.         .set('message', event.message);
  457.     const event2 = new shaka.util.FakeEvent('message', data);
  459.     session.generated();
  460.     session.dispatchEvent(event2);
  461.   }
  463.   /**
  464.    * @param {!MediaKeyEvent} event
  465.    * @private
  466.    */
  467.   onWebkitKeyAdded_(event) {
  468.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyAdded_', event);
  470.     const session = this.findSession_(event.sessionId);
  471.     goog.asserts.assert(
  472.         session, 'unable to find session in onWebkitKeyAdded_');
  473.     if (session) {
  474.       session.ready();
  475.     }
  476.   }
  478.   /**
  479.    * @param {!MediaKeyEvent} event
  480.    * @private
  481.    */
  482.   onWebkitKeyError_(event) {
  483.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyError_', event);
  485.     const session = this.findSession_(event.sessionId);
  486.     goog.asserts.assert(
  487.         session, 'unable to find session in onWebkitKeyError_');
  488.     if (session) {
  489.       session.handleError(event);
  490.     }
  491.   }
  493.   /**
  494.    * @param {string} sessionId
  495.    * @return {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession}
  496.    * @private
  497.    */
  498.   findSession_(sessionId) {
  499.     let session = this.sessionMap_.get(sessionId);
  500.     if (session) {
  501.       shaka.log.debug(
  502.           'PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  503.       return session;
  504.     }
  506.     session = this.newSessions_.shift();
  507.     if (session) {
  508.       session.sessionId = sessionId;
  509.       this.sessionMap_.set(sessionId, session);
  510.       shaka.log.debug(
  511.           'PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  512.       return session;
  513.     }
  515.     return null;
  516.   }
  517. };
  520. /**
  521.  * An implementation of MediaKeySession.
  522.  *
  523.  * @implements {MediaKeySession}
  524.  */
  525. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession =
  526. class extends shaka.util.FakeEventTarget {
  527.   /**
  528.    * @param {!HTMLMediaElement} media
  529.    * @param {string} keySystem
  530.    * @param {string} sessionType
  531.    */
  532.   constructor(media, keySystem, sessionType) {
  533.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession');
  534.     super();
  536.     /** @private {!HTMLMediaElement} */
  537.     this.media_ = media;
  539.     /** @private {boolean} */
  540.     this.initialized_ = false;
  542.     /** @private {shaka.util.PublicPromise} */
  543.     this.generatePromise_ = null;
  545.     /** @private {shaka.util.PublicPromise} */
  546.     this.updatePromise_ = null;
  548.     /** @private {string} */
  549.     this.keySystem_ = keySystem;
  551.     /** @private {string} */
  552.     this.type_ = sessionType;
  554.     /** @type {string} */
  555.     this.sessionId = '';
  557.     /** @type {number} */
  558.     this.expiration = NaN;
  560.     /** @type {!shaka.util.PublicPromise} */
  561.     this.closed = new shaka.util.PublicPromise();
  563.     /** @type {!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap} */
  564.     this.keyStatuses =
  565.         new shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap();
  566.   }
  568.   /**
  569.    * Signals that the license request has been generated.  This resolves the
  570.    * 'generateRequest' promise.
  571.    *
  572.    * @protected
  573.    */
  574.   generated() {
  575.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generated');
  577.     if (this.generatePromise_) {
  578.       this.generatePromise_.resolve();
  579.       this.generatePromise_ = null;
  580.     }
  581.   }
  583.   /**
  584.    * Signals that the session is 'ready', which is the terminology used in older
  585.    * versions of EME.  The new signal is to resolve the 'update' promise.  This
  586.    * translates between the two.
  587.    *
  588.    * @protected
  589.    */
  590.   ready() {
  591.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.ready');
  593.     this.updateKeyStatus_('usable');
  595.     if (this.updatePromise_) {
  596.       this.updatePromise_.resolve();
  597.     }
  598.     this.updatePromise_ = null;
  599.   }
  601.   /**
  602.    * Either rejects a promise, or dispatches an error event, as appropriate.
  603.    *
  604.    * @param {!MediaKeyEvent} event
  605.    */
  606.   handleError(event) {
  607.     shaka.log.debug(
  608.         'PatchedMediaKeysWebkit.MediaKeySession.handleError', event);
  610.     // This does not match the DOMException we get in current WD EME, but it
  611.     // will at least provide some information which can be used to look into the
  612.     // problem.
  613.     const error = new Error('EME v0.1b key error');
  614.     const errorCode = event.errorCode;
  615.     errorCode.systemCode = event.systemCode;
  616.     error['errorCode'] = errorCode;
  618.     // The presence or absence of sessionId indicates whether this corresponds
  619.     // to generateRequest() or update().
  620.     if (!event.sessionId && this.generatePromise_) {
  621.       if (event.systemCode == 45) {
  622.         error.message = 'Unsupported session type.';
  623.       }
  624.       this.generatePromise_.reject(error);
  625.       this.generatePromise_ = null;
  626.     } else if (event.sessionId && this.updatePromise_) {
  627.       this.updatePromise_.reject(error);
  628.       this.updatePromise_ = null;
  629.     } else {
  630.       // This mapping of key statuses is imperfect at best.
  631.       const code = event.errorCode.code;
  632.       const systemCode = event.systemCode;
  633.       if (code == MediaKeyError['MEDIA_KEYERR_OUTPUT']) {
  634.         this.updateKeyStatus_('output-restricted');
  635.       } else if (systemCode == 1) {
  636.         this.updateKeyStatus_('expired');
  637.       } else {
  638.         this.updateKeyStatus_('internal-error');
  639.       }
  640.     }
  641.   }
  643.   /**
  644.    * Logic which is shared between generateRequest() and load(), both of which
  645.    * are ultimately implemented with webkitGenerateKeyRequest in prefixed EME.
  646.    *
  647.    * @param {?BufferSource} initData
  648.    * @param {?string} offlineSessionId
  649.    * @return {!Promise}
  650.    * @private
  651.    */
  652.   generate_(initData, offlineSessionId) {
  653.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  655.     if (this.initialized_) {
  656.       const error = new Error('The session is already initialized.');
  657.       return Promise.reject(error);
  658.     }
  660.     this.initialized_ = true;
  662.     /** @type {!Uint8Array} */
  663.     let mangledInitData;
  665.     try {
  666.       if (this.type_ == 'persistent-license') {
  667.         const StringUtils = shaka.util.StringUtils;
  668.         if (!offlineSessionId) {
  669.           goog.asserts.assert(initData, 'expecting init data');
  670.           // Persisting the initial license.
  671.           // Prefix the init data with a tag to indicate persistence.
  672.           const prefix = StringUtils.toUTF8('PERSISTENT|');
  673.           mangledInitData = shaka.util.Uint8ArrayUtils.concat(prefix, initData);
  674.         } else {
  675.           // Loading a stored license.
  676.           // Prefix the init data (which is really a session ID) with a tag to
  677.           // indicate that we are loading a persisted session.
  678.           mangledInitData = shaka.util.BufferUtils.toUint8(
  679.               StringUtils.toUTF8('LOAD_SESSION|' + offlineSessionId));
  680.         }
  681.       } else {
  682.         // Streaming.
  683.         goog.asserts.assert(this.type_ == 'temporary',
  684.             'expected temporary session');
  685.         goog.asserts.assert(!offlineSessionId,
  686.             'unexpected offline session ID');
  687.         goog.asserts.assert(initData, 'expecting init data');
  688.         mangledInitData = shaka.util.BufferUtils.toUint8(initData);
  689.       }
  691.       goog.asserts.assert(mangledInitData, 'init data not set!');
  692.     } catch (exception) {
  693.       return Promise.reject(exception);
  694.     }
  696.     goog.asserts.assert(this.generatePromise_ == null,
  697.         'generatePromise_ should be null');
  698.     this.generatePromise_ = new shaka.util.PublicPromise();
  700.     // Because we are hacking media.src in createSession to better emulate
  701.     // unprefixed EME's ability to create sessions and license requests without
  702.     // a video tag, we can get ourselves into trouble.  It seems that sometimes,
  703.     // the setting of media.src hasn't been processed by some other thread, and
  704.     // GKR can throw an exception.  If this occurs, wait 10 ms and try again at
  705.     // most once.  This situation should only occur when init data is available
  706.     // ahead of the 'needkey' event.
  708.     const generateKeyRequestName =
  709.         PatchedMediaKeysWebkit.prefixApi_('generateKeyRequest');
  710.     try {
  711.       this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  712.     } catch (exception) {
  713.       if (exception.name != 'InvalidStateError') {
  714.         this.generatePromise_ = null;
  715.         return Promise.reject(exception);
  716.       }
  718.       const timer = new shaka.util.Timer(() => {
  719.         try {
  720.           this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  721.         } catch (exception2) {
  722.           this.generatePromise_.reject(exception2);
  723.           this.generatePromise_ = null;
  724.         }
  725.       });
  727.       timer.tickAfter(/* seconds= */ 0.01);
  728.     }
  730.     return this.generatePromise_;
  731.   }
  733.   /**
  734.    * An internal version of update which defers new calls while old ones are in
  735.    * progress.
  736.    *
  737.    * @param {!shaka.util.PublicPromise} promise  The promise associated with
  738.    *   this call.
  739.    * @param {BufferSource} response
  740.    * @private
  741.    */
  742.   update_(promise, response) {
  743.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  745.     if (this.updatePromise_) {
  746.       // We already have an update in-progress, so defer this one until after
  747.       // the old one is resolved.  Execute this whether the original one
  748.       // succeeds or fails.
  749.       this.updatePromise_.then(() => this.update_(promise, response))
  750.           .catch(() => this.update_(promise, response));
  751.       return;
  752.     }
  754.     this.updatePromise_ = promise;
  756.     let key;
  757.     let keyId;
  759.     if (this.keySystem_ == 'webkit-org.w3.clearkey') {
  760.       // The current EME version of clearkey wants a structured JSON response.
  761.       // The v0.1b version wants just a raw key.  Parse the JSON response and
  762.       // extract the key and key ID.
  763.       const StringUtils = shaka.util.StringUtils;
  764.       const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  765.       const licenseString = StringUtils.fromUTF8(response);
  766.       const jwkSet = /** @type {JWKSet} */ (JSON.parse(licenseString));
  767.       const kty = jwkSet.keys[0].kty;
  768.       if (kty != 'oct') {
  769.         // Reject the promise.
  770.         this.updatePromise_.reject(new Error(
  771.             'Response is not a valid JSON Web Key Set.'));
  772.         this.updatePromise_ = null;
  773.       }
  774.       key = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].k);
  775.       keyId = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].kid);
  776.     } else {
  777.       // The key ID is not required.
  778.       key = shaka.util.BufferUtils.toUint8(response);
  779.       keyId = null;
  780.     }
  782.     const addKeyName = PatchedMediaKeysWebkit.prefixApi_('addKey');
  783.     try {
  784.       this.media_[addKeyName](this.keySystem_, key, keyId, this.sessionId);
  785.     } catch (exception) {
  786.       // Reject the promise.
  787.       this.updatePromise_.reject(exception);
  788.       this.updatePromise_ = null;
  789.     }
  790.   }
  792.   /**
  793.    * Update key status and dispatch a 'keystatuseschange' event.
  794.    *
  795.    * @param {string} status
  796.    * @private
  797.    */
  798.   updateKeyStatus_(status) {
  799.     this.keyStatuses.setStatus(status);
  800.     const event = new shaka.util.FakeEvent('keystatuseschange');
  801.     this.dispatchEvent(event);
  802.   }
  804.   /** @override */
  805.   generateRequest(initDataType, initData) {
  806.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generateRequest');
  807.     return this.generate_(initData, null);
  808.   }
  810.   /** @override */
  811.   load(sessionId) {
  812.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.load');
  813.     if (this.type_ == 'persistent-license') {
  814.       return this.generate_(null, sessionId);
  815.     } else {
  816.       return Promise.reject(new Error('Not a persistent session.'));
  817.     }
  818.   }
  820.   /** @override */
  821.   update(response) {
  822.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.update', response);
  823.     goog.asserts.assert(this.sessionId, 'update without session ID');
  825.     const nextUpdatePromise = new shaka.util.PublicPromise();
  826.     this.update_(nextUpdatePromise, response);
  827.     return nextUpdatePromise;
  828.   }
  830.   /** @override */
  831.   close() {
  832.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  834.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.close');
  836.     // This will remove a persistent session, but it's also the only way to free
  837.     // CDM resources on v0.1b.
  838.     if (this.type_ != 'persistent-license') {
  839.       // sessionId may reasonably be null if no key request has been generated
  840.       // yet.  Unprefixed EME will return a rejected promise in this case.  We
  841.       // will use the same error message that Chrome 41 uses in its EME
  842.       // implementation.
  843.       if (!this.sessionId) {
  844.         this.closed.reject(new Error('The session is not callable.'));
  845.         return this.closed;
  846.       }
  848.       // This may throw an exception, but we ignore it because we are only using
  849.       // it to clean up resources in v0.1b.  We still consider the session
  850.       // closed. We can't let the exception propagate because
  851.       // MediaKeySession.close() should not throw.
  852.       const cancelKeyRequestName =
  853.           PatchedMediaKeysWebkit.prefixApi_('cancelKeyRequest');
  854.       try {
  855.         this.media_[cancelKeyRequestName](this.keySystem_, this.sessionId);
  856.       } catch (exception) {}
  857.     }
  859.     // Resolve the 'closed' promise and return it.
  860.     this.closed.resolve();
  861.     return this.closed;
  862.   }
  864.   /** @override */
  865.   remove() {
  866.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.remove');
  868.     if (this.type_ != 'persistent-license') {
  869.       return Promise.reject(new Error('Not a persistent session.'));
  870.     }
  872.     return this.close();
  873.   }
  874. };
  877. /**
  878.  * An implementation of MediaKeyStatusMap.
  879.  * This fakes a map with a single key ID.
  880.  *
  881.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  882.  * @implements {MediaKeyStatusMap}
  883.  */
  884. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap = class {
  885.   /** */
  886.   constructor() {
  887.     /**
  888.      * @type {number}
  889.      */
  890.     this.size = 0;
  892.     /**
  893.      * @private {string|undefined}
  894.      */
  895.     this.status_ = undefined;
  896.   }
  898.   /**
  899.    * An internal method used by the session to set key status.
  900.    * @param {string|undefined} status
  901.    */
  902.   setStatus(status) {
  903.     this.size = status == undefined ? 0 : 1;
  904.     this.status_ = status;
  905.   }
  907.   /**
  908.    * An internal method used by the session to get key status.
  909.    * @return {string|undefined}
  910.    */
  911.   getStatus() {
  912.     return this.status_;
  913.   }
  915.   /** @override */
  916.   forEach(fn) {
  917.     if (this.status_) {
  918.       fn(this.status_, shaka.media.DrmEngine.DUMMY_KEY_ID.value());
  919.     }
  920.   }
  922.   /** @override */
  923.   get(keyId) {
  924.     if (this.has(keyId)) {
  925.       return this.status_;
  926.     }
  927.     return undefined;
  928.   }
  930.   /** @override */
  931.   has(keyId) {
  932.     const fakeKeyId = shaka.media.DrmEngine.DUMMY_KEY_ID.value();
  933.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  934.       return true;
  935.     }
  936.     return false;
  937.   }
  939.   /**
  940.    * @suppress {missingReturn}
  941.    * @override
  942.    */
  943.   entries() {
  944.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  945.   }
  947.   /**
  948.    * @suppress {missingReturn}
  949.    * @override
  950.    */
  951.   keys() {
  952.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  953.   }
  955.   /**
  956.    * @suppress {missingReturn}
  957.    * @override
  958.    */
  959.   values() {
  960.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  961.   }
  962. };
  965. /**
  966.  * Store api prefix.
  967.  *
  968.  * @private {string}
  969.  */
  970. shaka.polyfill.PatchedMediaKeysWebkit.prefix_ = '';
  973. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysWebkit.install);