shaka-player 4.1.3 → 4.2.0

package/lib/text/vtt_text_parser.js

@@ -412,6 +412,7 @@ shaka.text.VttTextParser = class {
       VttTextParser.addDefaultTextColor_(styles);
     }
     payload = VttTextParser.replaceColorPayload_(payload);
+    payload = VttTextParser.replaceKaraokeStylePayload_(payload);
     const xmlPayload = '<span>' + payload + '</span>';
     const element = shaka.util.XmlUtils.parseXmlString(xmlPayload, 'span');
     if (element) {
@@ -437,6 +438,44 @@ shaka.text.VttTextParser = class {
     }
   }
 
+  /**
+   * Converts karaoke style tag to be valid for xml parsing
+   * For example,
+   * input: Text <00:00:00.450> time <00:00:01.450> 1
+   * output: Text <div time="00:00:00.450"> time
+   *         <div time="00:00:01.450"> 1</div></div>
+   *
+   * @param {string} payload
+   * @return {string} processed payload
+   * @private
+   */
+  static replaceKaraokeStylePayload_(payload) {
+    const names = [];
+    let nameStart = -1;
+    for (let i = 0; i < payload.length; i++) {
+      if (payload[i] === '<') {
+        nameStart = i + 1;
+      } else if (payload[i] === '>') {
+        if (nameStart > 0) {
+          const name = payload.substr(nameStart, i - nameStart);
+          if (name.match(shaka.text.VttTextParser.timeFormat_)) {
+            names.push(name);
+          }
+          nameStart = -1;
+        }
+      }
+    }
+    let newPayload = payload;
+    for (const name of names) {
+      const replaceTag = '<' + name + '>';
+      const startTag = '<div time="' + name + '">';
+      const endTag = '</div>';
+      newPayload = newPayload.replace(replaceTag, startTag);
+      newPayload += endTag;
+    }
+    return newPayload;
+  }
+
   /**
    * Converts color end tag to be valid for xml parsing
    * For example,
@@ -560,6 +599,18 @@ shaka.text.VttTextParser = class {
           case 'u':
             nestedCue.textDecoration.push(underline);
             break;
+          case 'div': {
+            const time = /** @type {!Element} */(element).getAttribute('time');
+            if (!time) {
+              break;
+            }
+            const parser = new shaka.util.TextParser(time);
+            const cueTime = shaka.text.VttTextParser.parseTime_(parser);
+            if (cueTime) {
+              nestedCue.startTime = cueTime;
+            }
+            break;
+          }
           default:
             break;
         }
