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.  * @suppress {unnecessaryCasts}
  70.  */
  71. shaka.polyfill.PatchedMediaKeysMs.requestMediaKeySystemAccess =
  72.     function(keySystem, supportedConfigurations) {
  73.   shaka.log.debug('PatchedMediaKeysMs.requestMediaKeySystemAccess');
  74.   goog.asserts.assert(this == navigator,
  75.                       'bad "this" for requestMediaKeySystemAccess');
  77.   // Alias.
  78.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  79.   try {
  80.     var access = new PatchedMediaKeysMs.MediaKeySystemAccess(
  81.         keySystem, supportedConfigurations);
  82.     return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  83.   } catch (exception) {
  84.     return Promise.reject(exception);
  85.   }
  86. };
  90. /**
  91.  * An implementation of MediaKeySystemAccess.
  92.  *
  93.  * @constructor
  94.  * @struct
  95.  * @param {string} keySystem
  96.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  97.  * @implements {MediaKeySystemAccess}
  98.  * @throws {Error} if the key system is not supported.
  99.  */
  100. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess =
  101.     function(keySystem, supportedConfigurations) {
  102.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess');
  104.   /** @type {string} */
  105.   this.keySystem = keySystem;
  107.   /** @private {!MediaKeySystemConfiguration} */
  108.   this.configuration_;
  110.   var allowPersistentState = true;
  112.   var success = false;
  113.   for (var i = 0; i < supportedConfigurations.length; ++i) {
  114.     var cfg = supportedConfigurations[i];
  116.     // Create a new config object and start adding in the pieces which we
  117.     // find support for.  We will return this from getConfiguration() if
  118.     // asked.
  119.     /** @type {!MediaKeySystemConfiguration} */
  120.     var newCfg = {
  121.       'audioCapabilities': [],
  122.       'videoCapabilities': [],
  123.       // It is technically against spec to return these as optional, but we
  124.       // don't truly know their values from the prefixed API:
  125.       'persistentState': 'optional',
  126.       'distinctiveIdentifier': 'optional',
  127.       // Pretend the requested init data types are supported, since we don't
  128.       // really know that either:
  129.       'initDataTypes': cfg.initDataTypes,
  130.       'sessionTypes': ['temporary'],
  131.       'label': cfg.label
  132.     };
  134.     // PatchedMediaKeysMs tests for key system availability through
  135.     // MSMediaKeys.isTypeSupported
  136.     var ranAnyTests = false;
  137.     if (cfg.audioCapabilities) {
  138.       for (var j = 0; j < cfg.audioCapabilities.length; ++j) {
  139.         var cap = cfg.audioCapabilities[j];
  140.         if (cap.contentType) {
  141.           ranAnyTests = true;
  142.           var contentType = cap.contentType.split(';')[0];
  143.           if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  144.             newCfg.audioCapabilities.push(cap);
  145.             success = true;
  146.           }
  147.         }
  148.       }
  149.     }
  150.     if (cfg.videoCapabilities) {
  151.       for (var j = 0; j < cfg.videoCapabilities.length; ++j) {
  152.         var cap = cfg.videoCapabilities[j];
  153.         if (cap.contentType) {
  154.           ranAnyTests = true;
  155.           var contentType = cap.contentType.split(';')[0];
  156.           if (MSMediaKeys.isTypeSupported(this.keySystem, contentType)) {
  157.             newCfg.videoCapabilities.push(cap);
  158.             success = true;
  159.           }
  160.         }
  161.       }
  162.     }
  164.     if (!ranAnyTests) {
  165.       // If no specific types were requested, we check all common types to find
  166.       // out if the key system is present at all.
  167.       success = MSMediaKeys.isTypeSupported(this.keySystem, 'video/mp4');
  168.     }
  169.     if (cfg.persistentState == 'required') {
  170.       if (allowPersistentState) {
  171.         newCfg.persistentState = 'required';
  172.         newCfg.sessionTypes = ['persistent-license'];
  173.       } else {
  174.         success = false;
  175.       }
  176.     }
  178.     if (success) {
  179.       this.configuration_ = newCfg;
  180.       return;
  181.     }
  182.   }  // for each cfg in supportedConfigurations
  184.   // As per the spec, this should be a DOMException, but
  185.   // there is not a public constructor for this
  186.   var unsupportedKeySystemError = new Error('Unsupported keySystem');
  187.   unsupportedKeySystemError.name = 'NotSupportedError';
  188.   unsupportedKeySystemError.code = DOMException.NOT_SUPPORTED_ERR;
  189.   throw unsupportedKeySystemError;
  190. };
  193. /**
  194.  * @override
  195.  * @suppress {unnecessaryCasts}
  196.  */
  197. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess.prototype.
  198.     createMediaKeys = function() {
  199.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess.createMediaKeys');
  201.   // Alias
  202.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  204.   var mediaKeys = new PatchedMediaKeysMs.MediaKeys(this.keySystem);
  205.   return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  206. };
  209. /** @override */
  210. shaka.polyfill.PatchedMediaKeysMs.MediaKeySystemAccess.prototype.
  211.     getConfiguration = function() {
  212.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySystemAccess.getConfiguration');
  213.   return this.configuration_;
  214. };
  217. /**
  218.  * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  219.  * Attach a MediaKeys object to the media element.
  220.  *
  221.  * @this {!HTMLMediaElement}
  222.  * @param {MediaKeys} mediaKeys
  223.  * @return {!Promise}
  224.  */
  225. shaka.polyfill.PatchedMediaKeysMs.setMediaKeys = function(mediaKeys) {
  226.   shaka.log.debug('PatchedMediaKeysMs.setMediaKeys');
  227.   goog.asserts.assert(this instanceof HTMLMediaElement,
  228.                       'bad "this" for setMediaKeys');
  230.   // Alias
  231.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  233.   var newMediaKeys =
  234.       /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  235.       mediaKeys);
  236.   var oldMediaKeys =
  237.       /** @type {shaka.polyfill.PatchedMediaKeysMs.MediaKeys} */ (
  238.       this.mediaKeys);
  240.   if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  241.     goog.asserts.assert(oldMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  242.                         'non-polyfill instance of oldMediaKeys');
  243.     // Have the old MediaKeys stop listening to events on the video tag.
  244.     oldMediaKeys.setMedia(null);
  245.   }
  247.   delete this['mediaKeys'];  // in case there is an existing getter
  248.   this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  250.   if (newMediaKeys) {
  251.     goog.asserts.assert(newMediaKeys instanceof PatchedMediaKeysMs.MediaKeys,
  252.                         'non-polyfill instance of newMediaKeys');
  253.     return newMediaKeys.setMedia(this);
  254.   }
  256.   return Promise.resolve();
  257. };
  261. /**
  262.  * An implementation of MediaKeys.
  263.  *
  264.  * @constructor
  265.  * @struct
  266.  * @param {string} keySystem
  267.  * @implements {MediaKeys}
  268.  */
  269. shaka.polyfill.PatchedMediaKeysMs.MediaKeys = function(keySystem) {
  270.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys');
  272.   /** @private {!MSMediaKeys} */
  273.   this.nativeMediaKeys_ = new MSMediaKeys(keySystem);
  275.   /** @private {!shaka.util.EventManager} */
  276.   this.eventManager_ = new shaka.util.EventManager();
  277. };
  280. /** @override */
  281. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  282.     createSession = function(opt_sessionType) {
  283.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys.createSession');
  285.   var sessionType = opt_sessionType || 'temporary';
  286.   // For now, only 'temporary' type is supported
  287.   if (sessionType != 'temporary') {
  288.     throw new TypeError('Session type ' + opt_sessionType +
  289.         ' is unsupported on this platform.');
  290.   }
  292.   // Alias
  293.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  295.   return new PatchedMediaKeysMs.MediaKeySession(
  296.       this.nativeMediaKeys_, sessionType);
  297. };
  300. /** @override */
  301. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  302.     setServerCertificate = function(serverCertificate) {
  303.   shaka.log.debug('PatchedMediaKeysMs.MediaKeys.setServerCertificate');
  305.   // There is no equivalent in PatchedMediaKeysMs, so return failure.
  306.   return Promise.reject(new Error('setServerCertificate not supported on ' +
  307.       'this platform.'));
  308. };
  311. /**
  312.  * @param {HTMLMediaElement} media
  313.  * @protected
  314.  * @return {!Promise}
  315.  */
  316. shaka.polyfill.PatchedMediaKeysMs.MediaKeys.prototype.
  317.     setMedia = function(media) {
  319.   // Alias
  320.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  322.   // Remove any old listeners.
  323.   this.eventManager_.removeAll();
  325.   // It is valid for media to be null, it's used to flag that event handlers
  326.   // need to be cleaned up
  327.   if (!media) {
  328.     return Promise.resolve();
  329.   }
  331.   // Intercept and translate these prefixed EME events.
  332.   this.eventManager_.listen(media, 'msneedkey',
  333.       /** @type {shaka.util.EventManager.ListenerType} */
  334.       (PatchedMediaKeysMs.onMsNeedKey_));
  336.   var self = this;
  337.   function setMediaKeysDeferred() {
  338.     media.msSetMediaKeys(self.nativeMediaKeys_);
  339.     media.removeEventListener('loadedmetadata', setMediaKeysDeferred);
  340.   }
  342.   // Wrap native HTMLMediaElement.msSetMediaKeys with Promise
  343.   try {
  344.     // IE11/Edge requires that readyState >=1 before mediaKeys can be set, so
  345.     // check this and wait for loadedmetadata if we are not in the correct state
  346.     if (media.readyState >= 1) {
  347.       media.msSetMediaKeys(this.nativeMediaKeys_);
  348.     } else {
  349.       media.addEventListener('loadedmetadata', setMediaKeysDeferred);
  350.     }
  352.     return Promise.resolve();
  354.   } catch (exception) {
  355.     return Promise.reject(exception);
  356.   }
  357. };
  361. /**
  362.  * An implementation of MediaKeySession.
  363.  *
  364.  * @constructor
  365.  * @struct
  366.  * @param {MSMediaKeys} nativeMediaKeys
  367.  * @param {string} sessionType
  368.  * @implements {MediaKeySession}
  369.  * @extends {shaka.util.FakeEventTarget}
  370.  */
  371. shaka.polyfill.PatchedMediaKeysMs.
  372.     MediaKeySession = function(nativeMediaKeys, sessionType) {
  373.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession');
  374.   shaka.util.FakeEventTarget.call(this);
  376.   // Native MediaKeySession, which will be created in generateRequest
  377.   /** @private {MSMediaKeySession} */
  378.   this.nativeMediaKeySession_ = null;
  380.   /** @private {MSMediaKeys} */
  381.   this.nativeMediaKeys_ = nativeMediaKeys;
  383.   // Promises that are resolved later
  384.   /** @private {Promise} */
  385.   this.generateRequestPromise_ = null;
  387.   /** @private {Promise} */
  388.   this.updatePromise_ = null;
  390.   /** @private {!shaka.util.EventManager} */
  391.   this.eventManager_ = new shaka.util.EventManager();
  393.   /** @type {string} */
  394.   this.sessionId = '';
  396.   /** @type {number} */
  397.   this.expiration = NaN;
  399.   /** @type {!shaka.util.PublicPromise} */
  400.   this.closed = new shaka.util.PublicPromise();
  402.   /** @type {!MediaKeyStatusMap} */
  403.   this.keyStatuses =
  404.       new shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap();
  405. };
  406. goog.inherits(shaka.polyfill.PatchedMediaKeysMs.MediaKeySession,
  407.     shaka.util.FakeEventTarget);
  410. /** @override */
  411. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  412.     generateRequest = function(initDataType, initData) {
  413.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.generateRequest');
  415.   this.generateRequestPromise_ = new shaka.util.PublicPromise();
  417.   try {
  418.     // This EME spec version requires a MIME content type as the 1st param
  419.     // to createSession, but doesn't seem to matter what the value is.
  421.     // NOTE: IE11 takes either Uint8Array or ArrayBuffer, but Edge 12 only
  422.     // accepts Uint8Array.
  423.     this.nativeMediaKeySession_ = this.nativeMediaKeys_
  424.         .createSession('video/mp4', new Uint8Array(initData), null);
  426.     // Attach session event handlers here
  427.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeymessage',
  428.         /** @type {shaka.util.EventManager.ListenerType} */
  429.         (this.onMsKeyMessage_.bind(this)));
  430.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyadded',
  431.         /** @type {shaka.util.EventManager.ListenerType} */
  432.         (this.onMsKeyAdded_.bind(this)));
  433.     this.eventManager_.listen(this.nativeMediaKeySession_, 'mskeyerror',
  434.         /** @type {shaka.util.EventManager.ListenerType} */
  435.         (this.onMsKeyError_.bind(this)));
  437.     this.updateKeyStatus_('status-pending');
  438.   } catch (exception) {
  439.     this.generateRequestPromise_.reject(exception);
  440.   }
  442.   return this.generateRequestPromise_;
  443. };
  446. /** @override */
  447. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  448.     load = function() {
  449.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.load');
  451.   return Promise.reject(new Error('MediaKeySession.load not yet supported'));
  452. };
  455. /** @override */
  456. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  457.     update = function(response) {
  458.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.update');
  460.   this.updatePromise_ = new shaka.util.PublicPromise();
  462.   try {
  463.     // Pass through to the native session.
  464.     // NOTE: IE11 takes either Uint8Array or ArrayBuffer, but Edge 12 only
  465.     // accepts Uint8Array.
  466.     this.nativeMediaKeySession_.update(new Uint8Array(response));
  467.   } catch (exception) {
  468.     this.updatePromise_.reject(exception);
  469.   }
  471.   return this.updatePromise_;
  472. };
  475. /** @override */
  476. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  477.     close = function() {
  478.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.close');
  480.   try {
  481.     // Pass through to the native session
  482.     // NOTE: IE seems to have spec discrepancy here - v2010218 should have
  483.     // MediaKeySession.release, but actually uses "close". The next version
  484.     // of the spec is the initial Promise based one, so it's not the target spec
  485.     // either.
  486.     this.nativeMediaKeySession_.close();
  488.     this.closed.resolve();
  489.     this.eventManager_.removeAll();
  490.   } catch (exception) {
  491.     this.closed.reject(exception);
  492.   }
  494.   return this.closed;
  495. };
  498. /** @override */
  499. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  500.     remove = function() {
  501.   shaka.log.debug('PatchedMediaKeysMs.MediaKeySession.remove');
  503.   return Promise.reject(new Error('MediaKeySession.remove is only ' +
  504.       'applicable for persistent licenses, which are not supported on ' +
  505.       'this platform'));
  506. };
  509. /**
  510.  * Handler for the native media elements msNeedKey event.
  511.  *
  512.  * @this {!HTMLMediaElement}
  513.  * @param {!MediaKeyEvent} event
  514.  * @private
  515.  */
  516. shaka.polyfill.PatchedMediaKeysMs.onMsNeedKey_ = function(event) {
  517.   shaka.log.debug('PatchedMediaKeysMs.onMsNeedKey_', event);
  519.   // Alias
  520.   var PatchedMediaKeysMs = shaka.polyfill.PatchedMediaKeysMs;
  522.   // NOTE: Because "this" is a real EventTarget, on IE, the event we dispatch
  523.   // here must also be a real Event.
  524.   var event2 = /** @type {!CustomEvent} */(document.createEvent('CustomEvent'));
  525.   event2.initCustomEvent('encrypted', false, false, null);
  526.   event2.initDataType = 'cenc';
  527.   event2.initData = PatchedMediaKeysMs.NormaliseInitData_(event.initData);
  529.   this.dispatchEvent(event2);
  530. };
  533. /**
  534.  * Normalise the initData array. This is to apply browser specific work-arounds,
  535.  * e.g. removing duplicates which appears to occur intermittently when the
  536.  * native msneedkey event fires (i.e. event.initData contains dupes).
  537.  *
  538.  * @param {?Uint8Array} initData
  539.  * @private
  540.  * @return {?Uint8Array}
  541.  */
  542. shaka.polyfill.PatchedMediaKeysMs.
  543.     NormaliseInitData_ = function(initData) {
  544.   if (!initData) {
  545.     return initData;
  546.   }
  548.   var pssh = new shaka.util.Pssh(initData);
  550.   // If there is only a single pssh, return the original array
  551.   if (pssh.dataBoundaries.length <= 1) {
  552.     return initData;
  553.   }
  555.   var unfilteredInitDatas = [];
  556.   for (var i = 0; i < pssh.dataBoundaries.length; i++) {
  557.     var currPssh = initData.subarray(
  558.         pssh.dataBoundaries[i].start,
  559.         pssh.dataBoundaries[i].end + 1); // end is exclusive, hence the +1
  561.     unfilteredInitDatas.push(currPssh);
  562.   }
  564.   // Dedupe psshData
  565.   var dedupedInitDatas = shaka.util.ArrayUtils.removeDuplicates(
  566.       unfilteredInitDatas,
  567.       shaka.polyfill.PatchedMediaKeysMs.compareInitDatas_);
  569.   var targetLength = 0;
  570.   for (var i = 0; i < dedupedInitDatas.length; i++) {
  571.     targetLength += dedupedInitDatas[i].length;
  572.   }
  574.   // Concat array of Uint8Arrays back into a single Uint8Array
  575.   var normalisedInitData = new Uint8Array(targetLength);
  576.   var offset = 0;
  577.   for (var i = 0; i < dedupedInitDatas.length; i++) {
  578.     normalisedInitData.set(dedupedInitDatas[i], offset);
  579.     offset += dedupedInitDatas[i].length;
  580.   }
  582.   return normalisedInitData;
  583. };
  586. /**
  587.  * @param {!Uint8Array} initDataA
  588.  * @param {!Uint8Array} initDataB
  589.  * @return {boolean}
  590.  * @private
  591.  */
  592. shaka.polyfill.PatchedMediaKeysMs.compareInitDatas_ =
  593.     function(initDataA, initDataB) {
  594.   return shaka.util.Uint8ArrayUtils.equal(initDataA, initDataB);
  595. };
  598. /**
  599.  * Handler for the native keymessage event on MSMediaKeySession.
  600.  *
  601.  * @param {!MediaKeyEvent} event
  602.  * @private
  603.  */
  604. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  605.     onMsKeyMessage_ = function(event) {
  606.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyMessage_', event);
  608.   // We can now resolve this.generateRequestPromise (it should be non-null)
  609.   goog.asserts.assert(this.generateRequestPromise_,
  610.                       'generateRequestPromise_ not set in onMsKeyMessage_');
  611.   if (this.generateRequestPromise_) {
  612.     this.generateRequestPromise_.resolve();
  613.     this.generateRequestPromise_ = null;
  614.   }
  616.   var isNew = this.keyStatuses.getStatus() == undefined;
  618.   var event2 = new shaka.util.FakeEvent('message', {
  619.     messageType: isNew ? 'licenserequest' : 'licenserenewal',
  620.     message: event.message.buffer
  621.   });
  623.   this.dispatchEvent(event2);
  624. };
  627. /**
  628.  * Handler for the native keyadded event on MSMediaKeySession.
  629.  *
  630.  * @param {!MediaKeyEvent} event
  631.  * @private
  632.  */
  633. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  634.     onMsKeyAdded_ = function(event) {
  635.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyAdded_', event);
  637.   // PlayReady's concept of persistent licenses makes emulation difficult here.
  638.   // A license policy can say that the license persists, which causes the CDM to
  639.   // store it for use in a later session.  The result is that in IE11, the CDM
  640.   // fires 'mskeyadded' without ever firing 'mskeymessage'.
  641.   if (this.generateRequestPromise_) {
  642.     shaka.log.debug('Simulating completion for a PR persistent license.');
  643.     goog.asserts.assert(!this.updatePromise_,
  644.         'updatePromise_ and generateRequestPromise_ set in onMsKeyAdded_');
  645.     this.updateKeyStatus_('usable');
  646.     this.generateRequestPromise_.resolve();
  647.     this.generateRequestPromise_ = null;
  648.     return;
  649.   }
  651.   // We can now resolve this.updatePromise (it should be non-null)
  652.   goog.asserts.assert(this.updatePromise_,
  653.                       'updatePromise_ not set in onMsKeyAdded_');
  654.   if (this.updatePromise_) {
  655.     this.updateKeyStatus_('usable');
  656.     this.updatePromise_.resolve();
  657.     this.updatePromise_ = null;
  658.   }
  659. };
  662. /**
  663.  * Handler for the native keyerror event on MSMediaKeySession.
  664.  *
  665.  * @param {!MediaKeyEvent} event
  666.  * @private
  667.  */
  668. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  669.     onMsKeyError_ = function(event) {
  670.   shaka.log.debug('PatchedMediaKeysMs.onMsKeyError_', event);
  672.   var error = new Error('EME PatchedMediaKeysMs key error');
  673.   error.errorCode = this.nativeMediaKeySession_.error;
  675.   if (this.generateRequestPromise_ != null) {
  676.     this.generateRequestPromise_.reject(error);
  677.     this.generateRequestPromise_ = null;
  678.   } else if (this.updatePromise_ != null) {
  679.     this.updatePromise_.reject(error);
  680.     this.updatePromise_ = null;
  681.   } else {
  682.     /*
  683.     Unexpected error - map native codes to standardised key statuses.
  684.     Possible values of this.nativeMediaKeySession_.error.code
  686.     MS_MEDIA_KEYERR_UNKNOWN        = 1
  687.     MS_MEDIA_KEYERR_CLIENT         = 2
  688.     MS_MEDIA_KEYERR_SERVICE        = 3
  689.     MS_MEDIA_KEYERR_OUTPUT         = 4
  690.     MS_MEDIA_KEYERR_HARDWARECHANGE = 5
  691.     MS_MEDIA_KEYERR_DOMAIN         = 6
  692.     */
  694.     switch (this.nativeMediaKeySession_.error.code) {
  695.       case MSMediaKeyError.MS_MEDIA_KEYERR_OUTPUT:
  696.       case MSMediaKeyError.MS_MEDIA_KEYERR_HARDWARECHANGE:
  697.         this.updateKeyStatus_('output-not-allowed');
  698.       default:
  699.         this.updateKeyStatus_('internal-error');
  700.     }
  701.   }
  702. };
  705. /**
  706.  * Update key status and dispatch a 'keystatuseschange' event.
  707.  *
  708.  * @param {string} status
  709.  * @private
  710.  */
  711. shaka.polyfill.PatchedMediaKeysMs.MediaKeySession.prototype.
  712.     updateKeyStatus_ = function(status) {
  713.   this.keyStatuses.setStatus(status);
  714.   var event = new shaka.util.FakeEvent('keystatuseschange');
  715.   this.dispatchEvent(event);
  716. };
  720. /**
  721.  * An implementation of MediaKeyStatusMap.
  722.  * This fakes a map with a single key ID.
  723.  *
  724.  * @constructor
  725.  * @struct
  726.  * @implements {MediaKeyStatusMap}
  727.  */
  728. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap = function() {
  729.   /**
  730.    * @type {number}
  731.    */
  732.   this.size = 0;
  734.   /**
  735.    * @private {string|undefined}
  736.    */
  737.   this.status_ = undefined;
  738. };
  741. /**
  742.  * @const {!ArrayBuffer}
  743.  * @private
  744.  */
  745. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  748. /**
  749.  * An internal method used by the session to set key status.
  750.  * @param {string|undefined} status
  751.  */
  752. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  753.     setStatus = function(status) {
  754.   this.size = status == undefined ? 0 : 1;
  755.   this.status_ = status;
  756. };
  759. /**
  760.  * An internal method used by the session to get key status.
  761.  * @return {string|undefined}
  762.  */
  763. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  764.     getStatus = function() {
  765.   return this.status_;
  766. };
  769. /** @override */
  770. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  771.     forEach = function(fn) {
  772.   if (this.status_) {
  773.     var fakeKeyId =
  774.         shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  775.     fn(this.status_, fakeKeyId);
  776.   }
  777. };
  780. /** @override */
  781. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  782.     get = function(keyId) {
  783.   if (this.has(keyId)) {
  784.     return this.status_;
  785.   }
  786.   return undefined;
  787. };
  790. /** @override */
  791. shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.prototype.
  792.     has = function(keyId) {
  793.   var fakeKeyId =
  794.       shaka.polyfill.PatchedMediaKeysMs.MediaKeyStatusMap.KEY_ID_;
  795.   if (this.status_ &&
  796.       shaka.util.Uint8ArrayUtils.equal(
  797.           new Uint8Array(keyId), new Uint8Array(fakeKeyId))) {
  798.     return true;
  799.   }
  800.   return false;
  801. };