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.util.EventManager');
  23. goog.require('shaka.util.FakeEvent');
  24. goog.require('shaka.util.FakeEventTarget');
  25. goog.require('shaka.util.PublicPromise');
  26. goog.require('shaka.util.StringUtils');
  27. goog.require('shaka.util.Uint8ArrayUtils');
  30. /**
  31.  * Store api prefix.
  32.  *
  33.  * @private {string}
  34.  */
  35. shaka.polyfill.PatchedMediaKeysWebkit.prefix_ = '';
  38. /**
  39.  * Install a polyfill to implement {@link http://goo.gl/blgtZZ EME draft
  40.  * 12 March 2015} on top of webkit-prefixed
  41.  * {@link http://goo.gl/FSpoAo EME v0.1b}.
  42.  *
  43.  * @param {string} prefix
  44.  */
  45. shaka.polyfill.PatchedMediaKeysWebkit.install = function(prefix) {
  46.   shaka.log.debug('PatchedMediaKeysWebkit.install');
  48.   // Alias.
  49.   var PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  50.   PatchedMediaKeysWebkit.prefix_ = prefix;
  51.   var prefixApi = PatchedMediaKeysWebkit.prefixApi_;
  53.   goog.asserts.assert(
  54.       HTMLMediaElement.prototype[prefixApi('generateKeyRequest')],
  55.                       'PatchedMediaKeysWebkit APIs not available!');
  57.   // Construct fake key ID.  This is not done at load-time to avoid exceptions
  58.   // on unsupported browsers.  This particular fake key ID was suggested in
  59.   // w3c/encrypted-media#32.
  60.   PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_ =
  61.       (new Uint8Array([0])).buffer;
  63.   // Install patches.
  64.   navigator.requestMediaKeySystemAccess =
  65.       PatchedMediaKeysWebkit.requestMediaKeySystemAccess;
  66.   // Delete mediaKeys to work around strict mode compatibility issues.
  67.   delete HTMLMediaElement.prototype['mediaKeys'];
  68.   // Work around read-only declaration for mediaKeys by using a string.
  69.   HTMLMediaElement.prototype['mediaKeys'] = null;
  70.   HTMLMediaElement.prototype.setMediaKeys = PatchedMediaKeysWebkit.setMediaKeys;
  71.   window.MediaKeys = PatchedMediaKeysWebkit.MediaKeys;
  72.   window.MediaKeySystemAccess = PatchedMediaKeysWebkit.MediaKeySystemAccess;
  73. };
  76. /**
  77.  * Prefix api by stored prefix.
  78.  *
  79.  * @param {string} api
  80.  * @return {string}
  81.  * @private
  82.  */
  83. shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_ = function(api) {
  84.   var prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  85.   if (prefix) {
  86.     return prefix + api.charAt(0).toUpperCase() + api.slice(1);
  87.   }
  88.   return api;
  89. };
  92. /**
  93.  * An implementation of navigator.requestMediaKeySystemAccess.
  94.  * Retrieve a MediaKeySystemAccess object.
  95.  *
  96.  * @this {!Navigator}
  97.  * @param {string} keySystem
  98.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  99.  * @return {!Promise.<!MediaKeySystemAccess>}
  100.  */
  101. shaka.polyfill.PatchedMediaKeysWebkit.requestMediaKeySystemAccess =
  102.     function(keySystem, supportedConfigurations) {
  103.   shaka.log.debug('PatchedMediaKeysWebkit.requestMediaKeySystemAccess');
  104.   goog.asserts.assert(this == navigator,
  105.                       'bad "this" for requestMediaKeySystemAccess');
  107.   // Alias.
  108.   var PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  109.   try {
  110.     var access = new PatchedMediaKeysWebkit.MediaKeySystemAccess(
  111.         keySystem, supportedConfigurations);
  112.     return Promise.resolve(/** @type {!MediaKeySystemAccess} */ (access));
  113.   } catch (exception) {
  114.     return Promise.reject(exception);
  115.   }
  116. };
  119. /**
  120.  * An implementation of HTMLMediaElement.prototype.setMediaKeys.
  121.  * Attach a MediaKeys object to the media element.
  122.  *
  123.  * @this {!HTMLMediaElement}
  124.  * @param {MediaKeys} mediaKeys
  125.  * @return {!Promise}
  126.  */
  127. shaka.polyfill.PatchedMediaKeysWebkit.setMediaKeys = function(mediaKeys) {
  128.   shaka.log.debug('PatchedMediaKeysWebkit.setMediaKeys');
  129.   goog.asserts.assert(this instanceof HTMLMediaElement,
  130.                       'bad "this" for setMediaKeys');
  132.   // Alias.
  133.   var PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  135.   var newMediaKeys =
  136.       /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  137.           mediaKeys);
  138.   var oldMediaKeys =
  139.       /** @type {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys} */ (
  140.           this.mediaKeys);
  142.   if (oldMediaKeys && oldMediaKeys != newMediaKeys) {
  143.     goog.asserts.assert(
  144.         oldMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  145.         'non-polyfill instance of oldMediaKeys');
  146.     // Have the old MediaKeys stop listening to events on the video tag.
  147.     oldMediaKeys.setMedia(null);
  148.   }
  150.   delete this['mediaKeys'];  // in case there is an existing getter
  151.   this['mediaKeys'] = mediaKeys;  // work around read-only declaration
  153.   if (newMediaKeys) {
  154.     goog.asserts.assert(
  155.         newMediaKeys instanceof PatchedMediaKeysWebkit.MediaKeys,
  156.         'non-polyfill instance of newMediaKeys');
  157.     newMediaKeys.setMedia(this);
  158.   }
  160.   return Promise.resolve();
  161. };
  164. /**
  165.  * For some of this polyfill's implementation, we need to query a video element.
  166.  * But for some embedded systems, it is memory-expensive to create multiple
  167.  * video elements.  Therefore, we check the document to see if we can borrow one
  168.  * to query before we fall back to creating one temporarily.
  169.  *
  170.  * @return {!HTMLVideoElement}
  171.  * @private
  172.  */
  173. shaka.polyfill.PatchedMediaKeysWebkit.getVideoElement_ = function() {
  174.   var videos = document.getElementsByTagName('video');
  175.   var tmpVideo = videos.length ? videos[0] : document.createElement('video');
  176.   return /** @type {!HTMLVideoElement} */(tmpVideo);
  177. };
  181. /**
  182.  * An implementation of MediaKeySystemAccess.
  183.  *
  184.  * @constructor
  185.  * @struct
  186.  * @param {string} keySystem
  187.  * @param {!Array.<!MediaKeySystemConfiguration>} supportedConfigurations
  188.  * @implements {MediaKeySystemAccess}
  189.  * @throws {Error} if the key system is not supported.
  190.  */
  191. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess =
  192.     function(keySystem, supportedConfigurations) {
  193.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySystemAccess');
  195.   /** @type {string} */
  196.   this.keySystem = keySystem;
  198.   /** @private {string} */
  199.   this.internalKeySystem_ = keySystem;
  201.   /** @private {!MediaKeySystemConfiguration} */
  202.   this.configuration_;
  204.   // This is only a guess, since we don't really know from the prefixed API.
  205.   var allowPersistentState = false;
  207.   if (keySystem == 'org.w3.clearkey') {
  208.     // ClearKey's string must be prefixed in v0.1b.
  209.     this.internalKeySystem_ = 'webkit-org.w3.clearkey';
  210.     // ClearKey doesn't support persistence.
  211.     allowPersistentState = false;
  212.   }
  214.   var success = false;
  215.   var tmpVideo = shaka.polyfill.PatchedMediaKeysWebkit.getVideoElement_();
  216.   for (var i = 0; i < supportedConfigurations.length; ++i) {
  217.     var cfg = supportedConfigurations[i];
  219.     // Create a new config object and start adding in the pieces which we
  220.     // find support for.  We will return this from getConfiguration() if
  221.     // asked.
  222.     /** @type {!MediaKeySystemConfiguration} */
  223.     var newCfg = {
  224.       'audioCapabilities': [],
  225.       'videoCapabilities': [],
  226.       // It is technically against spec to return these as optional, but we
  227.       // don't truly know their values from the prefixed API:
  228.       'persistentState': 'optional',
  229.       'distinctiveIdentifier': 'optional',
  230.       // Pretend the requested init data types are supported, since we don't
  231.       // really know that either:
  232.       'initDataTypes': cfg.initDataTypes,
  233.       'sessionTypes': ['temporary'],
  234.       'label': cfg.label
  235.     };
  237.     // v0.1b tests for key system availability with an extra argument on
  238.     // canPlayType.
  239.     var ranAnyTests = false;
  240.     if (cfg.audioCapabilities) {
  241.       for (var j = 0; j < cfg.audioCapabilities.length; ++j) {
  242.         var cap = cfg.audioCapabilities[j];
  243.         if (cap.contentType) {
  244.           ranAnyTests = true;
  245.           // In Chrome <= 40, if you ask about Widevine-encrypted audio support,
  246.           // you get a false-negative when you specify codec information.
  247.           // Work around this by stripping codec info for audio types.
  248.           var contentType = cap.contentType.split(';')[0];
  249.           if (tmpVideo.canPlayType(contentType, this.internalKeySystem_)) {
  250.             newCfg.audioCapabilities.push(cap);
  251.             success = true;
  252.           }
  253.         }
  254.       }
  255.     }
  256.     if (cfg.videoCapabilities) {
  257.       for (var j = 0; j < cfg.videoCapabilities.length; ++j) {
  258.         var cap = cfg.videoCapabilities[j];
  259.         if (cap.contentType) {
  260.           ranAnyTests = true;
  261.           if (tmpVideo.canPlayType(cap.contentType, this.internalKeySystem_)) {
  262.             newCfg.videoCapabilities.push(cap);
  263.             success = true;
  264.           }
  265.         }
  266.       }
  267.     }
  269.     if (!ranAnyTests) {
  270.       // If no specific types were requested, we check all common types to find
  271.       // out if the key system is present at all.
  272.       success = tmpVideo.canPlayType('video/mp4', this.internalKeySystem_) ||
  273.                 tmpVideo.canPlayType('video/webm', this.internalKeySystem_);
  274.     }
  275.     if (cfg.persistentState == 'required') {
  276.       if (allowPersistentState) {
  277.         newCfg.persistentState = 'required';
  278.         newCfg.sessionTypes = ['persistent-license'];
  279.       } else {
  280.         success = false;
  281.       }
  282.     }
  284.     if (success) {
  285.       this.configuration_ = newCfg;
  286.       return;
  287.     }
  288.   }  // for each cfg in supportedConfigurations
  290.   var message = 'Unsupported keySystem';
  291.   if (keySystem == 'org.w3.clearkey' || keySystem == 'com.widevine.alpha') {
  292.     message = 'None of the requested configurations were supported.';
  293.   }
  294.   var unsupportedError = new Error(message);
  295.   unsupportedError.name = 'NotSupportedError';
  296.   unsupportedError.code = DOMException.NOT_SUPPORTED_ERR;
  297.   throw unsupportedError;
  298. };
  301. /** @override */
  302. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess.prototype.
  303.     createMediaKeys = function() {
  304.   shaka.log.debug(
  305.       'PatchedMediaKeysWebkit.MediaKeySystemAccess.createMediaKeys');
  307.   // Alias.
  308.   var PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  309.   var mediaKeys = new PatchedMediaKeysWebkit.MediaKeys(this.internalKeySystem_);
  310.   return Promise.resolve(/** @type {!MediaKeys} */ (mediaKeys));
  311. };
  314. /** @override */
  315. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySystemAccess.prototype.
  316.     getConfiguration = function() {
  317.   shaka.log.debug(
  318.       'PatchedMediaKeysWebkit.MediaKeySystemAccess.getConfiguration');
  319.   return this.configuration_;
  320. };
  324. /**
  325.  * An implementation of MediaKeys.
  326.  *
  327.  * @constructor
  328.  * @struct
  329.  * @param {string} keySystem
  330.  * @implements {MediaKeys}
  331.  */
  332. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys = function(keySystem) {
  333.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys');
  335.   /** @private {string} */
  336.   this.keySystem_ = keySystem;
  338.   /** @private {HTMLMediaElement} */
  339.   this.media_ = null;
  341.   /** @private {!shaka.util.EventManager} */
  342.   this.eventManager_ = new shaka.util.EventManager();
  344.   /**
  345.    * @private {!Array.<!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  346.    */
  347.   this.newSessions_ = [];
  349.   /**
  350.    * @private {!Object.<string,
  351.    *                    !shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession>}
  352.    */
  353.   this.sessionMap_ = {};
  354. };
  357. /**
  358.  * @param {HTMLMediaElement} media
  359.  * @protected
  360.  */
  361. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.setMedia =
  362.     function(media) {
  363.   this.media_ = media;
  365.   // Remove any old listeners.
  366.   this.eventManager_.removeAll();
  368.   var prefix = shaka.polyfill.PatchedMediaKeysWebkit.prefix_;
  369.   if (media) {
  370.     // Intercept and translate these prefixed EME events.
  371.     this.eventManager_.listen(media, prefix + 'needkey',
  372.         /** @type {shaka.util.EventManager.ListenerType} */ (
  373.             this.onWebkitNeedKey_.bind(this)));
  375.     this.eventManager_.listen(media, prefix + 'keymessage',
  376.         /** @type {shaka.util.EventManager.ListenerType} */ (
  377.             this.onWebkitKeyMessage_.bind(this)));
  379.     this.eventManager_.listen(media, prefix + 'keyadded',
  380.         /** @type {shaka.util.EventManager.ListenerType} */ (
  381.             this.onWebkitKeyAdded_.bind(this)));
  383.     this.eventManager_.listen(media, prefix + 'keyerror',
  384.         /** @type {shaka.util.EventManager.ListenerType} */ (
  385.             this.onWebkitKeyError_.bind(this)));
  386.   }
  387. };
  390. /** @override */
  391. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.createSession =
  392.     function(opt_sessionType) {
  393.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.createSession');
  395.   var sessionType = opt_sessionType || 'temporary';
  396.   // TODO: Consider adding support for persistent-release once Chrome has
  397.   // implemented it natively.  http://crbug.com/448888
  398.   // This is a non-issue if we've deprecated the polyfill by then, since
  399.   // prefixed EME is on its way out.
  400.   if (sessionType != 'temporary' && sessionType != 'persistent-license') {
  401.     throw new TypeError('Session type ' + opt_sessionType +
  402.                         ' is unsupported on this platform.');
  403.   }
  405.   // Alias.
  406.   var PatchedMediaKeysWebkit = shaka.polyfill.PatchedMediaKeysWebkit;
  408.   // Unprefixed EME allows for session creation without a video tag or src.
  409.   // Prefixed EME requires both a valid HTMLMediaElement and a src.
  410.   var media = this.media_ || /** @type {!HTMLMediaElement} */(
  411.       document.createElement('video'));
  412.   if (!media.src) media.src = 'about:blank';
  414.   var session = new PatchedMediaKeysWebkit.MediaKeySession(
  415.       media, this.keySystem_, sessionType);
  416.   this.newSessions_.push(session);
  417.   return session;
  418. };
  421. /** @override */
  422. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.setServerCertificate =
  423.     function(serverCertificate) {
  424.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.setServerCertificate');
  426.   // There is no equivalent in v0.1b, so return failure.
  427.   return Promise.resolve(false);
  428. };
  431. /**
  432.  * @param {!MediaKeyEvent} event
  433.  * @private
  434.  */
  435. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitNeedKey_ =
  436.     function(event) {
  437.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitNeedKey_', event);
  438.   goog.asserts.assert(this.media_, 'media_ not set in onWebkitNeedKey_');
  440.   var event2 =
  441.       /** @type {!CustomEvent} */ (document.createEvent('CustomEvent'));
  442.   event2.initCustomEvent('encrypted', false, false, null);
  444.   // not used by v0.1b EME, but given a valid value
  445.   event2.initDataType = 'webm';
  446.   event2.initData = event.initData;
  448.   this.media_.dispatchEvent(event2);
  449. };
  452. /**
  453.  * @param {!MediaKeyEvent} event
  454.  * @private
  455.  */
  456. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitKeyMessage_ =
  457.     function(event) {
  458.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyMessage_', event);
  460.   var session = this.findSession_(event.sessionId);
  461.   if (!session) {
  462.     shaka.log.error('Session not found', event.sessionId);
  463.     return;
  464.   }
  466.   var isNew = session.keyStatuses.getStatus() == undefined;
  468.   var event2 = new shaka.util.FakeEvent('message', {
  469.     messageType: isNew ? 'licenserequest' : 'licenserenewal',
  470.     message: event.message
  471.   });
  473.   session.generated();
  474.   session.dispatchEvent(event2);
  475. };
  478. /**
  479.  * @param {!MediaKeyEvent} event
  480.  * @private
  481.  */
  482. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitKeyAdded_ =
  483.     function(event) {
  484.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyAdded_', event);
  486.   var session = this.findSession_(event.sessionId);
  487.   goog.asserts.assert(session, 'unable to find session in onWebkitKeyAdded_');
  488.   if (session) {
  489.     session.ready();
  490.   }
  491. };
  494. /**
  495.  * @param {!MediaKeyEvent} event
  496.  * @private
  497.  */
  498. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.onWebkitKeyError_ =
  499.     function(event) {
  500.   shaka.log.debug('PatchedMediaKeysWebkit.onWebkitKeyError_', event);
  502.   var session = this.findSession_(event.sessionId);
  503.   goog.asserts.assert(session, 'unable to find session in onWebkitKeyError_');
  504.   if (session) {
  505.     session.handleError(event);
  506.   }
  507. };
  510. /**
  511.  * @param {string} sessionId
  512.  * @return {shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession}
  513.  * @private
  514.  */
  515. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys.prototype.findSession_ =
  516.     function(sessionId) {
  517.   var session = this.sessionMap_[sessionId];
  518.   if (session) {
  519.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  520.     return session;
  521.   }
  523.   session = this.newSessions_.shift();
  524.   if (session) {
  525.     session.sessionId = sessionId;
  526.     this.sessionMap_[sessionId] = session;
  527.     shaka.log.debug('PatchedMediaKeysWebkit.MediaKeys.findSession_', session);
  528.     return session;
  529.   }
  531.   return null;
  532. };
  536. /**
  537.  * An implementation of MediaKeySession.
  538.  *
  539.  * @param {!HTMLMediaElement} media
  540.  * @param {string} keySystem
  541.  * @param {string} sessionType
  542.  *
  543.  * @constructor
  544.  * @struct
  545.  * @implements {MediaKeySession}
  546.  * @extends {shaka.util.FakeEventTarget}
  547.  */
  548. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession =
  549.     function(media, keySystem, sessionType) {
  550.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession');
  551.   shaka.util.FakeEventTarget.call(this);
  553.   /** @private {!HTMLMediaElement} */
  554.   this.media_ = media;
  556.   /** @private {boolean} */
  557.   this.initialized_ = false;
  559.   /** @private {shaka.util.PublicPromise} */
  560.   this.generatePromise_ = null;
  562.   /** @private {shaka.util.PublicPromise} */
  563.   this.updatePromise_ = null;
  565.   /** @private {string} */
  566.   this.keySystem_ = keySystem;
  568.   /** @private {string} */
  569.   this.type_ = sessionType;
  571.   /** @type {string} */
  572.   this.sessionId = '';
  574.   /** @type {number} */
  575.   this.expiration = NaN;
  577.   /** @type {!shaka.util.PublicPromise} */
  578.   this.closed = new shaka.util.PublicPromise();
  580.   /** @type {!shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap} */
  581.   this.keyStatuses =
  582.       new shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap();
  583. };
  584. goog.inherits(shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession,
  585.               shaka.util.FakeEventTarget);
  588. /**
  589.  * Signals that the license request has been generated.  This resolves the
  590.  * 'generateRequest' promise.
  591.  *
  592.  * @protected
  593.  */
  594. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.generated =
  595.     function() {
  596.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generated');
  598.   if (this.generatePromise_) {
  599.     this.generatePromise_.resolve();
  600.     this.generatePromise_ = null;
  601.   }
  602. };
  605. /**
  606.  * Signals that the session is 'ready', which is the terminology used in older
  607.  * versions of EME.  The new signal is to resolve the 'update' promise.  This
  608.  * translates between the two.
  609.  *
  610.  * @protected
  611.  */
  612. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.ready =
  613.     function() {
  614.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.ready');
  616.   this.updateKeyStatus_('usable');
  618.   if (this.updatePromise_) {
  619.     this.updatePromise_.resolve();
  620.   }
  621.   this.updatePromise_ = null;
  622. };
  625. /**
  626.  * Either rejects a promise, or dispatches an error event, as appropriate.
  627.  *
  628.  * @param {!MediaKeyEvent} event
  629.  */
  630. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.handleError =
  631.     function(event) {
  632.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.handleError', event);
  634.   // This does not match the DOMException we get in current WD EME, but it will
  635.   // at least provide some information which can be used to look into the
  636.   // problem.
  637.   var error = new Error('EME v0.1b key error');
  638.   error.errorCode = event.errorCode;
  639.   error.errorCode.systemCode = event.systemCode;
  641.   // The presence or absence of sessionId indicates whether this corresponds to
  642.   // generateRequest() or update().
  643.   if (!event.sessionId && this.generatePromise_) {
  644.     error.method = 'generateRequest';
  645.     if (event.systemCode == 45) {
  646.       error.message = 'Unsupported session type.';
  647.     }
  648.     this.generatePromise_.reject(error);
  649.     this.generatePromise_ = null;
  650.   } else if (event.sessionId && this.updatePromise_) {
  651.     error.method = 'update';
  652.     this.updatePromise_.reject(error);
  653.     this.updatePromise_ = null;
  654.   } else {
  655.     // This mapping of key statuses is imperfect at best.
  656.     var code = event.errorCode.code;
  657.     var systemCode = event.systemCode;
  658.     if (code == MediaKeyError['MEDIA_KEYERR_OUTPUT']) {
  659.       this.updateKeyStatus_('output-restricted');
  660.     } else if (systemCode == 1) {
  661.       this.updateKeyStatus_('expired');
  662.     } else {
  663.       this.updateKeyStatus_('internal-error');
  664.     }
  665.   }
  666. };
  669. /**
  670.  * Logic which is shared between generateRequest() and load(), both of which
  671.  * are ultimately implemented with webkitGenerateKeyRequest in prefixed EME.
  672.  *
  673.  * @param {?BufferSource} initData
  674.  * @param {?string} offlineSessionId
  675.  * @return {!Promise}
  676.  * @private
  677.  */
  678. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.generate_ =
  679.     function(initData, offlineSessionId) {
  680.   if (this.initialized_) {
  681.     return Promise.reject(new Error('The session is already initialized.'));
  682.   }
  684.   this.initialized_ = true;
  686.   /** @type {!Uint8Array} */
  687.   var mangledInitData;
  689.   try {
  690.     if (this.type_ == 'persistent-license') {
  691.       var StringUtils = shaka.util.StringUtils;
  692.       if (!offlineSessionId) {
  693.         // Persisting the initial license.
  694.         // Prefix the init data with a tag to indicate persistence.
  695.         var prefix = StringUtils.toUTF8('PERSISTENT|');
  696.         var result = new Uint8Array(prefix.byteLength + initData.byteLength);
  697.         result.set(new Uint8Array(prefix), 0);
  698.         result.set(new Uint8Array(initData), prefix.byteLength);
  699.         mangledInitData = result;
  700.       } else {
  701.         // Loading a stored license.
  702.         // Prefix the init data (which is really a session ID) with a tag to
  703.         // indicate that we are loading a persisted session.
  704.         mangledInitData = new Uint8Array(
  705.             StringUtils.toUTF8('LOAD_SESSION|' + offlineSessionId));
  706.       }
  707.     } else {
  708.       // Streaming.
  709.       goog.asserts.assert(this.type_ == 'temporary',
  710.                           'expected temporary session');
  711.       goog.asserts.assert(!offlineSessionId,
  712.                           'unexpected offline session ID');
  713.       mangledInitData = new Uint8Array(initData);
  714.     }
  716.     goog.asserts.assert(mangledInitData,
  717.                         'init data not set!');
  718.   } catch (exception) {
  719.     return Promise.reject(exception);
  720.   }
  722.   goog.asserts.assert(this.generatePromise_ == null,
  723.                       'generatePromise_ should be null');
  724.   this.generatePromise_ = new shaka.util.PublicPromise();
  726.   // Because we are hacking media.src in createSession to better emulate
  727.   // unprefixed EME's ability to create sessions and license requests without a
  728.   // video tag, we can get ourselves into trouble.  It seems that sometimes,
  729.   // the setting of media.src hasn't been processed by some other thread, and
  730.   // GKR can throw an exception.  If this occurs, wait 10 ms and try again at
  731.   // most once.  This situation should only occur when init data is available
  732.   // ahead of the 'needkey' event.
  734.   var prefixApi = shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_;
  735.   var generateKeyRequestName = prefixApi('generateKeyRequest');
  736.   try {
  737.     this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  738.   } catch (exception) {
  739.     if (exception.name != 'InvalidStateError') {
  740.       this.generatePromise_ = null;
  741.       return Promise.reject(exception);
  742.     }
  744.     setTimeout(function() {
  745.       try {
  746.         this.media_[generateKeyRequestName](this.keySystem_, mangledInitData);
  747.       } catch (exception) {
  748.         this.generatePromise_.reject(exception);
  749.         this.generatePromise_ = null;
  750.       }
  751.     }.bind(this), 10);
  752.   }
  754.   return this.generatePromise_;
  755. };
  758. /**
  759.  * An internal version of update which defers new calls while old ones are in
  760.  * progress.
  761.  *
  762.  * @param {!shaka.util.PublicPromise} promise  The promise associated with this
  763.  *   call.
  764.  * @param {?BufferSource} response
  765.  * @private
  766.  */
  767. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.update_ =
  768.     function(promise, response) {
  769.   if (this.updatePromise_) {
  770.     // We already have an update in-progress, so defer this one until after the
  771.     // old one is resolved.  Execute this whether the original one succeeds or
  772.     // fails.
  773.     this.updatePromise_.then(
  774.         this.update_.bind(this, promise, response)
  775.     ).catch(
  776.         this.update_.bind(this, promise, response)
  777.     );
  778.     return;
  779.   }
  781.   this.updatePromise_ = promise;
  783.   var key;
  784.   var keyId;
  786.   if (this.keySystem_ == 'webkit-org.w3.clearkey') {
  787.     // The current EME version of clearkey wants a structured JSON response.
  788.     // The v0.1b version wants just a raw key.  Parse the JSON response and
  789.     // extract the key and key ID.
  790.     var StringUtils = shaka.util.StringUtils;
  791.     var Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  792.     var licenseString = StringUtils.fromUTF8(response);
  793.     var jwkSet = /** @type {JWKSet} */ (JSON.parse(licenseString));
  794.     var kty = jwkSet.keys[0].kty;
  795.     if (kty != 'oct') {
  796.       // Reject the promise.
  797.       var error = new Error('Response is not a valid JSON Web Key Set.');
  798.       this.updatePromise_.reject(error);
  799.       this.updatePromise_ = null;
  800.     }
  801.     key = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].k);
  802.     keyId = Uint8ArrayUtils.fromBase64(jwkSet.keys[0].kid);
  803.   } else {
  804.     // The key ID is not required.
  805.     key = new Uint8Array(response);
  806.     keyId = null;
  807.   }
  809.   var prefixApi = shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_;
  810.   var addKeyName = prefixApi('addKey');
  811.   try {
  812.     this.media_[addKeyName](this.keySystem_, key, keyId, this.sessionId);
  813.   } catch (exception) {
  814.     // Reject the promise.
  815.     this.updatePromise_.reject(exception);
  816.     this.updatePromise_ = null;
  817.   }
  818. };
  821. /**
  822.  * Update key status and dispatch a 'keystatuseschange' event.
  823.  *
  824.  * @param {string} status
  825.  * @private
  826.  */
  827. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.
  828.     updateKeyStatus_ = function(status) {
  829.   this.keyStatuses.setStatus(status);
  830.   var event = new shaka.util.FakeEvent('keystatuseschange');
  831.   this.dispatchEvent(event);
  832. };
  835. /** @override */
  836. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.
  837.     generateRequest = function(initDataType, initData) {
  838.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.generateRequest');
  839.   return this.generate_(initData, null);
  840. };
  843. /** @override */
  844. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.load =
  845.     function(sessionId) {
  846.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.load');
  847.   if (this.type_ == 'persistent-license') {
  848.     return this.generate_(null, sessionId);
  849.   } else {
  850.     return Promise.reject(new Error('Not a persistent session.'));
  851.   }
  852. };
  855. /** @override */
  856. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.update =
  857.     function(response) {
  858.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.update', response);
  859.   goog.asserts.assert(this.sessionId, 'update without session ID');
  861.   var nextUpdatePromise = new shaka.util.PublicPromise();
  862.   this.update_(nextUpdatePromise, response);
  863.   return nextUpdatePromise;
  864. };
  867. /** @override */
  868. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.close =
  869.     function() {
  870.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.close');
  872.   // This will remove a persistent session, but it's also the only way to
  873.   // free CDM resources on v0.1b.
  874.   if (this.type_ != 'persistent-license') {
  875.     // sessionId may reasonably be null if no key request has been generated
  876.     // yet.  Unprefixed EME will return a rejected promise in this case.
  877.     // We will use the same error message that Chrome 41 uses in its EME
  878.     // implementation.
  879.     if (!this.sessionId) {
  880.       this.closed.reject(new Error('The session is not callable.'));
  881.       return this.closed;
  882.     }
  884.     // This may throw an exception, but we ignore it because we are only using
  885.     // it to clean up resources in v0.1b.  We still consider the session closed.
  886.     // We can't let the exception propagate because MediaKeySession.close()
  887.     // should not throw.
  888.     var prefixApi = shaka.polyfill.PatchedMediaKeysWebkit.prefixApi_;
  889.     var cancelKeyRequestName = prefixApi('cancelKeyRequest');
  890.     try {
  891.       this.media_[cancelKeyRequestName](this.keySystem_, this.sessionId);
  892.     } catch (exception) {}
  893.   }
  895.   // Resolve the 'closed' promise and return it.
  896.   this.closed.resolve();
  897.   return this.closed;
  898. };
  901. /** @override */
  902. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeySession.prototype.remove =
  903.     function() {
  904.   shaka.log.debug('PatchedMediaKeysWebkit.MediaKeySession.remove');
  906.   if (this.type_ != 'persistent-license') {
  907.     return Promise.reject(new Error('Not a persistent session.'));
  908.   }
  910.   return this.close();
  911. };
  915. /**
  916.  * An implementation of MediaKeyStatusMap.
  917.  * This fakes a map with a single key ID.
  918.  *
  919.  * @constructor
  920.  * @struct
  921.  * @implements {MediaKeyStatusMap}
  922.  */
  923. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap = function() {
  924.   /**
  925.    * @type {number}
  926.    */
  927.   this.size = 0;
  929.   /**
  930.    * @private {string|undefined}
  931.    */
  932.   this.status_ = undefined;
  933. };
  936. /**
  937.  * @const {!ArrayBuffer}
  938.  * @private
  939.  */
  940. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_;
  943. /**
  944.  * An internal method used by the session to set key status.
  945.  * @param {string|undefined} status
  946.  */
  947. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.setStatus =
  948.     function(status) {
  949.   this.size = status == undefined ? 0 : 1;
  950.   this.status_ = status;
  951. };
  954. /**
  955.  * An internal method used by the session to get key status.
  956.  * @return {string|undefined}
  957.  */
  958. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.getStatus =
  959.     function() {
  960.   return this.status_;
  961. };
  964. /** @override */
  965. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.forEach =
  966.     function(fn) {
  967.   if (this.status_) {
  968.     var fakeKeyId =
  969.         shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_;
  970.     fn(this.status_, fakeKeyId);
  971.   }
  972. };
  975. /** @override */
  976. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.get =
  977.     function(keyId) {
  978.   if (this.has(keyId)) {
  979.     return this.status_;
  980.   }
  981.   return undefined;
  982. };
  985. /** @override */
  986. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.has =
  987.     function(keyId) {
  988.   var fakeKeyId =
  989.       shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.KEY_ID_;
  990.   if (this.status_ &&
  991.       shaka.util.Uint8ArrayUtils.equal(
  992.           new Uint8Array(keyId), new Uint8Array(fakeKeyId))) {
  993.     return true;
  994.   }
  995.   return false;
  996. };
  999. /** @suppress {missingReturn} */
  1000. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.
  1001.     entries = function() {
  1002.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  1003. };
  1006. /** @suppress {missingReturn} */
  1007. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.
  1008.     keys = function() {
  1009.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  1010. };
  1013. /** @suppress {missingReturn} */
  1014. shaka.polyfill.PatchedMediaKeysWebkit.MediaKeyStatusMap.prototype.
  1015.     values = function() {
  1016.   goog.asserts.assert(false, 'Not used!  Provided only for compiler.');
  1017. };