shaka-player 4.0.0 → 4.0.3

package/lib/util/mime_utils.js

@@ -8,6 +8,7 @@ goog.provide('shaka.util.MimeUtils');
 
 goog.require('shaka.dependencies');
 goog.require('shaka.media.Transmuxer');
+goog.require('shaka.util.ManifestParserUtils');
 
 /**
  * @summary A set of utility functions for dealing with MIME types.
@@ -34,6 +35,8 @@ shaka.util.MimeUtils = class {
   /**
    * Takes a MIME type and a codecs string and produces the full MIME
    * type. If it's a transport stream, convert its codecs to MP4 codecs.
+   * Otherwise for multiplexed content, convert the video MIME types to
+   * their audio equivalents if the content type is audio.
    *
    * @param {string} mimeType
    * @param {string} codecs
@@ -42,13 +45,19 @@ shaka.util.MimeUtils = class {
    */
   static getFullOrConvertedType(mimeType, codecs, contentType) {
     const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    if (!shaka.dependencies.muxjs() ||
-        !shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
-      return fullMimeType;
+    if (shaka.media.Transmuxer.isTsContainer(fullMimeType)) {
+      if (shaka.dependencies.muxjs()) {
+        return shaka.media.Transmuxer.convertTsCodecs(
+            contentType, fullMimeType);
+      }
+    } else if (contentType == ContentType.AUDIO) {
+      // video/mp2t is the correct mime type for TS audio, so only replace the
+      // word "video" with "audio" for non-TS audio content.
+      return fullMimeType.replace('video', 'audio');
     }
-
-    return shaka.media.Transmuxer.convertTsCodecs(contentType, fullMimeType);
+    return fullMimeType;
   }
 
 
@@ -96,6 +105,53 @@ shaka.util.MimeUtils = class {
     return codecs.split(',');
   }
 
+  /**
+   * Get the normalized codec from a codec string,
+   * independently of their container.
+   *
+   * @param {string} codecString
+   * @return {string}
+   */
+  static getNormalizedCodec(codecString) {
+    const parts =
+      shaka.util.MimeUtils.getCodecParts_(codecString);
+    const base = parts[0];
+    const profile = parts[1].toLowerCase();
+    switch (true) {
+      case base === 'mp4a' && profile === '69':
+      case base === 'mp4a' && profile === '6b':
+        return 'mp3';
+      case base === 'mp4a' && profile === '66':
+      case base === 'mp4a' && profile === '67':
+      case base === 'mp4a' && profile === '68':
+      case base === 'mp4a' && profile === '40.2':
+      case base === 'mp4a' && profile === '40.02':
+      case base === 'mp4a' && profile === '40.5':
+      case base === 'mp4a' && profile === '40.05':
+      case base === 'mp4a' && profile === '40.29':
+      case base === 'mp4a' && profile === '40.42': // Extended HE-AAC
+        return 'aac';
+      case base === 'mp4a' && profile === 'a5':
+        return 'ac-3'; // Dolby Digital
+      case base === 'mp4a' && profile === 'a6':
+        return 'ec-3'; // Dolby Digital Plus
+      case base === 'mp4a' && profile === 'b2':
+        return 'dtsx'; // DTS:X
+      case base === 'mp4a' && profile === 'a9':
+        return 'dtsc'; // DTS Digital Surround
+      case base === 'avc1':
+      case base === 'avc3':
+        return 'avc'; // H264
+      case base === 'hvc1':
+      case base === 'hev1':
+        return 'hevc'; // H265
+      case base === 'dvh1':
+      case base === 'dvhe':
+        return 'dovi'; // Dolby Vision
+    }
+    return base;
+  }
+
   /**
    * Get the base codec from a codec string.
    *
@@ -152,7 +208,7 @@ shaka.util.MimeUtils = class {
 
     const base = parts[0];
 
-    parts.pop();
+    parts.shift();
     const profile = parts.join('.');
 
     // Make sure that we always return a "base" and "profile".

package/lib/util/periods.js

@@ -573,8 +573,8 @@ shaka.util.PeriodCombiner = class {
         // TODO(#1528): Consider changing this when we support codec switching.
         const hasCodec = outputStreams.some((s) => {
           return s.mimeType == stream.mimeType &&
-                shaka.util.MimeUtils.getCodecBase(s.codecs) ==
-                    shaka.util.MimeUtils.getCodecBase(stream.codecs);
+                shaka.util.MimeUtils.getNormalizedCodec(s.codecs) ==
+                    shaka.util.MimeUtils.getNormalizedCodec(stream.codecs);
         });
         if (!hasCodec) {
           continue;
@@ -1050,10 +1050,11 @@ shaka.util.PeriodCombiner = class {
    * @private
    */
   static areAVStreamsCompatible_(outputStream, candidate) {
-    const getCodecBase = (codecs) => shaka.util.MimeUtils.getCodecBase(codecs);
+    const getCodec = (codecs) =>
+      shaka.util.MimeUtils.getNormalizedCodec(codecs);
     // Check MIME type and codecs, which should always be the same.
     if (candidate.mimeType != outputStream.mimeType ||
-        getCodecBase(candidate.codecs) != getCodecBase(outputStream.codecs)) {
+        getCodec(candidate.codecs) != getCodec(outputStream.codecs)) {
       return false;
     }
 

package/lib/util/player_configuration.js

@@ -16,14 +16,6 @@ goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.Platform');
 
 
-// TODO(vaage): Many times in our configs, we need to create an empty
-//  implementation of a method, but to avoid closure from removing unused
-//  parameters (and breaking our merge config code) we need to use each
-//  parameter. Is there a better solution to this problem than what we are
-//  doing now?
-//
-//  NOTE: Chrome App Content Security Policy prohibits usage of new Function()
-
 /**
  * @final
  * @export
@@ -74,6 +66,11 @@ shaka.util.PlayerConfiguration = class {
       clearKeys: {},  // key is arbitrary key system ID, value must be string
       advanced: {},    // key is arbitrary key system ID, value is a record type
       delayLicenseRequestUntilPlayed: false,
+      initDataTransform: (initData, initDataType, drmInfo) => {
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [initData, initDataType, drmInfo],
+            initData);
+      },
       logLicenseExchange: false,
       updateExpirationTime: 1,
       preferredKeySystems: [],
@@ -113,11 +110,10 @@ shaka.util.PlayerConfiguration = class {
           'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb':
             'com.adobe.primetime',
         },
-        // Need some operation in the callback or else closure may remove calls
-        // to the function as it would be a no-op.  The operation can't just be
-        // a log message, because those are stripped in the compiled build.
         manifestPreprocessor: (element) => {
-          return element;
+          return shaka.util.ConfigUtils.referenceParametersAndReturn(
+              [element],
+              element);
         },
       },
       hls: {
@@ -138,7 +134,9 @@ shaka.util.PlayerConfiguration = class {
       // log message, because those are stripped in the compiled build.
       failureCallback: (error) => {
         shaka.log.error('Unhandled streaming error', error);
-        return [error];
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [error],
+            undefined);
       },
       // When low latency streaming is enabled, rebufferingGoal will default to
       // 0.01 if not specified.
@@ -214,7 +212,9 @@ shaka.util.PlayerConfiguration = class {
       // to the function as it would be a no-op.  The operation can't just be a
       // log message, because those are stripped in the compiled build.
       progressCallback: (content, progress) => {
-        return [content, progress];
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [content, progress],
+            undefined);
       },
 
       // By default we use persistent licenses as forces errors to surface if

package/lib/util/stream_utils.js

@@ -283,12 +283,14 @@ shaka.util.StreamUtils = class {
     // both be considered the same codec: avc1.42c01e, avc1.4d401f
     let baseVideoCodec = '';
     if (variant.video) {
-      baseVideoCodec = shaka.util.MimeUtils.getCodecBase(variant.video.codecs);
+      baseVideoCodec =
+        shaka.util.MimeUtils.getNormalizedCodec(variant.video.codecs);
     }
 
     let baseAudioCodec = '';
     if (variant.audio) {
-      baseAudioCodec = shaka.util.MimeUtils.getCodecBase(variant.audio.codecs);
+      baseAudioCodec =
+        shaka.util.MimeUtils.getNormalizedCodec(variant.audio.codecs);
     }
 
     return baseVideoCodec + '-' + baseAudioCodec;
@@ -1006,6 +1008,7 @@ shaka.util.StreamUtils = class {
       track.channelsCount = audio.channelsCount;
       track.audioSamplingRate = audio.audioSamplingRate;
       track.audioBandwidth = audio.bandwidth || null;
+      track.spatialAudio = audio.spatialAudio;
       track.label = audio.label;
       track.audioRoles = audio.roles;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.0.0",
+  "version": "4.0.3",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -50,7 +50,7 @@
     "less": "https://gitpkg.now.sh/joeyparrish/less.js/packages/less?28c63a43",
     "less-plugin-clean-css": "github:austingardner/less-plugin-clean-css#4e9e77bf",
     "material-design-lite": "^1.3.0",
-    "mux.js": "^5.14.1",
+    "mux.js": "^6.1.0",
     "open-sans-fonts": "^1.6.2",
     "postcss-less": "^6.0.0",
     "pwacompat": "^2.0.17",
@@ -96,6 +96,9 @@
     "prepublishOnly": "python build/checkversion.py && python build/all.py --force"
   },
   "dependencies": {
-    "eme-encryption-scheme-polyfill": "^2.0.3"
+    "eme-encryption-scheme-polyfill": "^2.0.5"
+  },
+  "engines": {
+    "node": ">=14"
   }
 }

package/test/hls/hls_live_unit.js

@@ -539,11 +539,13 @@ describe('HlsParser live', () => {
       ManifestParser.verifySegmentIndex(video, [ref1, ref2]);
     });
 
+    // Test for https://github.com/shaka-project/shaka-player/issues/4223
     it('parses streams with partial and preload hinted segments', async () => {
       playerInterface.isLowLatencyMode = () => true;
       const mediaWithPartialSegments = [
         '#EXTM3U\n',
         '#EXT-X-TARGETDURATION:5\n',
+        '#EXT-X-PART-INF:PART-TARGET=1.5\n',
         '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
         '#EXT-X-MEDIA-SEQUENCE:0\n',
         // ref includes partialRef, partialRef2
@@ -576,26 +578,73 @@ describe('HlsParser live', () => {
           'test:/partial2.mp4', 2, 4, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 200, /* endByte= */ 429);
 
+      const ref = makeReference(
+          'test:/main.mp4', 0, 4, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 429,
+          /* timestampOffset= */ 0, [partialRef, partialRef2]);
+
       const partialRef3 = makeReference(
           'test:/partial.mp4', 4, 6, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 209);
 
-      // A preload hinted partial segment doesn't have duration information,
-      // so its startTime and endTime are the same.
       const preloadRef = makeReference(
-          'test:/partial.mp4', 6, 6, /* syncTime= */ null,
+          'test:/partial.mp4', 6, 7.5, /* syncTime= */ null,
           /* baseUri= */ '', /* startByte= */ 210, /* endByte= */ null);
 
+      // ref2 is not fully published yet, so it doesn't have a segment uri.
+      const ref2 = makeReference(
+          '', 4, 7.5, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
+          /* timestampOffset= */ 0, [partialRef3, preloadRef]);
+
+      const manifest = await parser.start('test:/master', playerInterface);
+      const video = manifest.variants[0].video;
+      await video.createSegmentIndex();
+      ManifestParser.verifySegmentIndex(video, [ref, ref2]);
+    });
+
+    // Test for https://github.com/shaka-project/shaka-player/issues/4223
+    it('ignores preload hinted segments without target duration', async () => {
+      playerInterface.isLowLatencyMode = () => true;
+
+      // Missing PART-TARGET, so preload hints are skipped.
+      const mediaWithPartialSegments = [
+        '#EXTM3U\n',
+        '#EXT-X-TARGETDURATION:5\n',
+        '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+        '#EXT-X-MEDIA-SEQUENCE:0\n',
+        '#EXTINF:4,\n',
+        // ref1
+        'main.mp4\n',
+        // ref2 includes partialRef, but not preloadRef
+        // partialRef
+        '#EXT-X-PART:DURATION=2,URI="partial.mp4",BYTERANGE=210@0\n',
+        // preloadRef
+        '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="partial.mp4",BYTERANGE-START=210\n',
+      ].join('');
+
+      fakeNetEngine
+          .setResponseText('test:/master', master)
+          .setResponseText('test:/video', mediaWithPartialSegments)
+          .setResponseValue('test:/init.mp4', initSegmentData)
+          .setResponseValue('test:/main.mp4', segmentData)
+          .setResponseValue('test:/partial.mp4', segmentData)
+          .setResponseValue('test:/partial2.mp4', segmentData);
+
       const ref = makeReference(
           'test:/main.mp4', 0, 4, /* syncTime= */ null,
-          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 429,
-          /* timestampOffset= */ 0, [partialRef, partialRef2]);
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
+          /* timestampOffset= */ 0, []);
+
+      const partialRef = makeReference(
+          'test:/partial.mp4', 4, 6, /* syncTime= */ null,
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 209);
 
       // ref2 is not fully published yet, so it doesn't have a segment uri.
       const ref2 = makeReference(
           '', 4, 6, /* syncTime= */ null,
-          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ null,
-          /* timestampOffset= */ 0, [partialRef3, preloadRef]);
+          /* baseUri= */ '', /* startByte= */ 0, /* endByte= */ 209,
+          /* timestampOffset= */ 0, [partialRef]);
 
       const manifest = await parser.start('test:/master', playerInterface);
       const video = manifest.variants[0].video;
