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;
  76.     window.shakaMediaKeysPolyfill = true;
  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.   /**
  421.    * @param {!MediaKeyEvent} event
  422.    * @suppress {constantProperty} We reassign what would be const on a real
  423.    *   MediaEncryptedEvent, but in our look-alike event.
  424.    * @private
  425.    */
  426.   onWebkitNeedKey_(event) {
  427.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitNeedKey_', event);
  428.     goog.asserts.assert(this.media_, 'media_ not set in onWebkitNeedKey_');
  430.     const event2 = new CustomEvent('encrypted');
  431.     const encryptedEvent =
  432.       /** @type {!MediaEncryptedEvent} */(/** @type {?} */(event2));
  433.     // initDataType is not used by v0.1b EME, so any valid value is fine here.
  434.     encryptedEvent.initDataType = 'cenc';
  435.     encryptedEvent.initData = shaka.util.BufferUtils.toArrayBuffer(
  436.         event.initData);
  438.     this.media_.dispatchEvent(event2);
  439.   }
  441.   /**
  442.    * @param {!MediaKeyEvent} event
  443.    * @private
  444.    */
  445.   onWebkitKeyMessage_(event) {
  446.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyMessage_', event);
  448.     const session = this.findSession_(event.sessionId);
  449.     if (!session) {
  450.       shaka.log.error('Session not found', event.sessionId);
  451.       return;
  452.     }
  454.     const isNew = session.keyStatuses.getStatus() == undefined;
  456.     const data = new Map()
  457.         .set('messageType', isNew ? 'licenserequest' : 'licenserenewal')
  458.         .set('message', event.message);
  459.     const event2 = new shaka.util.FakeEvent('message', data);
  461.     session.generated();
  462.     session.dispatchEvent(event2);
  463.   }
  465.   /**
  466.    * @param {!MediaKeyEvent} event
  467.    * @private
  468.    */
  469.   onWebkitKeyAdded_(event) {
  470.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyAdded_', event);
  472.     const session = this.findSession_(event.sessionId);
  473.     goog.asserts.assert(
  474.         session, 'unable to find session in onWebkitKeyAdded_');
  475.     if (session) {
  476.       session.ready();
  477.     }
  478.   }
  480.   /**
  481.    * @param {!MediaKeyEvent} event
  482.    * @private
  483.    */
  484.   onWebkitKeyError_(event) {
  485.     shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyError_', event);
  487.     const session = this.findSession_(event.sessionId);
  488.     goog.asserts.assert(
  489.         session, 'unable to find session in onWebkitKeyError_');
  490.     if (session) {
  491.       session.handleError(event);
  492.     }
  493.   }
  495.   /**
  496.    * @param {string} sessionId
  497.    * @return {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession}
  498.    * @private
  499.    */
  500.   findSession_(sessionId) {
  501.     let session = this.sessionMap_.get(sessionId);
  502.     if (session) {
  503.       shaka.log.debug(
  504.           'PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  505.       return session;
  506.     }
  508.     session = this.newSessions_.shift();
  509.     if (session) {
  510.       session.sessionId = sessionId;
  511.       this.sessionMap_.set(sessionId, session);
  512.       shaka.log.debug(
  513.           'PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  514.       return session;
  515.     }
  517.     return null;
  518.   }
  519. };
  522. /**
  523.  * An implementation of MediaKeySession.
  524.  *
  525.  * @implements {MediaKeySession}
  526.  */
  527. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession =
  528. class extends shaka.util.FakeEventTarget {
  529.   /**
  530.    * @param {!HTMLMediaElement} media
  531.    * @param {string} keySystem
  532.    * @param {string} sessionType
  533.    */
  534.   constructor(media, keySystem, sessionType) {
  535.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession');
  536.     super();
  538.     /** @private {!HTMLMediaElement} */
  539.     this.media_ = media;
  541.     /** @private {boolean} */
  542.     this.initialized_ = false;
  544.     /** @private {shaka.util.PublicPromise} */
  545.     this.generatePromise_ = null;
  547.     /** @private {shaka.util.PublicPromise} */
  548.     this.updatePromise_ = null;
  550.     /** @private {string} */
  551.     this.keySystem_ = keySystem;
  553.     /** @private {string} */
  554.     this.type_ = sessionType;
  556.     /** @type {string} */
  557.     this.sessionId = '';
  559.     /** @type {number} */
  560.     this.expiration = NaN;
  562.     /** @type {!shaka.util.PublicPromise} */
  563.     this.closed = new shaka.util.PublicPromise();
  565.     /** @type {!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap} */
  566.     this.keyStatuses =
  567.         new shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap();
  568.   }
  570.   /**
  571.    * Signals that the license request has been generated.  This resolves the
  572.    * 'generateRequest' promise.
  573.    *
  574.    * @protected
  575.    */
  576.   generated() {
  577.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generated');
  579.     if (this.generatePromise_) {
  580.       this.generatePromise_.resolve();
  581.       this.generatePromise_ = null;
  582.     }
  583.   }
  585.   /**
  586.    * Signals that the session is 'ready', which is the terminology used in older
  587.    * versions of EME.  The new signal is to resolve the 'update' promise.  This
  588.    * translates between the two.
  589.    *
  590.    * @protected
  591.    */
  592.   ready() {
  593.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.ready');
  595.     this.updateKeyStatus_('usable');
  597.     if (this.updatePromise_) {
  598.       this.updatePromise_.resolve();
  599.     }
  600.     this.updatePromise_ = null;
  601.   }
  603.   /**
  604.    * Either rejects a promise, or dispatches an error event, as appropriate.
  605.    *
  606.    * @param {!MediaKeyEvent} event
  607.    */
  608.   handleError(event) {
  609.     shaka.log.debug(
  610.         'PatchedMediaKeysWebkit.MediaKeySession.handleError', event);
  612.     // This does not match the DOMException we get in current WD EME, but it
  613.     // will at least provide some information which can be used to look into the
  614.     // problem.
  615.     const error = new Error('EME v0.1b key error');
  616.     const errorCode = event.errorCode;
  617.     errorCode.systemCode = event.systemCode;
  618.     error['errorCode'] = errorCode;
  620.     // The presence or absence of sessionId indicates whether this corresponds
  621.     // to generateRequest() or update().
  622.     if (!event.sessionId && this.generatePromise_) {
  623.       if (event.systemCode == 45) {
  624.         error.message = 'Unsupported session type.';
  625.       }
  626.       this.generatePromise_.reject(error);
  627.       this.generatePromise_ = null;
  628.     } else if (event.sessionId && this.updatePromise_) {
  629.       this.updatePromise_.reject(error);
  630.       this.updatePromise_ = null;
  631.     } else {
  632.       // This mapping of key statuses is imperfect at best.
  633.       const code = event.errorCode.code;
  634.       const systemCode = event.systemCode;
  635.       if (code == MediaKeyError['MEDIA_KEYERR_OUTPUT']) {
  636.         this.updateKeyStatus_('output-restricted');
  637.       } else if (systemCode == 1) {
  638.         this.updateKeyStatus_('expired');
  639.       } else {
  640.         this.updateKeyStatus_('internal-error');
  641.       }
  642.     }
  643.   }
  645.   /**
  646.    * Logic which is shared between generateRequest() and load(), both of which
  647.    * are ultimately implemented with webkitGenerateKeyRequest in prefixed EME.
  648.    *
  649.    * @param {?BufferSource} initData
  650.    * @param {?string} offlineSessionId
  651.    * @return {!Promise}
  652.    * @private
  653.    */
  654.   generate_(initData, offlineSessionId) {
  655.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  657.     if (this.initialized_) {
  658.       const error = new Error('The session is already initialized.');
  659.       return Promise.reject(error);
  660.     }
  662.     this.initialized_ = true;
  664.     /** @type {!Uint8Array} */
  665.     let mangledInitData;
  667.     try {
  668.       if (this.type_ == 'persistent-license') {
  669.         const StringUtils = shaka.util.StringUtils;
  670.         if (!offlineSessionId) {
  671.           goog.asserts.assert(initData, 'expecting init data');
  672.           // Persisting the initial license.
  673.           // Prefix the init data with a tag to indicate persistence.
  674.           const prefix = StringUtils.toUTF8('PERSISTENT|');
  675.           mangledInitData = shaka.util.Uint8ArrayUtils.concat(prefix, initData);
  676.         } else {
  677.           // Loading a stored license.
  678.           // Prefix the init data (which is really a session ID) with a tag to
  679.           // indicate that we are loading a persisted session.
  680.           mangledInitData = shaka.util.BufferUtils.toUint8(
  681.               StringUtils.toUTF8('LOAD_SESSION|' + offlineSessionId));
  682.         }
  683.       } else {
  684.         // Streaming.
  685.         goog.asserts.assert(this.type_ == 'temporary',
  686.             'expected temporary session');
  687.         goog.asserts.assert(!offlineSessionId,
  688.             'unexpected offline session ID');
  689.         goog.asserts.assert(initData, 'expecting init data');
  690.         mangledInitData = shaka.util.BufferUtils.toUint8(initData);
  691.       }
  693.       goog.asserts.assert(mangledInitData, 'init data not set!');
  694.     } catch (exception) {
  695.       return Promise.reject(exception);
  696.     }
  698.     goog.asserts.assert(this.generatePromise_ == null,
  699.         'generatePromise_ should be null');
  700.     this.generatePromise_ = new shaka.util.PublicPromise();
  702.     // Because we are hacking media.src in createSession to better emulate
  703.     // unprefixed EME's ability to create sessions and license requests without
  704.     // a video tag, we can get ourselves into trouble.  It seems that sometimes,
  705.     // the setting of media.src hasn't been processed by some other thread, and
  706.     // GKR can throw an exception.  If this occurs, wait 10 ms and try again at
  707.     // most once.  This situation should only occur when init data is available
  708.     // ahead of the 'needkey' event.
  710.     const generateKeyRequestName =
  711.         PatchedMediaKeysWebkit.prefixApi_('generateKeyRequest');
  712.     try {
  713.       this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  714.     } catch (exception) {
  715.       if (exception.name != 'InvalidStateError') {
  716.         this.generatePromise_ = null;
  717.         return Promise.reject(exception);
  718.       }
  720.       const timer = new shaka.util.Timer(() => {
  721.         try {
  722.           this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  723.         } catch (exception2) {
  724.           this.generatePromise_.reject(exception2);
  725.           this.generatePromise_ = null;
  726.         }
  727.       });
  729.       timer.tickAfter(/* seconds= */ 0.01);
  730.     }
  732.     return this.generatePromise_;
  733.   }
  735.   /**
  736.    * An internal version of update which defers new calls while old ones are in
  737.    * progress.
  738.    *
  739.    * @param {!shaka.util.PublicPromise} promise  The promise associated with
  740.    *   this call.
  741.    * @param {BufferSource} response
  742.    * @private
  743.    */
  744.   update_(promise, response) {
  745.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  747.     if (this.updatePromise_) {
  748.       // We already have an update in-progress, so defer this one until after
  749.       // the old one is resolved.  Execute this whether the original one
  750.       // succeeds or fails.
  751.       this.updatePromise_.then(() => this.update_(promise, response))
  752.           .catch(() => this.update_(promise, response));
  753.       return;
  754.     }
  756.     this.updatePromise_ = promise;
  758.     let key;
  759.     let keyId;
  761.     if (this.keySystem_ == 'webkit-org.w3.clearkey') {
  762.       // The current EME version of clearkey wants a structured JSON response.
  763.       // The v0.1b version wants just a raw key.  Parse the JSON response and
  764.       // extract the key and key ID.
  765.       const StringUtils = shaka.util.StringUtils;
  766.       const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  767.       const licenseString = StringUtils.fromUTF8(response);
  768.       const jwkSet = /** @type {JWKSet} */ (JSON.parse(licenseString));
  769.       const kty = jwkSet.keys[0].kty;
  770.       if (kty != 'oct') {
  771.         // Reject the promise.
  772.         this.updatePromise_.reject(new Error(
  773.             'Response is not a valid JSON Web Key Set.'));
  774.         this.updatePromise_ = null;
  775.       }
  776.       key = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].k);
  777.       keyId = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].kid);
  778.     } else {
  779.       // The key ID is not required.
  780.       key = shaka.util.BufferUtils.toUint8(response);
  781.       keyId = null;
  782.     }
  784.     const addKeyName = PatchedMediaKeysWebkit.prefixApi_('addKey');
  785.     try {
  786.       this.media_[addKeyName](this.keySystem_, key, keyId, this.sessionId);
  787.     } catch (exception) {
  788.       // Reject the promise.
  789.       this.updatePromise_.reject(exception);
  790.       this.updatePromise_ = null;
  791.     }
  792.   }
  794.   /**
  795.    * Update key status and dispatch a 'keystatuseschange' event.
  796.    *
  797.    * @param {string} status
  798.    * @private
  799.    */
  800.   updateKeyStatus_(status) {
  801.     this.keyStatuses.setStatus(status);
  802.     const event = new shaka.util.FakeEvent('keystatuseschange');
  803.     this.dispatchEvent(event);
  804.   }
  806.   /** @override */
  807.   generateRequest(initDataType, initData) {
  808.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generateRequest');
  809.     return this.generate_(initData, null);
  810.   }
  812.   /** @override */
  813.   load(sessionId) {
  814.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.load');
  815.     if (this.type_ == 'persistent-license') {
  816.       return this.generate_(null, sessionId);
  817.     } else {
  818.       return Promise.reject(new Error('Not a persistent session.'));
  819.     }
  820.   }
  822.   /** @override */
  823.   update(response) {
  824.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.update', response);
  825.     goog.asserts.assert(this.sessionId, 'update without session ID');
  827.     const nextUpdatePromise = new shaka.util.PublicPromise();
  828.     this.update_(nextUpdatePromise, response);
  829.     return nextUpdatePromise;
  830.   }
  832.   /** @override */
  833.   close() {
  834.     const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  836.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.close');
  838.     // This will remove a persistent session, but it's also the only way to free
  839.     // CDM resources on v0.1b.
  840.     if (this.type_ != 'persistent-license') {
  841.       // sessionId may reasonably be null if no key request has been generated
  842.       // yet.  Unprefixed EME will return a rejected promise in this case.  We
  843.       // will use the same error message that Chrome 41 uses in its EME
  844.       // implementation.
  845.       if (!this.sessionId) {
  846.         this.closed.reject(new Error('The session is not callable.'));
  847.         return this.closed;
  848.       }
  850.       // This may throw an exception, but we ignore it because we are only using
  851.       // it to clean up resources in v0.1b.  We still consider the session
  852.       // closed. We can't let the exception propagate because
  853.       // MediaKeySession.close() should not throw.
  854.       const cancelKeyRequestName =
  855.           PatchedMediaKeysWebkit.prefixApi_('cancelKeyRequest');
  856.       try {
  857.         this.media_[cancelKeyRequestName](this.keySystem_, this.sessionId);
  858.       } catch (exception) {}
  859.     }
  861.     // Resolve the 'closed' promise and return it.
  862.     this.closed.resolve();
  863.     return this.closed;
  864.   }
  866.   /** @override */
  867.   remove() {
  868.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.remove');
  870.     if (this.type_ != 'persistent-license') {
  871.       return Promise.reject(new Error('Not a persistent session.'));
  872.     }
  874.     return this.close();
  875.   }
  876. };
  879. /**
  880.  * An implementation of MediaKeyStatusMap.
  881.  * This fakes a map with a single key ID.
  882.  *
  883.  * @todo Consolidate the MediaKeyStatusMap types in these polyfills.
  884.  * @implements {MediaKeyStatusMap}
  885.  */
  886. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap = class {
  887.   /** */
  888.   constructor() {
  889.     /**
  890.      * @type {number}
  891.      */
  892.     this.size = 0;
  894.     /**
  895.      * @private {string|undefined}
  896.      */
  897.     this.status_ = undefined;
  898.   }
  900.   /**
  901.    * An internal method used by the session to set key status.
  902.    * @param {string|undefined} status
  903.    */
  904.   setStatus(status) {
  905.     this.size = status == undefined ? 0 : 1;
  906.     this.status_ = status;
  907.   }
  909.   /**
  910.    * An internal method used by the session to get key status.
  911.    * @return {string|undefined}
  912.    */
  913.   getStatus() {
  914.     return this.status_;
  915.   }
  917.   /** @override */
  918.   forEach(fn) {
  919.     if (this.status_) {
  920.       fn(this.status_, shaka.media.DrmEngine.DUMMY_KEY_ID.value());
  921.     }
  922.   }
  924.   /** @override */
  925.   get(keyId) {
  926.     if (this.has(keyId)) {
  927.       return this.status_;
  928.     }
  929.     return undefined;
  930.   }
  932.   /** @override */
  933.   has(keyId) {
  934.     const fakeKeyId = shaka.media.DrmEngine.DUMMY_KEY_ID.value();
  935.     if (this.status_ && shaka.util.BufferUtils.equal(keyId, fakeKeyId)) {
  936.       return true;
  937.     }
  938.     return false;
  939.   }
  941.   /**
  942.    * @suppress {missingReturn}
  943.    * @override
  944.    */
  945.   entries() {
  946.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  947.   }
  949.   /**
  950.    * @suppress {missingReturn}
  951.    * @override
  952.    */
  953.   keys() {
  954.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  955.   }
  957.   /**
  958.    * @suppress {missingReturn}
  959.    * @override
  960.    */
  961.   values() {
  962.     goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  963.   }
  964. };
  967. /**
  968.  * Store api prefix.
  969.  *
  970.  * @private {string}
  971.  */
  972. shaka.polyfill.PatchedMediaKeysWebkit.prefix_ = '';
  975. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysWebkit.install);