Source: lib/polyfill/patchedmediakeys_webkit.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.polyfill.PatchedMediaKeysWebkit');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.polyfill.register');
  23. goog.require('shaka.util.EventManager');
  24. goog.require('shaka.util.FakeEvent');
  25. goog.require('shaka.util.FakeEventTarget');
  26. goog.require('shaka.util.PublicPromise');
  27. goog.require('shaka.util.StringUtils');
  28. goog.require('shaka.util.Uint8ArrayUtils');
  31. /**
  32.  * @namespace shaka.polyfill.PatchedMediaKeysWebkit
  33.  *
  34.  * @summary A polyfill to implement
  35.  * {@link http://goo.gl/blgtZZ EME draft 12 March 2015} on top of
  36.  * webkit-prefixed {@link http://goo.gl/FSpoAo EME v0.1b}.
  37.  */
  40. /**
  41.  * Store api prefix.
  42.  *
  43.  * @private {string}
  44.  */
  45. shaka.polyfill.PatchedMediaKeysWebkit.prefix_ = '';
  48. /**
  49.  * Installs the polyfill if needed.
  50.  */
  51. shaka.polyfill.PatchedMediaKeysWebkit.install = function() {
  52.   // Alias.
  53.   const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  54.   const prefixApi = PatchedMediaKeysWebkit.prefixApi_;
  56.   if (!window.HTMLVideoElement ||
  57.       (navigator.requestMediaKeySystemAccess &&
  58.        MediaKeySystemAccess.prototype.getConfiguration)) {
  59.     return;
  60.   }
  61.   if (HTMLMediaElement.prototype.webkitGenerateKeyRequest) {
  62.     shaka.log.info('Using webkit-prefixed EME v0.1b');
  63.     PatchedMediaKeysWebkit.prefix_ = 'webkit';
  64.   } else if (HTMLMediaElement.prototype.generateKeyRequest) {
  65.     shaka.log.info('Using nonprefixed EME v0.1b');
  66.   } else {
  67.     return;
  68.   }
  70.   goog.asserts.assert(
  71.       HTMLMediaElement.prototype[prefixApi('generateKeyRequest')],
  72.                       'PatchedMediaKeysWebkit APIs not available!');
  74.   // Construct a fake key ID.  This is not done at load-time to avoid exceptions
  75.   // on unsupported browsers.  This particular fake key ID was suggested in
  76.   // w3c/encrypted-media#32.
  77.   PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_ =
  78.       (new Uint8Array([0])).buffer;
  80.   // Install patches.
  81.   navigator.requestMediaKeySystemAccess =
  82.       PatchedMediaKeysWebkit.requestMediaKeySystemAccess;
  83.   // Delete mediaKeys to work around strict mode compatibility issues.
  84.   delete HTMLMediaElement.prototype['mediaKeys'];
  85.   // Work around read-only declaration for mediaKeys by using a string.
  86.   HTMLMediaElement.prototype['mediaKeys'] = null;
  87.   HTMLMediaElement.prototype.setMediaKeys = PatchedMediaKeysWebkit.setMediaKeys;
  88.   window.MediaKeys = PatchedMediaKeysWebkit.MediaKeys;
  89.   window.MediaKeySystemAccess = PatchedMediaKeysWebkit.MediaKeySystemAccess;
  90. };
  93. /**
  94.  * Prefix the api with the stored prefix.
  95.  *
  96.  * @param {string} api
  97.  * @return {string}
  98.  * @private
  99.  */
  100. shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_ = function(api) {
  101.   let prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  102.   if (prefix) {
  103.     return prefix + api.charAt(0).toUpperCase() + api.slice(1);
  104.   }
  105.   return api;
  106. };
  109. /**
  110.  * An implementation of navigator.requestMediaKeySystemAccess.
  111.  * Retrieves a MediaKeySystemAccess object.
  112.  *
  113.  * @this {!Navigator}
  114.  * @param {string} keySystem
  115.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  116.  * @return {!Promise.<!MediaKeySystemAccess>}
  117.  */
  118. shaka.polyfill.PatchedMediaKeysWebkit.requestMediaKeySystemAccess =
  119.     function(keySystem, supportedConfigurations) {
  120.   shaka.log.debug('PatchedMediaKeysWebkit.requestMediaKeySystemAccess');
  121.   goog.asserts.assert(this == navigator,
  122.                       'bad "this" for requestMediaKeySystemAccess');
  124.   // Alias.
  125.   const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  126.   try {
  127.     let access = new PatchedMediaKeysWebkit.MediaKeySystemAccess(
  128.         keySystem, supportedConfigurations);
  129.     return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  130.   } catch (exception) {
  131.     return Promise.reject(exception);
  132.   }
  133. };
  136. /**
  137.  * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  138.  * Attaches a MediaKeys object to the media element.
  139.  *
  140.  * @this {!HTMLMediaElement}
  141.  * @param {MediaKeys} mediaKeys
  142.  * @return {!Promise}
  143.  */
  144. shaka.polyfill.PatchedMediaKeysWebkit.setMediaKeys = function(mediaKeys) {
  145.   shaka.log.debug('PatchedMediaKeysWebkit.setMediaKeys');
  146.   goog.asserts.assert(this instanceof HTMLMediaElement,
  147.                       'bad "this" for setMediaKeys');
  149.   // Alias.
  150.   const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  152.   let newMediaKeys =
  153.       /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  154.           mediaKeys);
  155.   let oldMediaKeys =
  156.       /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  157.           this.mediaKeys);
  159.   if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  160.     goog.asserts.assert(
  161.         oldMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  162.         'non-polyfill instance of oldMediaKeys');
  163.     // Have the old MediaKeys stop listening to events on the video tag.
  164.     oldMediaKeys.setMedia(null);
  165.   }
  167.   delete this['mediaKeys'];  // In case there is an existing getter.
  168.   this['mediaKeys'] = mediaKeys;  // Work around the read-only declaration.
  170.   if (newMediaKeys) {
  171.     goog.asserts.assert(
  172.         newMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  173.         'non-polyfill instance of newMediaKeys');
  174.     newMediaKeys.setMedia(this);
  175.   }
  177.   return Promise.resolve();
  178. };
  181. /**
  182.  * For some of this polyfill's implementation, we need to query a video element.
  183.  * But for some embedded systems, it is memory-expensive to create multiple
  184.  * video elements.  Therefore, we check the document to see if we can borrow one
  185.  * to query before we fall back to creating one temporarily.
  186.  *
  187.  * @return {!HTMLVideoElement}
  188.  * @private
  189.  */
  190. shaka.polyfill.PatchedMediaKeysWebkit.getVideoElement_ = function() {
  191.   let videos = document.getElementsByTagName('video');
  192.   let tmpVideo = videos.length ? videos[0] : document.createElement('video');
  193.   return /** @type {!HTMLVideoElement} */(tmpVideo);
  194. };
  198. /**
  199.  * An implementation of MediaKeySystemAccess.
  200.  *
  201.  * @constructor
  202.  * @struct
  203.  * @param {string} keySystem
  204.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  205.  * @implements {MediaKeySystemAccess}
  206.  * @throws {Error} if the key system is not supported.
  207.  */
  208. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess =
  209.     function(keySystem, supportedConfigurations) {
  210.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySystemAccess');
  212.   /** @type {string} */
  213.   this.keySystem = keySystem;
  215.   /** @private {string} */
  216.   this.internalKeySystem_ = keySystem;
  218.   /** @private {!MediaKeySystemConfiguration} */
  219.   this.configuration_;
  221.   // This is only a guess, since we don't really know from the prefixed API.
  222.   let allowPersistentState = false;
  224.   if (keySystem == 'org.w3.clearkey') {
  225.     // ClearKey's string must be prefixed in v0.1b.
  226.     this.internalKeySystem_ = 'webkit-org.w3.clearkey';
  227.     // ClearKey doesn't support persistence.
  228.     allowPersistentState = false;
  229.   }
  231.   let success = false;
  232.   let tmpVideo = shaka.polyfill.PatchedMediaKeysWebkit.getVideoElement_();
  233.   for (let i = 0; i < supportedConfigurations.length; ++i) {
  234.     let cfg = supportedConfigurations[i];
  236.     // Create a new config object and start adding in the pieces which we
  237.     // find support for.  We will return this from getConfiguration() if asked.
  238.     /** @type {!MediaKeySystemConfiguration} */
  239.     let newCfg = {
  240.       'audioCapabilities': [],
  241.       'videoCapabilities': [],
  242.       // It is technically against spec to return these as optional, but we
  243.       // don't truly know their values from the prefixed API:
  244.       'persistentState': 'optional',
  245.       'distinctiveIdentifier': 'optional',
  246.       // Pretend the requested init data types are supported, since we don't
  247.       // really know that either:
  248.       'initDataTypes': cfg.initDataTypes,
  249.       'sessionTypes': ['temporary'],
  250.       'label': cfg.label
  251.     };
  253.     // v0.1b tests for key system availability with an extra argument on
  254.     // canPlayType.
  255.     let ranAnyTests = false;
  256.     if (cfg.audioCapabilities) {
  257.       for (let j = 0; j < cfg.audioCapabilities.length; ++j) {
  258.         let cap = cfg.audioCapabilities[j];
  259.         if (cap.contentType) {
  260.           ranAnyTests = true;
  261.           // In Chrome <= 40, if you ask about Widevine-encrypted audio support,
  262.           // you get a false-negative when you specify codec information.
  263.           // Work around this by stripping codec info for audio types.
  264.           let contentType = cap.contentType.split(';')[0];
  265.           if (tmpVideo.canPlayType(contentType, this.internalKeySystem_)) {
  266.             newCfg.audioCapabilities.push(cap);
  267.             success = true;
  268.           }
  269.         }
  270.       }
  271.     }
  272.     if (cfg.videoCapabilities) {
  273.       for (let j = 0; j < cfg.videoCapabilities.length; ++j) {
  274.         let cap = cfg.videoCapabilities[j];
  275.         if (cap.contentType) {
  276.           ranAnyTests = true;
  277.           if (tmpVideo.canPlayType(cap.contentType, this.internalKeySystem_)) {
  278.             newCfg.videoCapabilities.push(cap);
  279.             success = true;
  280.           }
  281.         }
  282.       }
  283.     }
  285.     if (!ranAnyTests) {
  286.       // If no specific types were requested, we check all common types to find
  287.       // out if the key system is present at all.
  288.       success = tmpVideo.canPlayType('video/mp4', this.internalKeySystem_) ||
  289.                 tmpVideo.canPlayType('video/webm', this.internalKeySystem_);
  290.     }
  291.     if (cfg.persistentState == 'required') {
  292.       if (allowPersistentState) {
  293.         newCfg.persistentState = 'required';
  294.         newCfg.sessionTypes = ['persistent-license'];
  295.       } else {
  296.         success = false;
  297.       }
  298.     }
  300.     if (success) {
  301.       this.configuration_ = newCfg;
  302.       return;
  303.     }
  304.   }  // for each cfg in supportedConfigurations
  306.   let message = 'Unsupported keySystem';
  307.   if (keySystem == 'org.w3.clearkey' || keySystem == 'com.widevine.alpha') {
  308.     message = 'None of the requested configurations were supported.';
  309.   }
  310.   let unsupportedError = new Error(message);
  311.   unsupportedError.name = 'NotSupportedError';
  312.   unsupportedError.code = DOMException.NOT_SUPPORTED_ERR;
  313.   throw unsupportedError;
  314. };
  317. /** @override */
  318. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess.prototype.
  319.     createMediaKeys = function() {
  320.   shaka.log.debug(
  321.       'PatchedMediaKeysWebkit.MediaKeySystemAccess.createMediaKeys');
  323.   // Alias.
  324.   const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  325.   let mediaKeys = new PatchedMediaKeysWebkit.MediaKeys(this.internalKeySystem_);
  326.   return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  327. };
  330. /** @override */
  331. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess.prototype.
  332.     getConfiguration = function() {
  333.   shaka.log.debug(
  334.       'PatchedMediaKeysWebkit.MediaKeySystemAccess.getConfiguration');
  335.   return this.configuration_;
  336. };
  340. /**
  341.  * An implementation of MediaKeys.
  342.  *
  343.  * @constructor
  344.  * @struct
  345.  * @param {string} keySystem
  346.  * @implements {MediaKeys}
  347.  */
  348. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys = function(keySystem) {
  349.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys');
  351.   /** @private {string} */
  352.   this.keySystem_ = keySystem;
  354.   /** @private {HTMLMediaElement} */
  355.   this.media_ = null;
  357.   /** @private {!shaka.util.EventManager} */
  358.   this.eventManager_ = new shaka.util.EventManager();
  360.   /**
  361.    * @private {!Array.<!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  362.    */
  363.   this.newSessions_ = [];
  365.   /**
  366.    * @private {!Object.<string,
  367.    *                    !shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  368.    */
  369.   this.sessionMap_ = {};
  370. };
  373. /**
  374.  * @param {HTMLMediaElement} media
  375.  * @protected
  376.  */
  377. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.setMedia =
  378.     function(media) {
  379.   this.media_ = media;
  381.   // Remove any old listeners.
  382.   this.eventManager_.removeAll();
  384.   let prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  385.   if (media) {
  386.     // Intercept and translate these prefixed EME events.
  387.     this.eventManager_.listen(media, prefix + 'needkey',
  388.         /** @type {shaka.util.EventManager.ListenerType} */ (
  389.             this.onWebkitNeedKey_.bind(this)));
  391.     this.eventManager_.listen(media, prefix + 'keymessage',
  392.         /** @type {shaka.util.EventManager.ListenerType} */ (
  393.             this.onWebkitKeyMessage_.bind(this)));
  395.     this.eventManager_.listen(media, prefix + 'keyadded',
  396.         /** @type {shaka.util.EventManager.ListenerType} */ (
  397.             this.onWebkitKeyAdded_.bind(this)));
  399.     this.eventManager_.listen(media, prefix + 'keyerror',
  400.         /** @type {shaka.util.EventManager.ListenerType} */ (
  401.             this.onWebkitKeyError_.bind(this)));
  402.   }
  403. };
  406. /** @override */
  407. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.createSession =
  408.     function(opt_sessionType) {
  409.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.createSession');
  411.   let sessionType = opt_sessionType || 'temporary';
  412.   if (sessionType != 'temporary' && sessionType != 'persistent-license') {
  413.     throw new TypeError('Session type ' + opt_sessionType +
  414.                         ' is unsupported on this platform.');
  415.   }
  417.   // Alias.
  418.   const PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  420.   // Unprefixed EME allows for session creation without a video tag or src.
  421.   // Prefixed EME requires both a valid HTMLMediaElement and a src.
  422.   let media = this.media_ || /** @type {!HTMLMediaElement} */(
  423.       document.createElement('video'));
  424.   if (!media.src) media.src = 'about:blank';
  426.   let session = new PatchedMediaKeysWebkit.MediaKeySession(
  427.       media, this.keySystem_, sessionType);
  428.   this.newSessions_.push(session);
  429.   return session;
  430. };
  433. /** @override */
  434. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.setServerCertificate =
  435.     function(serverCertificate) {
  436.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.setServerCertificate');
  438.   // There is no equivalent in v0.1b, so return failure.
  439.   return Promise.resolve(false);
  440. };
  443. /**
  444.  * @param {!MediaKeyEvent} event
  445.  * @private
  446.  */
  447. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitNeedKey_ =
  448.     function(event) {
  449.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitNeedKey_', event);
  450.   goog.asserts.assert(this.media_, 'media_ not set in onWebkitNeedKey_');
  452.   let event2 =
  453.       /** @type {!CustomEvent} */ (document.createEvent('CustomEvent'));
  454.   event2.initCustomEvent('encrypted', false, false, null);
  456.   // not used by v0.1b EME, but given a valid value
  457.   event2.initDataType = 'webm';
  458.   event2.initData = event.initData;
  460.   this.media_.dispatchEvent(event2);
  461. };
  464. /**
  465.  * @param {!MediaKeyEvent} event
  466.  * @private
  467.  */
  468. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitKeyMessage_ =
  469.     function(event) {
  470.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyMessage_', event);
  472.   let session = this.findSession_(event.sessionId);
  473.   if (!session) {
  474.     shaka.log.error('Session not found', event.sessionId);
  475.     return;
  476.   }
  478.   let isNew = session.keyStatuses.getStatus() == undefined;
  480.   let event2 = new shaka.util.FakeEvent('message', {
  481.     messageType: isNew ? 'licenserequest' : 'licenserenewal',
  482.     message: event.message
  483.   });
  485.   session.generated();
  486.   session.dispatchEvent(event2);
  487. };
  490. /**
  491.  * @param {!MediaKeyEvent} event
  492.  * @private
  493.  */
  494. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitKeyAdded_ =
  495.     function(event) {
  496.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyAdded_', event);
  498.   let session = this.findSession_(event.sessionId);
  499.   goog.asserts.assert(session, 'unable to find session in onWebkitKeyAdded_');
  500.   if (session) {
  501.     session.ready();
  502.   }
  503. };
  506. /**
  507.  * @param {!MediaKeyEvent} event
  508.  * @private
  509.  */
  510. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitKeyError_ =
  511.     function(event) {
  512.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyError_', event);
  514.   let session = this.findSession_(event.sessionId);
  515.   goog.asserts.assert(session, 'unable to find session in onWebkitKeyError_');
  516.   if (session) {
  517.     session.handleError(event);
  518.   }
  519. };
  522. /**
  523.  * @param {string} sessionId
  524.  * @return {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession}
  525.  * @private
  526.  */
  527. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.findSession_ =
  528.     function(sessionId) {
  529.   let session = this.sessionMap_[sessionId];
  530.   if (session) {
  531.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  532.     return session;
  533.   }
  535.   session = this.newSessions_.shift();
  536.   if (session) {
  537.     session.sessionId = sessionId;
  538.     this.sessionMap_[sessionId] = session;
  539.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  540.     return session;
  541.   }
  543.   return null;
  544. };
  548. /**
  549.  * An implementation of MediaKeySession.
  550.  *
  551.  * @param {!HTMLMediaElement} media
  552.  * @param {string} keySystem
  553.  * @param {string} sessionType
  554.  *
  555.  * @constructor
  556.  * @struct
  557.  * @implements {MediaKeySession}
  558.  * @extends {shaka.util.FakeEventTarget}
  559.  */
  560. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession =
  561.     function(media, keySystem, sessionType) {
  562.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession');
  563.   shaka.util.FakeEventTarget.call(this);
  565.   /** @private {!HTMLMediaElement} */
  566.   this.media_ = media;
  568.   /** @private {boolean} */
  569.   this.initialized_ = false;
  571.   /** @private {shaka.util.PublicPromise} */
  572.   this.generatePromise_ = null;
  574.   /** @private {shaka.util.PublicPromise} */
  575.   this.updatePromise_ = null;
  577.   /** @private {string} */
  578.   this.keySystem_ = keySystem;
  580.   /** @private {string} */
  581.   this.type_ = sessionType;
  583.   /** @type {string} */
  584.   this.sessionId = '';
  586.   /** @type {number} */
  587.   this.expiration = NaN;
  589.   /** @type {!shaka.util.PublicPromise} */
  590.   this.closed = new shaka.util.PublicPromise();
  592.   /** @type {!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap} */
  593.   this.keyStatuses =
  594.       new shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap();
  595. };
  596. goog.inherits(shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession,
  597.               shaka.util.FakeEventTarget);
  600. /**
  601.  * Signals that the license request has been generated.  This resolves the
  602.  * 'generateRequest' promise.
  603.  *
  604.  * @protected
  605.  */
  606. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.generated =
  607.     function() {
  608.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generated');
  610.   if (this.generatePromise_) {
  611.     this.generatePromise_.resolve();
  612.     this.generatePromise_ = null;
  613.   }
  614. };
  617. /**
  618.  * Signals that the session is 'ready', which is the terminology used in older
  619.  * versions of EME.  The new signal is to resolve the 'update' promise.  This
  620.  * translates between the two.
  621.  *
  622.  * @protected
  623.  */
  624. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.ready =
  625.     function() {
  626.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.ready');
  628.   this.updateKeyStatus_('usable');
  630.   if (this.updatePromise_) {
  631.     this.updatePromise_.resolve();
  632.   }
  633.   this.updatePromise_ = null;
  634. };
  637. /**
  638.  * Either rejects a promise, or dispatches an error event, as appropriate.
  639.  *
  640.  * @param {!MediaKeyEvent} event
  641.  */
  642. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.handleError =
  643.     function(event) {
  644.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.handleError', event);
  646.   // This does not match the DOMException we get in current WD EME, but it will
  647.   // at least provide some information which can be used to look into the
  648.   // problem.
  649.   let error = new Error('EME v0.1b key error');
  650.   error.errorCode = event.errorCode;
  651.   error.errorCode.systemCode = event.systemCode;
  653.   // The presence or absence of sessionId indicates whether this corresponds to
  654.   // generateRequest() or update().
  655.   if (!event.sessionId && this.generatePromise_) {
  656.     error.method = 'generateRequest';
  657.     if (event.systemCode == 45) {
  658.       error.message = 'Unsupported session type.';
  659.     }
  660.     this.generatePromise_.reject(error);
  661.     this.generatePromise_ = null;
  662.   } else if (event.sessionId && this.updatePromise_) {
  663.     error.method = 'update';
  664.     this.updatePromise_.reject(error);
  665.     this.updatePromise_ = null;
  666.   } else {
  667.     // This mapping of key statuses is imperfect at best.
  668.     let code = event.errorCode.code;
  669.     let systemCode = event.systemCode;
  670.     if (code == MediaKeyError['MEDIA_KEYERR_OUTPUT']) {
  671.       this.updateKeyStatus_('output-restricted');
  672.     } else if (systemCode == 1) {
  673.       this.updateKeyStatus_('expired');
  674.     } else {
  675.       this.updateKeyStatus_('internal-error');
  676.     }
  677.   }
  678. };
  681. /**
  682.  * Logic which is shared between generateRequest() and load(), both of which
  683.  * are ultimately implemented with webkitGenerateKeyRequest in prefixed EME.
  684.  *
  685.  * @param {?BufferSource} initData
  686.  * @param {?string} offlineSessionId
  687.  * @return {!Promise}
  688.  * @private
  689.  */
  690. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.generate_ =
  691.     function(initData, offlineSessionId) {
  692.   if (this.initialized_) {
  693.     return Promise.reject(new Error('The session is already initialized.'));
  694.   }
  696.   this.initialized_ = true;
  698.   /** @type {!Uint8Array} */
  699.   let mangledInitData;
  701.   try {
  702.     if (this.type_ == 'persistent-license') {
  703.       const StringUtils = shaka.util.StringUtils;
  704.       if (!offlineSessionId) {
  705.         // Persisting the initial license.
  706.         // Prefix the init data with a tag to indicate persistence.
  707.         let prefix = StringUtils.toUTF8('PERSISTENT|');
  708.         let result = new Uint8Array(prefix.byteLength + initData.byteLength);
  709.         result.set(new Uint8Array(prefix), 0);
  710.         result.set(new Uint8Array(initData), prefix.byteLength);
  711.         mangledInitData = result;
  712.       } else {
  713.         // Loading a stored license.
  714.         // Prefix the init data (which is really a session ID) with a tag to
  715.         // indicate that we are loading a persisted session.
  716.         mangledInitData = new Uint8Array(
  717.             StringUtils.toUTF8('LOAD_SESSION|' + offlineSessionId));
  718.       }
  719.     } else {
  720.       // Streaming.
  721.       goog.asserts.assert(this.type_ == 'temporary',
  722.                           'expected temporary session');
  723.       goog.asserts.assert(!offlineSessionId,
  724.                           'unexpected offline session ID');
  725.       mangledInitData = new Uint8Array(initData);
  726.     }
  728.     goog.asserts.assert(mangledInitData,
  729.                         'init data not set!');
  730.   } catch (exception) {
  731.     return Promise.reject(exception);
  732.   }
  734.   goog.asserts.assert(this.generatePromise_ == null,
  735.                       'generatePromise_ should be null');
  736.   this.generatePromise_ = new shaka.util.PublicPromise();
  738.   // Because we are hacking media.src in createSession to better emulate
  739.   // unprefixed EME's ability to create sessions and license requests without a
  740.   // video tag, we can get ourselves into trouble.  It seems that sometimes,
  741.   // the setting of media.src hasn't been processed by some other thread, and
  742.   // GKR can throw an exception.  If this occurs, wait 10 ms and try again at
  743.   // most once.  This situation should only occur when init data is available
  744.   // ahead of the 'needkey' event.
  746.   let prefixApi = shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_;
  747.   let generateKeyRequestName = prefixApi('generateKeyRequest');
  748.   try {
  749.     this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  750.   } catch (exception) {
  751.     if (exception.name != 'InvalidStateError') {
  752.       this.generatePromise_ = null;
  753.       return Promise.reject(exception);
  754.     }
  756.     setTimeout(function() {
  757.       try {
  758.         this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  759.       } catch (exception2) {
  760.         this.generatePromise_.reject(exception2);
  761.         this.generatePromise_ = null;
  762.       }
  763.     }.bind(this), 10);
  764.   }
  766.   return this.generatePromise_;
  767. };
  770. /**
  771.  * An internal version of update which defers new calls while old ones are in
  772.  * progress.
  773.  *
  774.  * @param {!shaka.util.PublicPromise} promise  The promise associated with this
  775.  *   call.
  776.  * @param {?BufferSource} response
  777.  * @private
  778.  */
  779. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.update_ =
  780.     function(promise, response) {
  781.   if (this.updatePromise_) {
  782.     // We already have an update in-progress, so defer this one until after the
  783.     // old one is resolved.  Execute this whether the original one succeeds or
  784.     // fails.
  785.     this.updatePromise_.then(
  786.         this.update_.bind(this, promise, response)
  787.     ).catch(
  788.         this.update_.bind(this, promise, response)
  789.     );
  790.     return;
  791.   }
  793.   this.updatePromise_ = promise;
  795.   let key;
  796.   let keyId;
  798.   if (this.keySystem_ == 'webkit-org.w3.clearkey') {
  799.     // The current EME version of clearkey wants a structured JSON response.
  800.     // The v0.1b version wants just a raw key.  Parse the JSON response and
  801.     // extract the key and key ID.
  802.     const StringUtils = shaka.util.StringUtils;
  803.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  804.     let licenseString = StringUtils.fromUTF8(response);
  805.     let jwkSet = /** @type {JWKSet} */ (JSON.parse(licenseString));
  806.     let kty = jwkSet.keys[0].kty;
  807.     if (kty != 'oct') {
  808.       // Reject the promise.
  809.       let error = new Error('Response is not a valid JSON Web Key Set.');
  810.       this.updatePromise_.reject(error);
  811.       this.updatePromise_ = null;
  812.     }
  813.     key = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].k);
  814.     keyId = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].kid);
  815.   } else {
  816.     // The key ID is not required.
  817.     key = new Uint8Array(response);
  818.     keyId = null;
  819.   }
  821.   let prefixApi = shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_;
  822.   let addKeyName = prefixApi('addKey');
  823.   try {
  824.     this.media_[addKeyName](this.keySystem_, key, keyId, this.sessionId);
  825.   } catch (exception) {
  826.     // Reject the promise.
  827.     this.updatePromise_.reject(exception);
  828.     this.updatePromise_ = null;
  829.   }
  830. };
  833. /**
  834.  * Update key status and dispatch a 'keystatuseschange' event.
  835.  *
  836.  * @param {string} status
  837.  * @private
  838.  */
  839. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.
  840.     updateKeyStatus_ = function(status) {
  841.   this.keyStatuses.setStatus(status);
  842.   let event = new shaka.util.FakeEvent('keystatuseschange');
  843.   this.dispatchEvent(event);
  844. };
  847. /** @override */
  848. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.
  849.     generateRequest = function(initDataType, initData) {
  850.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generateRequest');
  851.   return this.generate_(initData, null);
  852. };
  855. /** @override */
  856. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.load =
  857.     function(sessionId) {
  858.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.load');
  859.   if (this.type_ == 'persistent-license') {
  860.     return this.generate_(null, sessionId);
  861.   } else {
  862.     return Promise.reject(new Error('Not a persistent session.'));
  863.   }
  864. };
  867. /** @override */
  868. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.update =
  869.     function(response) {
  870.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.update', response);
  871.   goog.asserts.assert(this.sessionId, 'update without session ID');
  873.   let nextUpdatePromise = new shaka.util.PublicPromise();
  874.   this.update_(nextUpdatePromise, response);
  875.   return nextUpdatePromise;
  876. };
  879. /** @override */
  880. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.close =
  881.     function() {
  882.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.close');
  884.   // This will remove a persistent session, but it's also the only way to
  885.   // free CDM resources on v0.1b.
  886.   if (this.type_ != 'persistent-license') {
  887.     // sessionId may reasonably be null if no key request has been generated
  888.     // yet.  Unprefixed EME will return a rejected promise in this case.
  889.     // We will use the same error message that Chrome 41 uses in its EME
  890.     // implementation.
  891.     if (!this.sessionId) {
  892.       this.closed.reject(new Error('The session is not callable.'));
  893.       return this.closed;
  894.     }
  896.     // This may throw an exception, but we ignore it because we are only using
  897.     // it to clean up resources in v0.1b.  We still consider the session closed.
  898.     // We can't let the exception propagate because MediaKeySession.close()
  899.     // should not throw.
  900.     let prefixApi = shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_;
  901.     let cancelKeyRequestName = prefixApi('cancelKeyRequest');
  902.     try {
  903.       this.media_[cancelKeyRequestName](this.keySystem_, this.sessionId);
  904.     } catch (exception) {}
  905.   }
  907.   // Resolve the 'closed' promise and return it.
  908.   this.closed.resolve();
  909.   return this.closed;
  910. };
  913. /** @override */
  914. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.remove =
  915.     function() {
  916.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.remove');
  918.   if (this.type_ != 'persistent-license') {
  919.     return Promise.reject(new Error('Not a persistent session.'));
  920.   }
  922.   return this.close();
  923. };
  927. /**
  928.  * An implementation of MediaKeyStatusMap.
  929.  * This fakes a map with a single key ID.
  930.  *
  931.  * @constructor
  932.  * @struct
  933.  * @implements {MediaKeyStatusMap}
  934.  */
  935. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap = function() {
  936.   /**
  937.    * @type {number}
  938.    */
  939.   this.size = 0;
  941.   /**
  942.    * @private {string|undefined}
  943.    */
  944.   this.status_ = undefined;
  945. };
  948. /**
  949.  * @const {!ArrayBuffer}
  950.  * @private
  951.  */
  952. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_;
  955. /**
  956.  * An internal method used by the session to set key status.
  957.  * @param {string|undefined} status
  958.  */
  959. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.setStatus =
  960.     function(status) {
  961.   this.size = status == undefined ? 0 : 1;
  962.   this.status_ = status;
  963. };
  966. /**
  967.  * An internal method used by the session to get key status.
  968.  * @return {string|undefined}
  969.  */
  970. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.getStatus =
  971.     function() {
  972.   return this.status_;
  973. };
  976. /** @override */
  977. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.forEach =
  978.     function(fn) {
  979.   if (this.status_) {
  980.     let fakeKeyId =
  981.         shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_;
  982.     fn(this.status_, fakeKeyId);
  983.   }
  984. };
  987. /** @override */
  988. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.get =
  989.     function(keyId) {
  990.   if (this.has(keyId)) {
  991.     return this.status_;
  992.   }
  993.   return undefined;
  994. };
  997. /** @override */
  998. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.has =
  999.     function(keyId) {
  1000.   let fakeKeyId =
  1001.       shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_;
  1002.   if (this.status_ &&
  1003.       shaka.util.Uint8ArrayUtils.equal(
  1004.           new Uint8Array(keyId), new Uint8Array(fakeKeyId))) {
  1005.     return true;
  1006.   }
  1007.   return false;
  1008. };
  1011. /**
  1012.  * @suppress {missingReturn}
  1013.  * @override
  1014.  */
  1015. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.
  1016.     entries = function() {
  1017.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  1018. };
  1021. /**
  1022.  * @suppress {missingReturn}
  1023.  * @override
  1024.  */
  1025. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.
  1026.     keys = function() {
  1027.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  1028. };
  1031. /**
  1032.  * @suppress {missingReturn}
  1033.  * @override
  1034.  */
  1035. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.
  1036.     values = function() {
  1037.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  1038. };
  1041. shaka.polyfill.register(shaka.polyfill.PatchedMediaKeysWebkit.install);