Source: lib/polyfill/patchedmediakeys_ms.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.PatchedMediaKeysMs');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.util.ArrayUtils');
  23. goog.require('shaka.util.EventManager');
  24. goog.require('shaka.util.FakeEvent');
  25. goog.require('shaka.util.FakeEventTarget');
  26. goog.require('shaka.util.Pssh');
  27. goog.require('shaka.util.PublicPromise');
  28. goog.require('shaka.util.Uint8ArrayUtils');
  31. /**
  32.  * Install a polyfill to implement {@link http://goo.gl/blgtZZ EME draft
  33.  * 12 March 2015} on top of ms-prefixed
  34.  * {@link http://www.w3.org/TR/2014/WD-encrypted-media-20140218/ EME v20140218}.
  35.  */
  36. shaka.polyfill.PatchedMediaKeysMs.install = function() {
  37.   shaka.log.debug('PatchedMediaKeysMs.install');
  39.   // Alias
  40.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  42.   // Construct fake key ID.  This is not done at load-time to avoid exceptions
  43.   // on unsupported browsers.  This particular fake key ID was suggested in
  44.   // w3c/encrypted-media#32.
  45.   PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_ = (new Uint8Array([0])).buffer;
  47.   // Delete mediaKeys to work around strict mode compatibility issues.
  48.   delete HTMLMediaElement.prototype['mediaKeys'];
  49.   // Work around read-only declaration for mediaKeys by using a string.
  50.   HTMLMediaElement.prototype['mediaKeys'] = null;
  51.   HTMLMediaElement.prototype.setMediaKeys = PatchedMediaKeysMs.setMediaKeys;
  53.   // Install patches
  54.   window.MediaKeys = PatchedMediaKeysMs.MediaKeys;
  55.   window.MediaKeySystemAccess = PatchedMediaKeysMs.MediaKeySystemAccess;
  56.   navigator.requestMediaKeySystemAccess =
  57.       PatchedMediaKeysMs.requestMediaKeySystemAccess;
  58. };
  61. /**
  62.  * An implementation of navigator.requestMediaKeySystemAccess.
  63.  * Retrieve a MediaKeySystemAccess object.
  64.  *
  65.  * @this {!Navigator}
  66.  * @param {string} keySystem
  67.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  68.  * @return {!Promise.<!MediaKeySystemAccess>}
  69.  */
  70. shaka.polyfill.PatchedMediaKeysMs.requestMediaKeySystemAccess =
  71.     function(keySystem, supportedConfigurations) {
  72.   shaka.log.debug('PatchedMediaKeysMs.requestMediaKeySystemAccess');
  73.   goog.asserts.assert(this == navigator,
  74.                       'bad "this" for requestMediaKeySystemAccess');
  76.   // Alias.
  77.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  78.   try {
  79.     var access = new PatchedMediaKeysMs.MediaKeySystemAccess(
  80.         keySystem, supportedConfigurations);
  81.     return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  82.   } catch (exception) {
  83.     return Promise.reject(exception);
  84.   }
  85. };
  89. /**
  90.  * An implementation of MediaKeySystemAccess.
  91.  *
  92.  * @constructor
  93.  * @struct
  94.  * @param {string} keySystem
  95.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  96.  * @implements {MediaKeySystemAccess}
  97.  * @throws {Error} if the key system is not supported.
  98.  */
  99. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess =
  100.     function(keySystem, supportedConfigurations) {
  101.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess');
  103.   /** @type {string} */
  104.   this.keySystem = keySystem;
  106.   /** @private {!MediaKeySystemConfiguration} */
  107.   this.configuration_;
  109.   var allowPersistentState = false;
  111.   var success = false;
  112.   for (var i = 0; i < supportedConfigurations.length; ++i) {
  113.     var cfg = supportedConfigurations[i];
  115.     // Create a new config object and start adding in the pieces which we
  116.     // find support for.  We will return this from getConfiguration() if
  117.     // asked.
  118.     /** @type {!MediaKeySystemConfiguration} */
  119.     var newCfg = {
  120.       'audioCapabilities': [],
  121.       'videoCapabilities': [],
  122.       // It is technically against spec to return these as optional, but we
  123.       // don't truly know their values from the prefixed API:
  124.       'persistentState': 'optional',
  125.       'distinctiveIdentifier': 'optional',
  126.       // Pretend the requested init data types are supported, since we don't
  127.       // really know that either:
  128.       'initDataTypes': cfg.initDataTypes,
  129.       'sessionTypes': ['temporary'],
  130.       'label': cfg.label
  131.     };
  133.     // PatchedMediaKeysMs tests for key system availability through
  134.     // MSMediaKeys.isTypeSupported
  135.     var ranAnyTests = false;
  136.     if (cfg.audioCapabilities) {
  137.       for (var j = 0; j < cfg.audioCapabilities.length; ++j) {
  138.         var cap = cfg.audioCapabilities[j];
  139.         if (cap.contentType) {
  140.           ranAnyTests = true;
  141.           var contentType = cap.contentType.split(';')[0];
  142.           if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  143.             newCfg.audioCapabilities.push(cap);
  144.             success = true;
  145.           }
  146.         }
  147.       }
  148.     }
  149.     if (cfg.videoCapabilities) {
  150.       for (var j = 0; j < cfg.videoCapabilities.length; ++j) {
  151.         var cap = cfg.videoCapabilities[j];
  152.         if (cap.contentType) {
  153.           ranAnyTests = true;
  154.           var contentType = cap.contentType.split(';')[0];
  155.           if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  156.             newCfg.videoCapabilities.push(cap);
  157.             success = true;
  158.           }
  159.         }
  160.       }
  161.     }
  163.     if (!ranAnyTests) {
  164.       // If no specific types were requested, we check all common types to find
  165.       // out if the key system is present at all.
  166.       success = MSMediaKeys.isTypeSupported(this.keySystem, 'video/mp4');
  167.     }
  168.     if (cfg.persistentState == 'required') {
  169.       if (allowPersistentState) {
  170.         newCfg.persistentState = 'required';
  171.         newCfg.sessionTypes = ['persistent-license'];
  172.       } else {
  173.         success = false;
  174.       }
  175.     }
  177.     if (success) {
  178.       this.configuration_ = newCfg;
  179.       return;
  180.     }
  181.   }  // for each cfg in supportedConfigurations
  183.   // As per the spec, this should be a DOMException, but
  184.   // there is not a public constructor for this
  185.   var unsupportedKeySystemError = new Error('Unsupported keySystem');
  186.   unsupportedKeySystemError.name = 'NotSupportedError';
  187.   unsupportedKeySystemError.code = DOMException.NOT_SUPPORTED_ERR;
  188.   throw unsupportedKeySystemError;
  189. };
  192. /** @override */
  193. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess.prototype.
  194.     createMediaKeys = function() {
  195.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess.createMediaKeys');
  197.   // Alias
  198.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  200.   var mediaKeys = new PatchedMediaKeysMs.MediaKeys(this.keySystem);
  201.   return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  202. };
  205. /** @override */
  206. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess.prototype.
  207.     getConfiguration = function() {
  208.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess.getConfiguration');
  209.   return this.configuration_;
  210. };
  213. /**
  214.  * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  215.  * Attach a MediaKeys object to the media element.
  216.  *
  217.  * @this {!HTMLMediaElement}
  218.  * @param {MediaKeys} mediaKeys
  219.  * @return {!Promise}
  220.  */
  221. shaka.polyfill.PatchedMediaKeysMs.setMediaKeys = function(mediaKeys) {
  222.   shaka.log.debug('PatchedMediaKeysMs.setMediaKeys');
  223.   goog.asserts.assert(this instanceof HTMLMediaElement,
  224.                       'bad "this" for setMediaKeys');
  226.   // Alias
  227.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  229.   var newMediaKeys =
  230.       /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  231.       mediaKeys);
  232.   var oldMediaKeys =
  233.       /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  234.       this.mediaKeys);
  236.   if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  237.     goog.asserts.assert(oldMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  238.                         'non-polyfill instance of oldMediaKeys');
  239.     // Have the old MediaKeys stop listening to events on the video tag.
  240.     oldMediaKeys.setMedia(null);
  241.   }
  243.   delete this['mediaKeys'];  // in case there is an existing getter
  244.   this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  246.   if (newMediaKeys) {
  247.     goog.asserts.assert(newMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  248.                         'non-polyfill instance of newMediaKeys');
  249.     return newMediaKeys.setMedia(this);
  250.   }
  252.   return Promise.resolve();
  253. };
  257. /**
  258.  * An implementation of MediaKeys.
  259.  *
  260.  * @constructor
  261.  * @struct
  262.  * @param {string} keySystem
  263.  * @implements {MediaKeys}
  264.  */
  265. shaka.polyfill.PatchedMediaKeysMs.MediaKeys = function(keySystem) {
  266.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys');
  268.   /** @private {!MSMediaKeys} */
  269.   this.nativeMediaKeys_ = new MSMediaKeys(keySystem);
  271.   /** @private {!shaka.util.EventManager} */
  272.   this.eventManager_ = new shaka.util.EventManager();
  273. };
  276. /** @override */
  277. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  278.     createSession = function(opt_sessionType) {
  279.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys.createSession');
  281.   var sessionType = opt_sessionType || 'temporary';
  282.   // For now, only 'temporary' type is supported
  283.   if (sessionType != 'temporary') {
  284.     throw new TypeError('Session type ' + opt_sessionType +
  285.         ' is unsupported on this platform.');
  286.   }
  288.   // Alias
  289.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  291.   return new PatchedMediaKeysMs.MediaKeySession(
  292.       this.nativeMediaKeys_, sessionType);
  293. };
  296. /** @override */
  297. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  298.     setServerCertificate = function(serverCertificate) {
  299.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys.setServerCertificate');
  301.   // There is no equivalent in PatchedMediaKeysMs, so return failure.
  302.   return Promise.resolve(false);
  303. };
  306. /**
  307.  * @param {HTMLMediaElement} media
  308.  * @protected
  309.  * @return {!Promise}
  310.  */
  311. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  312.     setMedia = function(media) {
  314.   // Alias
  315.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  317.   // Remove any old listeners.
  318.   this.eventManager_.removeAll();
  320.   // It is valid for media to be null, it's used to flag that event handlers
  321.   // need to be cleaned up
  322.   if (!media) {
  323.     return Promise.resolve();
  324.   }
  326.   // Intercept and translate these prefixed EME events.
  327.   this.eventManager_.listen(media, 'msneedkey',
  328.       /** @type {shaka.util.EventManager.ListenerType} */
  329.       (PatchedMediaKeysMs.onMsNeedKey_));
  331.   var self = this;
  332.   function setMediaKeysDeferred() {
  333.     media.msSetMediaKeys(self.nativeMediaKeys_);
  334.     media.removeEventListener('loadedmetadata', setMediaKeysDeferred);
  335.   }
  337.   // Wrap native HTMLMediaElement.msSetMediaKeys with Promise
  338.   try {
  339.     // IE11/Edge requires that readyState >=1 before mediaKeys can be set, so
  340.     // check this and wait for loadedmetadata if we are not in the correct state
  341.     if (media.readyState >= 1) {
  342.       media.msSetMediaKeys(this.nativeMediaKeys_);
  343.     } else {
  344.       media.addEventListener('loadedmetadata', setMediaKeysDeferred);
  345.     }
  347.     return Promise.resolve();
  349.   } catch (exception) {
  350.     return Promise.reject(exception);
  351.   }
  352. };
  356. /**
  357.  * An implementation of MediaKeySession.
  358.  *
  359.  * @constructor
  360.  * @struct
  361.  * @param {MSMediaKeys} nativeMediaKeys
  362.  * @param {string} sessionType
  363.  * @implements {MediaKeySession}
  364.  * @extends {shaka.util.FakeEventTarget}
  365.  */
  366. shaka.polyfill.PatchedMediaKeysMs.
  367.     MediaKeySession = function(nativeMediaKeys, sessionType) {
  368.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession');
  369.   shaka.util.FakeEventTarget.call(this);
  371.   // Native MediaKeySession, which will be created in generateRequest
  372.   /** @private {MSMediaKeySession} */
  373.   this.nativeMediaKeySession_ = null;
  375.   /** @private {MSMediaKeys} */
  376.   this.nativeMediaKeys_ = nativeMediaKeys;
  378.   // Promises that are resolved later
  379.   /** @private {shaka.util.PublicPromise} */
  380.   this.generateRequestPromise_ = null;
  382.   /** @private {shaka.util.PublicPromise} */
  383.   this.updatePromise_ = null;
  385.   /** @private {!shaka.util.EventManager} */
  386.   this.eventManager_ = new shaka.util.EventManager();
  388.   /** @type {string} */
  389.   this.sessionId = '';
  391.   /** @type {number} */
  392.   this.expiration = NaN;
  394.   /** @type {!shaka.util.PublicPromise} */
  395.   this.closed = new shaka.util.PublicPromise();
  397.   /** @type {!shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap} */
  398.   this.keyStatuses =
  399.       new shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap();
  400. };
  401. goog.inherits(shaka.polyfill.PatchedMediaKeysMs.MediaKeySession,
  402.     shaka.util.FakeEventTarget);
  405. /** @override */
  406. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  407.     generateRequest = function(initDataType, initData) {
  408.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.generateRequest');
  410.   this.generateRequestPromise_ = new shaka.util.PublicPromise();
  412.   try {
  413.     // This EME spec version requires a MIME content type as the 1st param
  414.     // to createSession, but doesn't seem to matter what the value is.
  416.     // NOTE: IE11 takes either Uint8Array or ArrayBuffer, but Edge 12 only
  417.     // accepts Uint8Array.
  418.     this.nativeMediaKeySession_ = this.nativeMediaKeys_
  419.         .createSession('video/mp4', new Uint8Array(initData), null);
  421.     // Attach session event handlers here
  422.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeymessage',
  423.         /** @type {shaka.util.EventManager.ListenerType} */
  424.         (this.onMsKeyMessage_.bind(this)));
  425.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyadded',
  426.         /** @type {shaka.util.EventManager.ListenerType} */
  427.         (this.onMsKeyAdded_.bind(this)));
  428.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyerror',
  429.         /** @type {shaka.util.EventManager.ListenerType} */
  430.         (this.onMsKeyError_.bind(this)));
  432.     this.updateKeyStatus_('status-pending');
  433.   } catch (exception) {
  434.     this.generateRequestPromise_.reject(exception);
  435.   }
  437.   return this.generateRequestPromise_;
  438. };
  441. /** @override */
  442. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  443.     load = function() {
  444.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.load');
  446.   return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  447. };
  450. /** @override */
  451. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  452.     update = function(response) {
  453.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.update');
  455.   this.updatePromise_ = new shaka.util.PublicPromise();
  457.   try {
  458.     // Pass through to the native session.
  459.     // NOTE: IE11 takes either Uint8Array or ArrayBuffer, but Edge 12 only
  460.     // accepts Uint8Array.
  461.     this.nativeMediaKeySession_.update(new Uint8Array(response));
  462.   } catch (exception) {
  463.     this.updatePromise_.reject(exception);
  464.   }
  466.   return this.updatePromise_;
  467. };
  470. /** @override */
  471. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  472.     close = function() {
  473.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.close');
  475.   try {
  476.     // Pass through to the native session
  477.     // NOTE: IE seems to have spec discrepancy here - v2010218 should have
  478.     // MediaKeySession.release, but actually uses "close". The next version
  479.     // of the spec is the initial Promise based one, so it's not the target spec
  480.     // either.
  481.     this.nativeMediaKeySession_.close();
  483.     this.closed.resolve();
  484.     this.eventManager_.removeAll();
  485.   } catch (exception) {
  486.     this.closed.reject(exception);
  487.   }
  489.   return this.closed;
  490. };
  493. /** @override */
  494. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  495.     remove = function() {
  496.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.remove');
  498.   return Promise.reject(new Error('MediaKeySession.remove is only ' +
  499.       'applicable for persistent licenses, which are not supported on ' +
  500.       'this platform'));
  501. };
  504. /**
  505.  * Handler for the native media elements msNeedKey event.
  506.  *
  507.  * @this {!HTMLMediaElement}
  508.  * @param {!MediaKeyEvent} event
  509.  * @private
  510.  */
  511. shaka.polyfill.PatchedMediaKeysMs.onMsNeedKey_ = function(event) {
  512.   shaka.log.debug('PatchedMediaKeysMs.onMsNeedKey_', event);
  514.   // Alias
  515.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  517.   // NOTE: Because "this" is a real EventTarget, on IE, the event we dispatch
  518.   // here must also be a real Event.
  519.   var event2 = /** @type {!CustomEvent} */(document.createEvent('CustomEvent'));
  520.   event2.initCustomEvent('encrypted', false, false, null);
  521.   event2.initDataType = 'cenc';
  522.   event2.initData = PatchedMediaKeysMs.NormaliseInitData_(event.initData);
  524.   this.dispatchEvent(event2);
  525. };
  528. /**
  529.  * Normalise the initData array. This is to apply browser specific work-arounds,
  530.  * e.g. removing duplicates which appears to occur intermittently when the
  531.  * native msneedkey event fires (i.e. event.initData contains dupes).
  532.  *
  533.  * @param {?Uint8Array} initData
  534.  * @private
  535.  * @return {?Uint8Array}
  536.  */
  537. shaka.polyfill.PatchedMediaKeysMs.
  538.     NormaliseInitData_ = function(initData) {
  539.   if (!initData) {
  540.     return initData;
  541.   }
  543.   var pssh = new shaka.util.Pssh(initData);
  545.   // If there is only a single pssh, return the original array
  546.   if (pssh.dataBoundaries.length <= 1) {
  547.     return initData;
  548.   }
  550.   var unfilteredInitDatas = [];
  551.   for (var i = 0; i < pssh.dataBoundaries.length; i++) {
  552.     var currPssh = initData.subarray(
  553.         pssh.dataBoundaries[i].start,
  554.         pssh.dataBoundaries[i].end + 1); // end is exclusive, hence the +1
  556.     unfilteredInitDatas.push(currPssh);
  557.   }
  559.   // Dedupe psshData
  560.   var dedupedInitDatas = shaka.util.ArrayUtils.removeDuplicates(
  561.       unfilteredInitDatas,
  562.       shaka.polyfill.PatchedMediaKeysMs.compareInitDatas_);
  564.   var targetLength = 0;
  565.   for (var i = 0; i < dedupedInitDatas.length; i++) {
  566.     targetLength += dedupedInitDatas[i].length;
  567.   }
  569.   // Concat array of Uint8Arrays back into a single Uint8Array
  570.   var normalisedInitData = new Uint8Array(targetLength);
  571.   var offset = 0;
  572.   for (var i = 0; i < dedupedInitDatas.length; i++) {
  573.     normalisedInitData.set(dedupedInitDatas[i], offset);
  574.     offset += dedupedInitDatas[i].length;
  575.   }
  577.   return normalisedInitData;
  578. };
  581. /**
  582.  * @param {!Uint8Array} initDataA
  583.  * @param {!Uint8Array} initDataB
  584.  * @return {boolean}
  585.  * @private
  586.  */
  587. shaka.polyfill.PatchedMediaKeysMs.compareInitDatas_ =
  588.     function(initDataA, initDataB) {
  589.   return shaka.util.Uint8ArrayUtils.equal(initDataA, initDataB);
  590. };
  593. /**
  594.  * Handler for the native keymessage event on MSMediaKeySession.
  595.  *
  596.  * @param {!MediaKeyEvent} event
  597.  * @private
  598.  */
  599. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  600.     onMsKeyMessage_ = function(event) {
  601.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyMessage_', event);
  603.   // We can now resolve this.generateRequestPromise (it should be non-null)
  604.   goog.asserts.assert(this.generateRequestPromise_,
  605.                       'generateRequestPromise_ not set in onMsKeyMessage_');
  606.   if (this.generateRequestPromise_) {
  607.     this.generateRequestPromise_.resolve();
  608.     this.generateRequestPromise_ = null;
  609.   }
  611.   var isNew = this.keyStatuses.getStatus() == undefined;
  613.   var event2 = new shaka.util.FakeEvent('message', {
  614.     messageType: isNew ? 'licenserequest' : 'licenserenewal',
  615.     message: event.message.buffer
  616.   });
  618.   this.dispatchEvent(event2);
  619. };
  622. /**
  623.  * Handler for the native keyadded event on MSMediaKeySession.
  624.  *
  625.  * @param {!MediaKeyEvent} event
  626.  * @private
  627.  */
  628. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  629.     onMsKeyAdded_ = function(event) {
  630.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyAdded_', event);
  632.   // PlayReady's concept of persistent licenses makes emulation difficult here.
  633.   // A license policy can say that the license persists, which causes the CDM to
  634.   // store it for use in a later session.  The result is that in IE11, the CDM
  635.   // fires 'mskeyadded' without ever firing 'mskeymessage'.
  636.   if (this.generateRequestPromise_) {
  637.     shaka.log.debug('Simulating completion for a PR persistent license.');
  638.     goog.asserts.assert(!this.updatePromise_,
  639.         'updatePromise_ and generateRequestPromise_ set in onMsKeyAdded_');
  640.     this.updateKeyStatus_('usable');
  641.     this.generateRequestPromise_.resolve();
  642.     this.generateRequestPromise_ = null;
  643.     return;
  644.   }
  646.   // We can now resolve this.updatePromise (it should be non-null)
  647.   goog.asserts.assert(this.updatePromise_,
  648.                       'updatePromise_ not set in onMsKeyAdded_');
  649.   if (this.updatePromise_) {
  650.     this.updateKeyStatus_('usable');
  651.     this.updatePromise_.resolve();
  652.     this.updatePromise_ = null;
  653.   }
  654. };
  657. /**
  658.  * Handler for the native keyerror event on MSMediaKeySession.
  659.  *
  660.  * @param {!MediaKeyEvent} event
  661.  * @private
  662.  */
  663. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  664.     onMsKeyError_ = function(event) {
  665.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyError_', event);
  667.   var error = new Error('EME PatchedMediaKeysMs key error');
  668.   error.errorCode = this.nativeMediaKeySession_.error;
  670.   if (this.generateRequestPromise_ != null) {
  671.     this.generateRequestPromise_.reject(error);
  672.     this.generateRequestPromise_ = null;
  673.   } else if (this.updatePromise_ != null) {
  674.     this.updatePromise_.reject(error);
  675.     this.updatePromise_ = null;
  676.   } else {
  677.     /*
  678.     Unexpected error - map native codes to standardised key statuses.
  679.     Possible values of this.nativeMediaKeySession_.error.code
  681.     MS_MEDIA_KEYERR_UNKNOWN        = 1
  682.     MS_MEDIA_KEYERR_CLIENT         = 2
  683.     MS_MEDIA_KEYERR_SERVICE        = 3
  684.     MS_MEDIA_KEYERR_OUTPUT         = 4
  685.     MS_MEDIA_KEYERR_HARDWARECHANGE = 5
  686.     MS_MEDIA_KEYERR_DOMAIN         = 6
  687.     */
  689.     switch (this.nativeMediaKeySession_.error.code) {
  690.       case MSMediaKeyError.MS_MEDIA_KEYERR_OUTPUT:
  691.       case MSMediaKeyError.MS_MEDIA_KEYERR_HARDWARECHANGE:
  692.         this.updateKeyStatus_('output-not-allowed');
  693.       default:
  694.         this.updateKeyStatus_('internal-error');
  695.     }
  696.   }
  697. };
  700. /**
  701.  * Update key status and dispatch a 'keystatuseschange' event.
  702.  *
  703.  * @param {string} status
  704.  * @private
  705.  */
  706. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  707.     updateKeyStatus_ = function(status) {
  708.   this.keyStatuses.setStatus(status);
  709.   var event = new shaka.util.FakeEvent('keystatuseschange');
  710.   this.dispatchEvent(event);
  711. };
  715. /**
  716.  * An implementation of MediaKeyStatusMap.
  717.  * This fakes a map with a single key ID.
  718.  *
  719.  * @constructor
  720.  * @struct
  721.  * @implements {MediaKeyStatusMap}
  722.  */
  723. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap = function() {
  724.   /**
  725.    * @type {number}
  726.    */
  727.   this.size = 0;
  729.   /**
  730.    * @private {string|undefined}
  731.    */
  732.   this.status_ = undefined;
  733. };
  736. /**
  737.  * @const {!ArrayBuffer}
  738.  * @private
  739.  */
  740. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  743. /**
  744.  * An internal method used by the session to set key status.
  745.  * @param {string|undefined} status
  746.  */
  747. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  748.     setStatus = function(status) {
  749.   this.size = status == undefined ? 0 : 1;
  750.   this.status_ = status;
  751. };
  754. /**
  755.  * An internal method used by the session to get key status.
  756.  * @return {string|undefined}
  757.  */
  758. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  759.     getStatus = function() {
  760.   return this.status_;
  761. };
  764. /** @override */
  765. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  766.     forEach = function(fn) {
  767.   if (this.status_) {
  768.     var fakeKeyId =
  769.         shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  770.     fn(this.status_, fakeKeyId);
  771.   }
  772. };
  775. /** @override */
  776. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  777.     get = function(keyId) {
  778.   if (this.has(keyId)) {
  779.     return this.status_;
  780.   }
  781.   return undefined;
  782. };
  785. /** @override */
  786. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  787.     has = function(keyId) {
  788.   var fakeKeyId =
  789.       shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  790.   if (this.status_ &&
  791.       shaka.util.Uint8ArrayUtils.equal(
  792.           new Uint8Array(keyId), new Uint8Array(fakeKeyId))) {
  793.     return true;
  794.   }
  795.   return false;
  796. };
  799. /** @suppress {missingReturn} */
  800. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  801.     entries = function() {
  802.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  803. };
  806. /** @suppress {missingReturn} */
  807. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  808.     keys = function() {
  809.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  810. };
  813. /** @suppress {missingReturn} */
  814. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  815.     values = function() {
  816.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  817. };