shaka-player 3.3.4 → 3.3.5

package/lib/util/player_configuration.js

@@ -17,14 +17,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
@@ -109,11 +101,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: {
@@ -132,7 +123,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.
@@ -210,7 +203,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;

package/package.json

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

package/test/cast/cast_utils_unit.js

@@ -189,6 +189,7 @@ describe('CastUtils', () => {
         const fakeVideoStream = {
           mimeType: 'video/mp4',
           codecs: 'avc1.42c01e',
+          drmInfos: [],
         };
         const initSegmentUrl = '/base/test/test/assets/sintel-video-init.mp4';
         const videoSegmentUrl =

package/test/dash/dash_parser_manifest_unit.js

@@ -447,30 +447,6 @@ describe('DashParser Manifest', () => {
         expect(stream.closedCaptions).toEqual(expectedClosedCaptions);
       });
 
-  it('Detects E-AC3 JOC content by SupplementalProperty', async () => {
-    const idUri = 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018';
-    const source = [
-      '<MPD>',
-      '  <Period duration="PT30M">',
-      '    <AdaptationSet mimeType="audio/mp4" lang="\u2603">',
-      '      <Representation bandwidth="500">',
-      '        <SupplementalProperty schemeIdUri="' + idUri + '" value="JOC"/>',
-      '        <BaseURL>http://example.com</BaseURL>',
-      '        <SegmentTemplate media="2.mp4" duration="1" />',
-      '      </Representation>',
-      '    </AdaptationSet>',
-      '  </Period>',
-      '</MPD>',
-    ].join('\n');
-
-    fakeNetEngine.setResponseText('dummy://foo', source);
-
-    /** @type {shaka.extern.Manifest} */
-    const manifest = await parser.start('dummy://foo', playerInterface);
-    const stream = manifest.variants[0].audio;
-    expect(stream.mimeType).toBe('audio/eac3-joc');
-  });
-
   it('Detects spatial audio', async () => {
     const idUri = 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018';
     const source = [

package/test/hls/hls_live_unit.js

@@ -699,6 +699,32 @@ 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-MAP:URI="init.mp4",BYTERANGE="616@0"\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)
+          .setResponseValue('test:/init.mp4', initSegmentData)
+          .setResponseValue('test:/main.mp4', segmentData)
+          .setResponseValue('test:/partial.mp4', segmentData);
+
+      // 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 = ManifestParser.makeReference('test:/main.mp4', 2, 4);

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/media/media_source_engine_integration.js

@@ -103,6 +103,7 @@ describe('MediaSourceEngine', () => {
     return {
       mimeType: streamMetadata.mimeType,
       codecs: streamMetadata.codecs,
+      drmInfos: [],
     };
   }
 

package/test/media/media_source_engine_unit.js

@@ -49,10 +49,10 @@ describe('MediaSourceEngine', () => {
   const buffer2 = /** @type {!ArrayBuffer} */ (/** @type {?} */ (2));
   const buffer3 = /** @type {!ArrayBuffer} */ (/** @type {?} */ (3));
 
-  const fakeVideoStream = {mimeType: 'video/foo'};
-  const fakeAudioStream = {mimeType: 'audio/foo'};
-  const fakeTextStream = {mimeType: 'text/foo'};
-  const fakeTransportStream = {mimeType: 'tsMimetype'};
+  const fakeVideoStream = {mimeType: 'video/foo', drmInfos: []};
+  const fakeAudioStream = {mimeType: 'audio/foo', drmInfos: []};
+  const fakeTextStream = {mimeType: 'text/foo', drmInfos: []};
+  const fakeTransportStream = {mimeType: 'tsMimetype', drmInfos: []};
 
   let audioSourceBuffer;
   let videoSourceBuffer;

package/test/media/streaming_engine_integration.js

@@ -622,6 +622,7 @@ describe('StreamingEngine', () => {
             width: 600,
             height: 400,
             type: shaka.util.ManifestParserUtils.ContentType.VIDEO,
+            drmInfos: [],
           },
           audio: {
             id: 3,
@@ -631,6 +632,7 @@ describe('StreamingEngine', () => {
             codecs: 'mp4a.40.2',
             bandwidth: 192000,
             type: shaka.util.ManifestParserUtils.ContentType.AUDIO,
+            drmInfos: [],
           },
         }],
       };

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

@@ -120,7 +120,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

@@ -1053,16 +1053,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];
@@ -1082,8 +1082,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];
@@ -1112,15 +1110,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];
@@ -1136,5 +1132,5 @@ describe('Player', () => {
       expect(chapter3.startTime).toBe(30);
       expect(chapter3.endTime).toBe(61.349);
     });
-  });  // describe('chapters')
+  });  // describe('addChaptersTrack')
 });