@@ -776,10 +827,7 @@ shaka.text.VttTextParser = class {
    * @private
    */
   static parseTime_(parser) {
-    // 00:00.000 or 00:00:00.000 or 0:00:00.000 or
-    // 00:00.00 or 00:00:00.00 or 0:00:00.00
-    const regexExpresion = /(?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{2,3})/g;
-    const results = parser.readRegex(regexExpresion);
+    const results = parser.readRegex(shaka.text.VttTextParser.timeFormat_);
     if (results == null) {
       return null;
     }
@@ -810,6 +858,15 @@ shaka.text.VttTextParser.MPEG_TIMESCALE_ = 90000;
  */
 shaka.text.VttTextParser.TS_ROLLOVER_ = 0x200000000;
 
+/**
+ * @const
+ * @private {!RegExp}
+ * @example 00:00.000 or 00:00:00.000 or 0:00:00.000 or
+ * 00:00.00 or 00:00:00.00 or 0:00:00.00
+ */
+shaka.text.VttTextParser.timeFormat_ =
+    /(?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{2,3})/g;
+
 shaka.text.TextEngine.registerParser(
     'text/vtt', () => new shaka.text.VttTextParser());
 

package/lib/util/error.js

@@ -693,7 +693,27 @@ shaka.util.Error.Code = {
    */
   'HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED': 4040,
 
-  // RETIRED: 'HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED': 4041,
+  /**
+   * We do not support playing encrypted content (different than mp2t) with MSE
+   * and legacy Apple MediaKeys API.
+   */
+  'HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED': 4041,
+
+  /**
+   * Web Crypto API is not available (to decrypt AES-128 streams). Web Crypto
+   * only exists in secure origins like https.
+   */
+  'NO_WEB_CRYPTO_API': 4042,
+
+  /**
+   * AES-128 iv length should be 16 bytes.
+   */
+  'HLS_AES_128_INVALID_IV_LENGTH': 4043,
+
+  /**
+   * AES-128 encryption key length should be 16 bytes.
+   */
+  'HLS_AES_128_INVALID_KEY_LENGTH': 4044,
 
 
   // RETIRED: 'INCONSISTENT_BUFFER_STATE': 5000,

package/lib/util/fairplay_utils.js

@@ -133,13 +133,83 @@ shaka.util.FairPlayUtils = class {
   }
 
   /**
-   * SPC FairPlay request.
+   * Verimatrix initDataTransform configuration.
+   *
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   * @export
+   */
+  static verimatrixInitDataTransform(initData, initDataType, drmInfo) {
+    if (initDataType !== 'skd') {
+      return initData;
+    }
+    const StringUtils = shaka.util.StringUtils;
+    const FairPlayUtils = shaka.util.FairPlayUtils;
+    const cert = drmInfo.serverCertificate;
+    const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
+    const contentId = initDataAsString.split('skd://').pop();
+    return FairPlayUtils.initDataTransform(initData, contentId, cert);
+  }
+
+  /**
+   * EZDRM initDataTransform configuration.
+   *
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   * @export
+   */
+  static ezdrmInitDataTransform(initData, initDataType, drmInfo) {
+    if (initDataType !== 'skd') {
+      return initData;
+    }
+    const StringUtils = shaka.util.StringUtils;
+    const FairPlayUtils = shaka.util.FairPlayUtils;
+    const cert = drmInfo.serverCertificate;
+    const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
+    const contentId = initDataAsString.split(';').pop();
+    return FairPlayUtils.initDataTransform(initData, contentId, cert);
+  }
+
+  /**
+   * Conax initDataTransform configuration.
+   *
+   * @param {!Uint8Array} initData
+   * @param {string} initDataType
+   * @param {?shaka.extern.DrmInfo} drmInfo
+   * @export
+   */
+  static conaxInitDataTransform(initData, initDataType, drmInfo) {
+    if (initDataType !== 'skd') {
+      return initData;
+    }
+    const StringUtils = shaka.util.StringUtils;
+    const FairPlayUtils = shaka.util.FairPlayUtils;
+    const cert = drmInfo.serverCertificate;
+    const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
+    const skdValue = initDataAsString.split('skd://').pop().split('?').shift();
+    const stringToArray = (string) => {
+      // 2 bytes for each char
+      const buffer = new ArrayBuffer(string.length * 2);
+      const array = new Uint16Array(buffer);
+      for (let i = 0, strLen = string.length; i < strLen; i++) {
+        array[i] = string.charCodeAt(i);
+      }
+      return array;
+    };
+    const contentId = stringToArray(window.atob(skdValue));
+    return FairPlayUtils.initDataTransform(initData, contentId, cert);
+  }
+
+  /**
+   * Verimatrix FairPlay request.
    *
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
    * @export
    */
-  static spcFairPlayRequest(type, request) {
+  static verimatrixFairPlayRequest(type, request) {
     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
       return;
     }
@@ -150,6 +220,34 @@ shaka.util.FairPlayUtils = class {
     request.body = shaka.util.StringUtils.toUTF8('spc=' + base64Payload);
   }
 
+  /**
+   * EZDRM FairPlay request.
+   *
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @export
+   */
+  static ezdrmFairPlayRequest(type, request) {
+    if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
+      return;
+    }
+    request.headers['Content-Type'] = 'application/octet-stream';
+  }
+
+  /**
+   * Conax FairPlay request.
+   *
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.Request} request
+   * @export
+   */
+  static conaxFairPlayRequest(type, request) {
+    if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
+      return;
+    }
+    request.headers['Content-Type'] = 'application/octet-stream';
+  }
+
   /**
    * Common FairPlay response transform for some DRMs providers.
    *

package/lib/util/platform.js

@@ -199,7 +199,8 @@ shaka.util.Platform = class {
     return !!navigator.vendor && navigator.vendor.includes('Apple') &&
         !shaka.util.Platform.isTizen() &&
         !shaka.util.Platform.isEOS() &&
-        !shaka.util.Platform.isPS4();
+        !shaka.util.Platform.isPS4() &&
+        !shaka.util.Platform.isAmazonFireTV();
   }
 
   /**
@@ -222,6 +223,16 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('PlayStation 4');
   }
 
+  /**
+   * Check if the current platform is Amazon Fire TV.
+   * https://developer.amazon.com/docs/fire-tv/identify-amazon-fire-tv-devices.html
+   *
+   * @return {boolean}
+   */
+  static isAmazonFireTV() {
+    return shaka.util.Platform.userAgentContains_('AFT');
+  }
+
   /**
    * Returns a major version number for Safari, or Safari-based iOS browsers.
    *

package/lib/util/player_configuration.js

@@ -147,7 +147,7 @@ shaka.util.PlayerConfiguration = class {
       ignoreTextStreamFailures: false,
       alwaysStreamText: false,
       startAtSegmentBoundary: false,
-      gapDetectionThreshold: 0.1,
+      gapDetectionThreshold: 0.5,
       durationBackoff: 1,
       forceTransmuxTS: false,
       // Offset by 5 seconds since Chromecast takes a few seconds to start
@@ -173,15 +173,6 @@ shaka.util.PlayerConfiguration = class {
       maxDisabledTime: 30,
     };
 
-    // Some browsers will stop earlier than others before a gap (e.g., Edge
-    // stops 0.5 seconds before a gap). So for some browsers we need to use a
-    // larger threshold. See: https://bit.ly/2K5xmJO
-    if (shaka.util.Platform.isLegacyEdge() ||
-        shaka.util.Platform.isTizen() ||
-        shaka.util.Platform.isChromecast()) {
-      streaming.gapDetectionThreshold = 0.5;
-    }
-
     // WebOS, Tizen, and Chromecast have long hardware pipelines that respond
     // slowly to seeking.  Therefore we should not seek when we detect a stall
     // on one of these platforms.  Instead, default stallSkip to 0 to force the
@@ -253,6 +244,8 @@ shaka.util.PlayerConfiguration = class {
         fastHalfLife: 2,
         slowHalfLife: 5,
       },
+      restrictToElementSize: false,
+      ignoreDevicePixelRatio: false,
     };
 
     const cmcd = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.1.3",
+  "version": "4.2.0",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/shaka-player.uncompiled.js

@@ -38,6 +38,7 @@ goog.require('shaka.polyfill.Fullscreen');
 goog.require('shaka.polyfill.MediaSource');
 goog.require('shaka.polyfill.MediaCapabilities');
 goog.require('shaka.polyfill.Orientation');
+goog.require('shaka.polyfill.PatchedMediaKeysApple');
 goog.require('shaka.polyfill.PatchedMediaKeysNop');
 goog.require('shaka.polyfill.PatchedMediaKeysWebkit');
 goog.require('shaka.polyfill.PiPWebkit');

package/test/hls/hls_parser_unit.js

@@ -33,6 +33,8 @@ describe('HlsParser', () => {
   let segmentData;
   /** @type {!Uint8Array} */
   let selfInitializingSegmentData;
+  /** @type {!Uint8Array} */
+  let aes128Key;
 
   afterEach(() => {
     shaka.log.alwaysWarn = originalAlwaysWarn;
@@ -75,6 +77,11 @@ describe('HlsParser', () => {
     selfInitializingSegmentData =
         shaka.util.Uint8ArrayUtils.concat(initSegmentData, segmentData);
 
+    aes128Key = new Uint8Array([
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+    ]);
+
     fakeNetEngine = new shaka.test.FakeNetworkingEngine();
 
     config = shaka.util.PlayerConfiguration.createDefault().manifest;
@@ -2432,7 +2439,7 @@ describe('HlsParser', () => {
     expect(initSegments[1].getUris()[0]).toBe('test:/init2.mp4');
   });
 
-  it('drops variants encrypted with AES-128', async () => {
+  it('parses variants encrypted with AES-128', async () => {
     const master = [
       '#EXTM3U\n',
       '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,mp4a",',
@@ -2441,10 +2448,15 @@ describe('HlsParser', () => {
       '#EXT-X-STREAM-INF:BANDWIDTH=300,CODECS="avc1,mp4a",',
       'RESOLUTION=960x540,FRAME-RATE=120,AUDIO="aud2"\n',
       'video2\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=300,CODECS="avc1,mp4a",',
+      'RESOLUTION=960x540,FRAME-RATE=120,AUDIO="aud3"\n',
+      'video3\n',
       '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="eng",',
       'URI="audio"\n',
       '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud2",LANGUAGE="fr",',
       'URI="audio2"\n',
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud3",LANGUAGE="de",',
+      'URI="audio3"\n',
     ].join('');
 
     const media = [
@@ -2456,17 +2468,26 @@ describe('HlsParser', () => {
       'main.mp4',
     ].join('');
 
-    const mediaWithAesEncryption = [
+    const mediaWithMp4AesEncryption = [
       '#EXTM3U\n',
       '#EXT-X-PLAYLIST-TYPE:VOD\n',
       '#EXT-X-KEY:METHOD=AES-128,',
-      'URI="800k.key\n',
+      'URI="800k.key"\n',
       '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
       '#EXTINF:5,\n',
       '#EXT-X-BYTERANGE:121090@616\n',
       'main.mp4',
     ].join('');
 
+    const mediaWithTSAesEncryption = [
+      '#EXTM3U\n',
+      '#EXT-X-PLAYLIST-TYPE:VOD\n',
+      '#EXT-X-KEY:METHOD=AES-128,',
+      'URI="800k.key"\n',
+      '#EXTINF:5,\n',
+      'main.ts',
+    ].join('');
+
     const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
       manifest.anyTimeline();
       manifest.addPartialVariant((variant) => {
@@ -2478,6 +2499,24 @@ describe('HlsParser', () => {
           stream.language = 'en';
         });
       });
+      manifest.addPartialVariant((variant) => {
+        variant.bandwidth = 300;
+        variant.addPartialStream(ContentType.VIDEO, (stream) => {
+          stream.size(960, 540);
+        });
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'fr';
+        });
+      });
+      manifest.addPartialVariant((variant) => {
+        variant.bandwidth = 300;
+        variant.addPartialStream(ContentType.VIDEO, (stream) => {
+          stream.size(960, 540);
+        });
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'de';
+        });
+      });
       manifest.sequenceMode = true;
     });
 
@@ -2485,12 +2524,15 @@ describe('HlsParser', () => {
         .setResponseText('test:/master', master)
         .setResponseText('test:/audio', media)
         .setResponseText('test:/audio2', media)
+        .setResponseText('test:/audio3', media)
         .setResponseText('test:/video', media)
-        .setResponseText('test:/video2', mediaWithAesEncryption)
+        .setResponseText('test:/video2', mediaWithMp4AesEncryption)
+        .setResponseText('test:/video3', mediaWithTSAesEncryption)
         .setResponseText('test:/main.vtt', vttText)
         .setResponseValue('test:/init.mp4', initSegmentData)
         .setResponseValue('test:/main.mp4', segmentData)
         .setResponseValue('test:/main.test', segmentData)
+        .setResponseValue('test:/800k.key', aes128Key)
         .setResponseValue('test:/selfInit.mp4', selfInitializingSegmentData);
 
     const actual = await parser.start('test:/master', playerInterface);
@@ -2674,7 +2716,9 @@ describe('HlsParser', () => {
           .setResponseText('test:/video', media)
           .setResponseValue('test:/main.exe', segmentData)
           .setResponseValue('test:/init.mp4', initSegmentData)
-          .setResponseValue('test:/main.mp4', segmentData);
+          .setResponseValue('test:/main.mp4', segmentData)
+          .setResponseValue('data:text/plain;base64,AAECAwQFBgcICQoLDA0ODw==',
+              aes128Key);
 
       await expectAsync(parser.start('test:/master', playerInterface))
           .toBeRejectedWith(Util.jasmineError(error));
@@ -2708,34 +2752,6 @@ describe('HlsParser', () => {
       await verifyError(master, media, error);
     });
 
-    it('if all variants are encrypted with AES-128', async () => {
-      const master = [
-        '#EXTM3U\n',
-        '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1",',
-        'RESOLUTION=960x540,FRAME-RATE=60\n',
-        'video\n',
-      ].join('');
-
-      const media = [
-        '#EXTM3U\n',
-        '#EXT-X-TARGETDURATION:6\n',
-        '#EXT-X-PLAYLIST-TYPE:VOD\n',
-        '#EXT-X-KEY:METHOD=AES-128,',
-        'URI="data:text/plain;base64\n',
-        '#EXT-X-MAP:URI="init.mp4"\n',
-        '#EXTINF:5,\n',
-        '#EXT-X-BYTERANGE:121090@616\n',
-        'main.mp4',
-      ].join('');
-
-      const error = new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          Code.HLS_AES_128_ENCRYPTION_NOT_SUPPORTED);
-
-      await verifyError(master, media, error);
-    });
-
     describe('if required attributes are missing', () => {
       /**
        * @param {string} master

package/test/media/streaming_engine_unit.js

@@ -100,10 +100,13 @@ describe('StreamingEngine', () => {
     jasmine.clock().mockDate();
   });
 
-  /** @param {boolean=} trickMode
+  /**
+   * @param {boolean=} trickMode
    * @param {number=} mediaOffset The offset from 0 for the segment start times
+   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key The AES-128 key to put in
+   *   the manifest, if one should exist
    */
-  function setupVod(trickMode, mediaOffset) {
+  function setupVod(trickMode, mediaOffset, hlsAes128Key) {
     // For VOD, we fake a presentation that has 2 Periods of equal duration
     // (20 seconds), where each Period has 1 Variant and 1 text stream.
     //
@@ -209,7 +212,8 @@ describe('StreamingEngine', () => {
     setupManifest(
         /* firstPeriodStartTime= */ 0,
         /* secondPeriodStartTime= */ 20,
-        /* presentationDuration= */ 40);
+        /* presentationDuration= */ 40,
+        hlsAes128Key);
   }
 
   function setupLive() {
@@ -356,8 +360,15 @@ describe('StreamingEngine', () => {
         /* delays= */ netEngineDelays);
   }
 
+  /**
+   * @param {number} firstPeriodStartTime
+   * @param {number} secondPeriodStartTime
+   * @param {number} presentationDuration
+   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
+   */
   function setupManifest(
-      firstPeriodStartTime, secondPeriodStartTime, presentationDuration) {
+      firstPeriodStartTime, secondPeriodStartTime, presentationDuration,
+      hlsAes128Key) {
     const segmentDurations = {
       audio: segmentData[ContentType.AUDIO].segmentDuration,
       video: segmentData[ContentType.VIDEO].segmentDuration,
@@ -380,7 +391,7 @@ describe('StreamingEngine', () => {
         /** @type {!shaka.media.PresentationTimeline} */(timeline),
         [firstPeriodStartTime, secondPeriodStartTime],
         presentationDuration, segmentDurations, initSegmentRanges,
-        timestampOffsets);
+        timestampOffsets, hlsAes128Key);
 
     audioStream = manifest.variants[0].audio;
     videoStream = manifest.variants[0].video;
@@ -3430,6 +3441,69 @@ describe('StreamingEngine', () => {
     expect(alternateVideoStream.createSegmentIndex).not.toHaveBeenCalled();
   });
 
+  describe('AES-128', () => {
+    let key;
+    /** @type {!shaka.extern.HlsAes128Key} */
+    let hlsAes128Key;
+
+    beforeEach(async () => {
+      // Get a key.
+      const keyData = new ArrayBuffer(16);
+      const keyDataView = new DataView(keyData);
+      keyDataView.setInt16(0, 31710); // 0111 1011 1101 1110
+      key = await window.crypto.subtle.importKey(
+          'raw', keyData, 'AES-CBC', true, ['decrypt']);
+
+      // Set up a manifest with AES-128 key info.
+      // We don't actually provide the imported key OR the key fetching function
+      // here, though, so that the individual tests can choose what the starting
+      // state of the hlsAes128Key object is.
+      hlsAes128Key = {method: 'AES-128', firstMediaSequenceNumber: 0};
+
+      setupVod(false, 0, hlsAes128Key);
+      mediaSourceEngine = new shaka.test.FakeMediaSourceEngine(segmentData);
+      presentationTimeInSeconds = 0;
+      createStreamingEngine();
+      streamingEngine.switchVariant(variant);
+    });
+
+    afterEach(async () => {
+      await streamingEngine.destroy();
+    });
+
+    async function runTest() {
+      spyOn(window.crypto.subtle, 'decrypt').and.callThrough();
+
+      await streamingEngine.start();
+      playing = true;
+      await Util.fakeEventLoop(10);
+
+      expect(mediaSourceEngine.appendBuffer).toHaveBeenCalledTimes(2);
+      expect(window.crypto.subtle.decrypt).toHaveBeenCalledTimes(2);
+      expect(window.crypto.subtle.decrypt).toHaveBeenCalledWith(
+          {name: 'AES-CBC', iv: jasmine.any(Object)}, key, jasmine.any(Object));
+    }
+
+    it('decrypts segments', async () => {
+      hlsAes128Key.cryptoKey = key;
+      await runTest();
+    });
+
+    it('downloads key if not pre-filled', async () => {
+      hlsAes128Key.fetchKey = () => {
+        hlsAes128Key.cryptoKey = key;
+        hlsAes128Key.fetchKey = undefined;
+        return Promise.resolve();
+      };
+
+      await runTest();
+
+      // The key should have been fetched.
+      expect(hlsAes128Key.cryptoKey).not.toBeUndefined();
+      expect(hlsAes128Key.fetchKey).toBeUndefined();
+    });
+  });
+
   describe('destroy', () => {
     it('aborts pending network operations', async () => {
       setupVod();

package/test/test/util/simple_fakes.js

@@ -481,6 +481,10 @@ shaka.test.FakeSegmentIndex = class {
               return this.get(nextPosition - 1);
             },
 
+            currentPosition: () => {
+              return nextPosition;
+            },
+
             seek: (time) => {
               nextPosition = this.find(time);
               return this.get(nextPosition++);

package/test/test/util/streaming_engine_util.js

@@ -149,11 +149,13 @@ shaka.test.StreamingEngineUtil = class {
    *   ranges for each type of init segment.
    * @param {!Object.<string,number>=} timestampOffsets The timestamp offset
    *  for each type of segment
+   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key The AES-128 key to provide
+   *  to streams, if desired.
    * @return {shaka.extern.Manifest}
    */
   static createManifest(
       presentationTimeline, periodStartTimes, presentationDuration,
-      segmentDurations, initSegmentRanges, timestampOffsets) {
+      segmentDurations, initSegmentRanges, timestampOffsets, hlsAes128Key) {
     const Util = shaka.test.Util;
 
     /**
@@ -255,7 +257,7 @@ shaka.test.StreamingEngineUtil = class {
       const appendWindowEnd = periodIndex == periodStartTimes.length - 1?
           presentationDuration : periodStartTimes[periodIndex + 1];
 
-      return new shaka.media.SegmentReference(
+      const ref = new shaka.media.SegmentReference(
           /* startTime= */ periodStart + positionWithinPeriod * d,
           /* endTime= */ periodStart + (positionWithinPeriod + 1) * d,
           getUris,
@@ -265,6 +267,12 @@ shaka.test.StreamingEngineUtil = class {
           timestampOffset,
           appendWindowStart,
           appendWindowEnd);
+      const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      if (hlsAes128Key &&
+          (type == ContentType.AUDIO || type == ContentType.VIDEO)) {
+        ref.hlsAes128Key = hlsAes128Key;
+      }
+      return ref;
     };
 
     /** @type {shaka.extern.Manifest} */