@@ -603,6 +652,29 @@ describe('HlsParser live', () => {
       ManifestParser.verifySegmentIndex(video, [ref, ref2]);
     });
 
+    // Test for https://github.com/shaka-project/shaka-player/issues/4185
+    it('does not fail on preload hints with LL mode off', async () => {
+      // LL mode must be off for this test!
+      playerInterface.isLowLatencyMode = () => false;
+
+      const mediaWithPartialSegments = [
+        '#EXTM3U\n',
+        '#EXT-X-TARGETDURATION:5\n',
+        '#EXT-X-PART-INF:PART-TARGET=1.5\n',
+        '#EXTINF:4,\n',
+        'main.mp4\n',
+        '#EXT-X-PART:DURATION=2,URI="partial.mp4",BYTERANGE=210@0\n',
+        '#EXT-X-PRELOAD-HINT:TYPE=PART,URI="partial.mp4",BYTERANGE-START=210\n',
+      ].join('');
+
+      fakeNetEngine
+          .setResponseText('test:/master', master)
+          .setResponseText('test:/video', mediaWithPartialSegments);
+
+      // If this throws, the test fails.  Otherwise, it passes.
+      await parser.start('test:/master', playerInterface);
+    });
+
     describe('update', () => {
       it('adds new segments when they appear', async () => {
         const ref1 = makeReference(

package/test/hls/hls_parser_unit.js

@@ -2021,6 +2021,10 @@ describe('HlsParser', () => {
   });
 
   describe('produces syncTime', () => {
+    // Corresponds to "2000-01-01T00:00:00.00Z".
+    // All the PROGRAM-DATE-TIME values in the tests below are at or after this.
+    const syncTimeBase = 946684800;
+
     /**
      * @param {number} startTime
      * @param {number} endTime
@@ -2039,9 +2043,10 @@ describe('HlsParser', () => {
     /**
      * @param {string} media
      * @param {!Array.<number>} startTimes
+     * @param {number} syncTimeOffset
      * @param {(function(!shaka.media.SegmentReference))=} modifyFn
      */
-    async function test(media, startTimes, modifyFn) {
+    async function test(media, startTimes, syncTimeOffset, modifyFn) {
       const master = [
         '#EXTM3U\n',
         '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,vtt",',
@@ -2053,7 +2058,8 @@ describe('HlsParser', () => {
       for (let i = 0; i < startTimes.length - 1; i++) {
         const startTime = startTimes[i];
         const endTime = startTimes[i + 1];
-        const reference = makeReference(startTime, endTime, startTime);
+        const reference = makeReference(
+            startTime, endTime, syncTimeOffset + startTime);
         if (modifyFn) {
           modifyFn(reference);
         }
@@ -2100,7 +2106,7 @@ describe('HlsParser', () => {
         '#EXT-X-PROGRAM-DATE-TIME:2000-01-01T00:00:25.00Z\n',
         '#EXTINF:5,\n',
         'main.mp4',
-      ].join(''), [0, 5, 10, 15, 20, 25]);
+      ].join(''), [0, 5, 10, 15, 20, 25], syncTimeBase + 5);
     });
 
     it('when some EXT-X-PROGRAM-DATE-TIME values are missing', async () => {
@@ -2122,7 +2128,7 @@ describe('HlsParser', () => {
         'main.mp4\n',
         '#EXTINF:4,\n',
         'main.mp4',
-      ].join(''), [0, 2, 7, 12, 17, 19, 23]);
+      ].join(''), [0, 2, 7, 12, 17, 19, 23], syncTimeBase + 8);
     });
 
     it('except when ignoreManifestProgramDateTime is set', async () => {
@@ -2148,7 +2154,7 @@ describe('HlsParser', () => {
         '#EXT-X-PROGRAM-DATE-TIME:2000-01-01T00:00:25.00Z\n',
         '#EXTINF:5,\n',
         'main.mp4',
-      ].join(''), [0, 5, 10, 15, 20, 25], (reference) => {
+      ].join(''), [0, 5, 10, 15, 20, 25], syncTimeBase + 5, (reference) => {
         reference.syncTime = null;
       });
     });
@@ -2176,11 +2182,11 @@ describe('HlsParser', () => {
         '#EXT-X-PROGRAM-DATE-TIME:2000-01-01T00:00:25.00Z\n',
         '#EXTINF:5,\n',
         'main.mp4',
-      ].join(''), [0, 5, 10, 15, 20, 25], (reference) => {
+      ].join(''), [0, 5, 10, 15, 20, 25], syncTimeBase + 5, (reference) => {
         if (reference.startTime == 10) {
           reference.partialReferences = [
-            makeReference(10, 12.5, 10),
-            makeReference(12.5, 15, 12.5),
+            makeReference(10, 12.5, syncTimeBase + 15),
+            makeReference(12.5, 15, syncTimeBase + 17.5),
           ];
         }
       });
@@ -3555,4 +3561,92 @@ describe('HlsParser', () => {
 
     await testHlsParser(media, '', manifest);
   });
+
+  it('syncs on sequence with ignoreManifestProgramDateTime', async () => {
+    const config = shaka.util.PlayerConfiguration.createDefault().manifest;
+    config.hls.ignoreManifestProgramDateTime = true;
+    parser.configure(config);
+
+    const master = [
+      '#EXTM3U\n',
+      '#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="aud1",LANGUAGE="eng",URI="audio"\n',
+      '#EXT-X-STREAM-INF:BANDWIDTH=200,CODECS="avc1,mp4a",',
+      'RESOLUTION=960x540,FRAME-RATE=60,AUDIO="aud1"\n',
+      'video\n',
+    ].join('');
+
+    const video = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXT-X-MEDIA-SEQUENCE:1\n',
+      '#EXTINF:5,\n',
+      'video1.mp4\n',
+      '#EXTINF:5,\n',
+      'video2.mp4\n',
+      '#EXTINF:5,\n',
+      'video3.mp4\n',
+    ].join('');
+
+    const audio = [
+      '#EXTM3U\n',
+      '#EXT-X-TARGETDURATION:5\n',
+      '#EXT-X-MAP:URI="init.mp4",BYTERANGE="616@0"\n',
+      '#EXT-X-MEDIA-SEQUENCE:3\n',
+      '#EXTINF:5,\n',
+      'audio3.mp4\n',
+      '#EXTINF:5,\n',
+      'audio4.mp4\n',
+    ].join('');
+
+    const manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+      manifest.sequenceMode = true;
+      manifest.anyTimeline();
+      manifest.addPartialVariant((variant) => {
+        variant.language = 'en';
+        variant.bandwidth = 200;
+        variant.addPartialStream(ContentType.VIDEO, (stream) => {
+          stream.mime('video/mp4', 'avc1');
+          stream.size(960, 540);
+          stream.frameRate = 60;
+        });
+        variant.addPartialStream(ContentType.AUDIO, (stream) => {
+          stream.language = 'en';
+          stream.mime('audio/mp4', 'mp4a');
+        });
+      });
+    });
+
+    fakeNetEngine
+        .setResponseText('test:/master', master)
+        .setResponseText('test:/audio', audio)
+        .setResponseText('test:/video', video)
+        .setResponseValue('test:/init.mp4', initSegmentData);
+
+    const actualManifest = await parser.start('test:/master', playerInterface);
+    expect(actualManifest).toEqual(manifest);
+
+    const actualVideo = actualManifest.variants[0].video;
+    await actualVideo.createSegmentIndex();
+    goog.asserts.assert(actualVideo.segmentIndex != null, 'Null segmentIndex!');
+
+    const actualAudio = actualManifest.variants[0].audio;
+    await actualAudio.createSegmentIndex();
+    goog.asserts.assert(actualAudio.segmentIndex != null, 'Null segmentIndex!');
+
+    // Verify that the references are aligned on sequence number.
+    const videoSegments = Array.from(actualVideo.segmentIndex);
+    const audioSegments = Array.from(actualAudio.segmentIndex);
+
+    // The first two were dropped to align with the audio.
+    expect(videoSegments.map((ref) => ref.getUris()[0])).toEqual([
+      'test:/video3.mp4',
+    ]);
+    // Audio has a 4th segment that video doesn't, but that doesn't get clipped
+    // or used as the base.  Alignment is truly based on media sequence number.
+    expect(audioSegments.map((ref) => ref.getUris()[0])).toEqual([
+      'test:/audio3.mp4',
+      'test:/audio4.mp4',
+    ]);
+  });
 });

package/test/hls/manifest_text_parser_unit.js

@@ -238,6 +238,25 @@ describe('ManifestTextParser', () => {
           '#EXTM3U\n' +
           '#EXT-X-MEDIA:CODECS="avc1.64002a,mp4a.40.2",AUDIO="a1,a2"',
 
+          // manifest URI:
+          'https://test/manifest.m3u8');
+
+      verifyPlaylist(
+          {
+            type: shaka.hls.PlaylistType.MASTER,
+            tags: [
+              new shaka.hls.Tag(/* id= */ 3, 'EXT-X-MEDIA',
+                  [
+                    new shaka.hls.Attribute('CODECS',
+                        'av01.0.08M.08,mp4a.40.2'),
+                  ]),
+            ],
+          },
+
+          // playlist text:
+          '#EXTM3U\n' +
+          '#EXT-X-MEDIA:CODECS="av01.0.08M.08,mp4a.40.2"',
+
           // manifest URI:
           'https://test/manifest.m3u8');
     });

package/test/offline/indexeddb_storage_unit.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-filterDescribe('IndexeddbStorageCell', () => window.indexedDB, () => {
+filterDescribe('IndexeddbStorageCell', offlineSupported, () => {
   const IndexedDBUtils = shaka.test.IndexedDBUtils;
   const OfflineUtils = shaka.test.OfflineUtils;
   const Util = shaka.test.Util;

package/test/offline/storage_compatibility_unit.js

@@ -91,7 +91,7 @@ const compatibilityTestsMetadata = [
   },
 ];
 
-filterDescribe('Storage Compatibility', () => window.indexedDB, () => {
+filterDescribe('Storage Compatibility', offlineSupported, () => {
   for (const metadata of compatibilityTestsMetadata) {
     describe(metadata.name, () => {
       makeTests(metadata);

package/test/player_external.js

@@ -114,7 +114,13 @@ describe('Player', () => {
         const networkingEngine = player.getNetworkingEngine();
         asset.applyFilters(networkingEngine);
 
-        await player.load(asset.manifestUri);
+        // Rather than awaiting the load() method, catch any load() errors and
+        // wait on the 'canplay' event.  This has the advantage that we will
+        // get better logging of the media state on a timeout, since that
+        // capabilitiy is built into the waiter for media element events.
+        player.load(asset.manifestUri).catch(fail);
+        await waiter.timeoutAfter(60).waitForEvent(video, 'canplay');
+
         if (asset.features) {
           const isLive = asset.features.includes(Feature.LIVE);
           expect(player.isLive()).toBe(isLive);

package/test/player_integration.js

@@ -1069,16 +1069,16 @@ describe('Player', () => {
     });
   });  // describe('unloading')
 
-  describe('chapters', () => {
-    it('add external chapters in vtt format', async () => {
+  describe('addChaptersTrack', () => {
+    it('adds external chapters in vtt format', async () => {
       await player.load('test:sintel_no_text_compiled');
       const locationUri = new goog.Uri(location.href);
       const partialUri1 = new goog.Uri('/base/test/test/assets/chapters.vtt');
       const absoluteUri1 = locationUri.resolve(partialUri1);
       await player.addChaptersTrack(absoluteUri1.toString(), 'en');
 
-      await shaka.test.Util.delay(1.5);
-
+      // Data should be available as soon as addChaptersTrack resolves.
+      // See https://github.com/shaka-project/shaka-player/issues/4186
       const chapters = player.getChapters('en');
       expect(chapters.length).toBe(3);
       const chapter1 = chapters[0];
@@ -1098,8 +1098,6 @@ describe('Player', () => {
       const absoluteUri2 = locationUri.resolve(partialUri2);
       await player.addChaptersTrack(absoluteUri2.toString(), 'en');
 
-      await shaka.test.Util.delay(1.5);
-
       const chaptersUpdated = player.getChapters('en');
       expect(chaptersUpdated.length).toBe(6);
       const chapterUpdated1 = chaptersUpdated[0];
@@ -1128,15 +1126,13 @@ describe('Player', () => {
       expect(chapterUpdated6.endTime).toBe(61.349);
     });
 
-    it('add external chapters in srt format', async () => {
+    it('adds external chapters in srt format', async () => {
       await player.load('test:sintel_no_text_compiled');
       const locationUri = new goog.Uri(location.href);
       const partialUri = new goog.Uri('/base/test/test/assets/chapters.srt');
       const absoluteUri = locationUri.resolve(partialUri);
       await player.addChaptersTrack(absoluteUri.toString(), 'es');
 
-      await shaka.test.Util.delay(1.5);
-
       const chapters = player.getChapters('es');
       expect(chapters.length).toBe(3);
       const chapter1 = chapters[0];
@@ -1152,5 +1148,5 @@ describe('Player', () => {
       expect(chapter3.startTime).toBe(30);
       expect(chapter3.endTime).toBe(61.349);
     });
-  });  // describe('chapters')
+  });  // describe('addChaptersTrack')
 });