package/test/player_src_equals_integration.js

@@ -319,90 +319,88 @@ describe('Player Src Equals', () => {
     expect(newTrack).toBeTruthy();
   });
 
-  it('add external chapters in vtt format', async () => {
-    await loadWithSrcEquals(SMALL_MP4_CONTENT_URI, /* startTime= */ null);
-
-    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);
-
-    const chapters = player.getChapters('en');
-    expect(chapters.length).toBe(3);
-    const chapter1 = chapters[0];
-    expect(chapter1.title).toBe('Chapter 1');
-    expect(chapter1.startTime).toBe(0);
-    expect(chapter1.endTime).toBe(5);
-    const chapter2 = chapters[1];
-    expect(chapter2.title).toBe('Chapter 2');
-    expect(chapter2.startTime).toBe(5);
-    expect(chapter2.endTime).toBe(10);
-    const chapter3 = chapters[2];
-    expect(chapter3.title).toBe('Chapter 3');
-    expect(chapter3.startTime).toBe(10);
-    expect(chapter3.endTime).toBe(20);
-
-    const partialUri2 = new goog.Uri('/base/test/test/assets/chapters2.vtt');
-    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];
-    expect(chapterUpdated1.title).toBe('Chapter 1');
-    expect(chapterUpdated1.startTime).toBe(0);
-    expect(chapterUpdated1.endTime).toBe(5);
-    const chapterUpdated2 = chaptersUpdated[1];
-    expect(chapterUpdated2.title).toBe('Chapter 2');
-    expect(chapterUpdated2.startTime).toBe(5);
-    expect(chapterUpdated2.endTime).toBe(10);
-    const chapterUpdated3 = chaptersUpdated[2];
-    expect(chapterUpdated3.title).toBe('Chapter 3');
-    expect(chapterUpdated3.startTime).toBe(10);
-    expect(chapterUpdated3.endTime).toBe(20);
-    const chapterUpdated4 = chaptersUpdated[3];
-    expect(chapterUpdated4.title).toBe('Chapter 4');
-    expect(chapterUpdated4.startTime).toBe(20);
-    expect(chapterUpdated4.endTime).toBe(30);
-    const chapterUpdated5 = chaptersUpdated[4];
-    expect(chapterUpdated5.title).toBe('Chapter 5');
-    expect(chapterUpdated5.startTime).toBe(30);
-    expect(chapterUpdated5.endTime).toBe(40);
-    const chapterUpdated6 = chaptersUpdated[5];
-    expect(chapterUpdated6.title).toBe('Chapter 6');
-    expect(chapterUpdated6.startTime).toBe(40);
-    expect(chapterUpdated6.endTime).toBe(61.349);
-  });
-
-  it('add external chapters in srt format', async () => {
-    await loadWithSrcEquals(SMALL_MP4_CONTENT_URI, /* startTime= */ null);
-
-    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);
+  describe('addChaptersTrack', () => {
+    it('adds external chapters in vtt format', async () => {
+      await loadWithSrcEquals(SMALL_MP4_CONTENT_URI, /* startTime= */ null);
+
+      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');
+
+      // 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];
+      expect(chapter1.title).toBe('Chapter 1');
+      expect(chapter1.startTime).toBe(0);
+      expect(chapter1.endTime).toBe(5);
+      const chapter2 = chapters[1];
+      expect(chapter2.title).toBe('Chapter 2');
+      expect(chapter2.startTime).toBe(5);
+      expect(chapter2.endTime).toBe(10);
+      const chapter3 = chapters[2];
+      expect(chapter3.title).toBe('Chapter 3');
+      expect(chapter3.startTime).toBe(10);
+      expect(chapter3.endTime).toBe(20);
+
+      const partialUri2 = new goog.Uri('/base/test/test/assets/chapters2.vtt');
+      const absoluteUri2 = locationUri.resolve(partialUri2);
+      await player.addChaptersTrack(absoluteUri2.toString(), 'en');
+
+      const chaptersUpdated = player.getChapters('en');
+      expect(chaptersUpdated.length).toBe(6);
+      const chapterUpdated1 = chaptersUpdated[0];
+      expect(chapterUpdated1.title).toBe('Chapter 1');
+      expect(chapterUpdated1.startTime).toBe(0);
+      expect(chapterUpdated1.endTime).toBe(5);
+      const chapterUpdated2 = chaptersUpdated[1];
+      expect(chapterUpdated2.title).toBe('Chapter 2');
+      expect(chapterUpdated2.startTime).toBe(5);
+      expect(chapterUpdated2.endTime).toBe(10);
+      const chapterUpdated3 = chaptersUpdated[2];
+      expect(chapterUpdated3.title).toBe('Chapter 3');
+      expect(chapterUpdated3.startTime).toBe(10);
+      expect(chapterUpdated3.endTime).toBe(20);
+      const chapterUpdated4 = chaptersUpdated[3];
+      expect(chapterUpdated4.title).toBe('Chapter 4');
+      expect(chapterUpdated4.startTime).toBe(20);
+      expect(chapterUpdated4.endTime).toBe(30);
+      const chapterUpdated5 = chaptersUpdated[4];
+      expect(chapterUpdated5.title).toBe('Chapter 5');
+      expect(chapterUpdated5.startTime).toBe(30);
+      expect(chapterUpdated5.endTime).toBe(40);
+      const chapterUpdated6 = chaptersUpdated[5];
+      expect(chapterUpdated6.title).toBe('Chapter 6');
+      expect(chapterUpdated6.startTime).toBe(40);
+      expect(chapterUpdated6.endTime).toBe(61.349);
+    });
 
-    const chapters = player.getChapters('es');
-    expect(chapters.length).toBe(3);
-    const chapter1 = chapters[0];
-    expect(chapter1.title).toBe('Chapter 1');
-    expect(chapter1.startTime).toBe(0);
-    expect(chapter1.endTime).toBe(5);
-    const chapter2 = chapters[1];
-    expect(chapter2.title).toBe('Chapter 2');
-    expect(chapter2.startTime).toBe(5);
-    expect(chapter2.endTime).toBe(30);
-    const chapter3 = chapters[2];
-    expect(chapter3.title).toBe('Chapter 3');
-    expect(chapter3.startTime).toBe(30);
-    expect(chapter3.endTime).toBe(61.349);
-  });
+    it('add external chapters in srt format', async () => {
+      await loadWithSrcEquals(SMALL_MP4_CONTENT_URI, /* startTime= */ null);
+
+      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');
+
+      const chapters = player.getChapters('es');
+      expect(chapters.length).toBe(3);
+      const chapter1 = chapters[0];
+      expect(chapter1.title).toBe('Chapter 1');
+      expect(chapter1.startTime).toBe(0);
+      expect(chapter1.endTime).toBe(5);
+      const chapter2 = chapters[1];
+      expect(chapter2.title).toBe('Chapter 2');
+      expect(chapter2.startTime).toBe(5);
+      expect(chapter2.endTime).toBe(30);
+      const chapter3 = chapters[2];
+      expect(chapter3.title).toBe('Chapter 3');
+      expect(chapter3.startTime).toBe(30);
+      expect(chapter3.endTime).toBe(61.349);
+    });
+  }); // describe('addChaptersTrack')
 
   // Since we are not in-charge of streaming, calling |retryStreaming| should
   // have no effect.

package/test/player_unit.js

@@ -122,7 +122,13 @@ describe('Player', () => {
 
       player.createDrmEngine = () => drmEngine;
       player.createNetworkingEngine = () => networkingEngine;
-      player.createPlayhead = () => playhead;
+      player.createPlayhead = (startTime) => {
+        const callableSetStartTime =
+            shaka.test.Util.spyFunc(playhead.setStartTime);
+        callableSetStartTime(startTime);
+        playhead.setStartTime.calls.reset();
+        return playhead;
+      };
       player.createMediaSourceEngine = () => mediaSourceEngine;
       player.createStreamingEngine = () => streamingEngine;
     }
@@ -154,6 +160,7 @@ describe('Player', () => {
       window.MediaSource.isTypeSupported = originalIsTypeSupported;
       shaka.media.ManifestParser.unregisterParserByMime(fakeMimeType);
       navigator.mediaCapabilities.decodingInfo = originalDecodingInfo;
+      onError.calls.reset();
     }
   });
 
@@ -2632,6 +2639,51 @@ describe('Player', () => {
       expect(activeVariant.id).toBe(1);
     });
 
+    // Regression test for https://github.com/shaka-project/shaka-player/issues/4190
+    it('throws only one RESTRICTIONS_CANNOT_BE_MET error', async () => {
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(0, (variant) => {
+          variant.addVideo(1, (stream) => {
+            stream.keyIds = new Set(['abc']);
+          });
+        });
+      });
+
+      // Check that error is RESTRICTIONS_CANNOT_BE_MET
+      onError.and.callFake((e) => {
+        const error = e.detail;
+        shaka.test.Util.expectToEqualError(
+            error,
+            new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.MANIFEST,
+                shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET, {
+                  hasAppRestrictions: false,
+                  missingKeys: ['abc'],
+                  restrictedKeyStatuses: [],
+                }));
+      });
+
+      await player.load(fakeManifestUri, 0, fakeMimeType);
+      const activeVariant = getActiveVariantTrack();
+      expect(activeVariant.id).toBe(0);
+
+      abrManager.chooseIndex = 0;
+      abrManager.chooseVariant.calls.reset();
+
+      onKeyStatus({'abc': 'output-restricted'});
+
+      // Ensure that RESTRICTIONS_CANNOT_BE_MET is thrown once
+      expect(onError).toHaveBeenCalledTimes(1);
+
+      // It does not call chooseVariant
+      expect(abrManager.chooseVariant).not.toHaveBeenCalled();
+
+      // The first variant is disallowed.
+      expect(manifest.variants[0].id).toBe(0);
+      expect(manifest.variants[0].allowedByKeySystem).toBe(false);
+    });
+
     it('doesn\'t switch if the active stream isn\'t restricted', async () => {
       manifest = shaka.test.ManifestGenerator.generate((manifest) => {
         manifest.addVariant(0, (variant) => {
@@ -3638,6 +3690,51 @@ describe('Player', () => {
     });
   });
 
+  describe('config streaming.startAtSegmentBoundary', () => {
+    // Test for https://github.com/shaka-project/shaka-player/issues/4188
+    // In that issue, using streaming.startAtSegmentBoundary in v4.0.0 caused
+    // an exception due to the use of a removed method.
+    it('adjusts start time', async () => {
+      player.configure('streaming.startAtSegmentBoundary', true);
+
+      // In order to adjust the start time to a segment boundary, we need
+      // segment descriptions in the segment index.  So create a non-default
+      // fake manifest.
+      const timeline = new shaka.media.PresentationTimeline(300, 0);
+      timeline.setStatic(true);
+      // This duration is used by useSegmentTemplate below to decide how many
+      // references to generate.
+      timeline.setDuration(300);
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.presentationTimeline = timeline;
+        manifest.addVariant(0, (variant) => {
+          variant.addVideo(1, (stream) => {
+            stream.useSegmentTemplate(
+                '$Number$.mp4', /* segmentDuration= */ 10);
+          });
+        });
+      });
+
+      await player.load(fakeManifestUri, 12, fakeMimeType);
+
+      expect(playhead.setStartTime).toHaveBeenCalledWith(10);
+    });
+
+    it('does not fail with no segments', async () => {
+      player.configure('streaming.startAtSegmentBoundary', true);
+
+      // Without useSegmentTemplate in the fake manifest, the call to
+      // getIteratorForTime() in Player produces a null iterator.  Using the
+      // default fake manifest should cover that case.  But just to make sure,
+      // verify that we have no segments before calling load().
+      const variant = manifest.variants[0];
+      expect(variant.video.segmentIndex.getIteratorForTime(0)).toBeNull();
+      expect(variant.audio.segmentIndex.getIteratorForTime(0)).toBeNull();
+
+      await player.load(fakeManifestUri, 0, fakeMimeType);
+    });
+  });
+
   /**
    * Gets the currently active variant track.
    * @return {shaka.extern.Track}

package/test/test/boot.js

@@ -242,6 +242,15 @@ window.xfilterDescribe = (describeName, cond, describeBody) => {
   window['describe'] = oldDescribe;
 };
 
+/**
+ * A very short alias for filtering offline integration tests.
+ *
+ * @return {boolean}
+ */
+window.offlineSupported = () => {
+  return shaka.offline.StorageMuxer.support();
+};
+
 /**
  * Load node modules used in testing and install them into window.
  * @return {!Promise}

package/test/test/externs/filters.js

@@ -38,3 +38,7 @@ var filterDescribe = function(name, cond, callback) {};
  * @param {function()} callback
  */
 var xfilterDescribe = function(name, cond, callback) {};
+
+
+/** @return {boolean} */
+var offlineSupported = function() {};