shaka-player 4.2.3 → 4.3.0

package/test/player_integration.js

@@ -205,88 +205,6 @@ describe('Player', () => {
       }
     });
 
-    it('is called automatically if language prefs match', async () => {
-      // If the text is a match for the user's preferences, and audio differs
-      // from text, we enable text display automatically.
-
-      // NOTE: This is also a regression test for #1696, in which a change
-      // to this feature broke StreamingEngine initialization.
-
-      const preferredTextLanguage = 'fa';  // The same as in the content itself
-      player.configure({preferredTextLanguage: preferredTextLanguage});
-
-      // Now load a version of Sintel with delayed setup of video & audio
-      // streams and wait for completion.
-      await player.load('test:sintel_realistic_compiled');
-      // By this point, a MediaSource error would be thrown in a repro of bug
-      // #1696.
-
-      // Make sure the automatic setting took effect.
-      expect(player.isTextTrackVisible()).toBe(true);
-
-      // Make sure the content we tested with has text tracks, that the config
-      // we used matches the text language, and that the audio language differs.
-      // These will catch any changes to the underlying content that would
-      // invalidate the test setup.
-      expect(player.getTextTracks().length).not.toBe(0);
-      const textTrack = player.getTextTracks()[0];
-      expect(textTrack.language).toBe(preferredTextLanguage);
-
-      const variantTrack = player.getVariantTracks()[0];
-      expect(variantTrack.language).not.toBe(textTrack.language);
-    });
-
-    it('is not called automatically without language pref match', async () => {
-      // If the text preference doesn't match the content, we do not enable text
-      // display automatically.
-
-      const preferredTextLanguage = 'xx';  // Differs from the content itself
-      player.configure({preferredTextLanguage: preferredTextLanguage});
-
-      // Now load the content and wait for completion.
-      await player.load('test:sintel_realistic_compiled');
-
-      // Make sure the automatic setting did not happen.
-      expect(player.isTextTrackVisible()).toBe(false);
-
-      // Make sure the content we tested with has text tracks, that the config
-      // we used does not match the text language, and that the text and audio
-      // languages do not match each other (to keep this distinct from the next
-      // test case).  This will catch any changes to the underlying content that
-      // would invalidate the test setup.
-      expect(player.getTextTracks().length).not.toBe(0);
-      const textTrack = player.getTextTracks()[0];
-      expect(textTrack.language).not.toBe(preferredTextLanguage);
-
-      const variantTrack = player.getVariantTracks()[0];
-      expect(variantTrack.language).not.toBe(textTrack.language);
-    });
-
-    it('is not called automatically with audio and text match', async () => {
-      // If the audio and text tracks use the same language, we do not enable
-      // text display automatically, no matter the text preference.
-
-      const preferredTextLanguage = 'und';  // The same as in the content itself
-      player.configure({preferredTextLanguage: preferredTextLanguage});
-
-      // Now load the content and wait for completion.
-      await player.load('test:sintel_compiled');
-
-      // Make sure the automatic setting did not happen.
-      expect(player.isTextTrackVisible()).toBe(false);
-
-      // Make sure the content we tested with has text tracks, that the
-      // config we used matches the content, and that the text and audio
-      // languages match each other.  This will catch any changes to the
-      // underlying content that would invalidate the test setup.
-      expect(player.getTextTracks().length).not.toBe(0);
-      const textTrack = player.getTextTracks()[0];
-      expect(textTrack.language).toBe(preferredTextLanguage);
-
-      const variantTrack = player.getVariantTracks()[0];
-      expect(variantTrack.language).toBe(textTrack.language);
-    });
-
     // Repro for https://github.com/shaka-project/shaka-player/issues/1879.
     it('appends cues when enabled initially', async () => {
       let cues = [];
@@ -376,6 +294,160 @@ describe('Player', () => {
     });
   });  // describe('setTextTrackVisibility')
 
+  describe('autoShowText', () => {
+    async function textMatchesAudioDoesNot() {
+      const preferredTextLanguage = 'fa';  // The same as in the content
+      player.configure({preferredTextLanguage: preferredTextLanguage});
+
+      // NOTE: This is also a regression test for #1696, in which a change to
+      // this feature broke StreamingEngine initialization.
+
+      // Now load a version of Sintel with delayed setup of video & audio
+      // streams and wait for completion.
+      await player.load('test:sintel_realistic_compiled');
+      // By this point, a MediaSource error would be thrown in a repro of bug
+      // #1696.
+
+      // Make sure the content we tested with has text tracks, that the config
+      // we used matches the text language, and that the audio language differs.
+      // These will catch any changes to the underlying content that would
+      // invalidate the test setup.
+      expect(player.getTextTracks().length).not.toBe(0);
+      const textTrack = player.getTextTracks()[0];
+      expect(textTrack.language).toBe(preferredTextLanguage);
+
+      const variantTrack = player.getVariantTracks()[0];
+      expect(variantTrack.language).not.toBe(textTrack.language);
+    }
+
+    async function textDoesNotMatch() {
+      const preferredTextLanguage = 'xx';  // Differs from the content
+      player.configure({preferredTextLanguage: preferredTextLanguage});
+
+      // Now load the content and wait for completion.
+      await player.load('test:sintel_realistic_compiled');
+
+      // Make sure the content we tested with has text tracks, that the config
+      // we used does not match the text language, and that the text and audio
+      // languages do not match each other (to keep this distinct from the next
+      // test case).  This will catch any changes to the underlying content that
+      // would invalidate the test setup.
+      expect(player.getTextTracks().length).not.toBe(0);
+      const textTrack = player.getTextTracks()[0];
+      expect(textTrack.language).not.toBe(preferredTextLanguage);
+
+      const variantTrack = player.getVariantTracks()[0];
+      expect(variantTrack.language).not.toBe(textTrack.language);
+    }
+
+    async function textAndAudioMatch() {
+      const preferredTextLanguage = 'und';  // The same as in the content
+      player.configure({preferredTextLanguage: preferredTextLanguage});
+
+      // Now load the content and wait for completion.
+      await player.load('test:sintel_compiled');
+
+      // Make sure the content we tested with has text tracks, that the config
+      // we used matches the content, and that the text and audio languages
+      // match each other.  This will catch any changes to the underlying
+      // content that would invalidate the test setup.
+      expect(player.getTextTracks().length).not.toBe(0);
+      const textTrack = player.getTextTracks()[0];
+      expect(textTrack.language).toBe(preferredTextLanguage);
+
+      const variantTrack = player.getVariantTracks()[0];
+      expect(variantTrack.language).toBe(textTrack.language);
+    }
+
+    describe('IF_SUBTITLES_MAY_BE_NEEDED', () => {
+      beforeEach(() => {
+        player.configure(
+            'autoShowText',
+            shaka.config.AutoShowText.IF_SUBTITLES_MAY_BE_NEEDED);
+      });
+
+      it('enables text if text matches and audio does not', async () => {
+        await textMatchesAudioDoesNot();
+        expect(player.isTextTrackVisible()).toBe(true);
+      });
+
+      it('disables text if text does not match', async () => {
+        await textDoesNotMatch();
+        expect(player.isTextTrackVisible()).toBe(false);
+      });
+
+      it('disables text if both text and audio match', async () => {
+        await textAndAudioMatch();
+        expect(player.isTextTrackVisible()).toBe(false);
+      });
+    });  // IF_SUBTITLES_MAY_BE_NEEDED
+
+    describe('IF_PREFERRED_TEXT_LANGUAGE', () => {
+      beforeEach(() => {
+        player.configure(
+            'autoShowText',
+            shaka.config.AutoShowText.IF_PREFERRED_TEXT_LANGUAGE);
+      });
+
+      it('enables text if text matches and audio does not', async () => {
+        await textMatchesAudioDoesNot();
+        expect(player.isTextTrackVisible()).toBe(true);
+      });
+
+      it('disables text if text does not match', async () => {
+        await textDoesNotMatch();
+        expect(player.isTextTrackVisible()).toBe(false);
+      });
+
+      it('enables text if both text and audio match', async () => {
+        await textAndAudioMatch();
+        expect(player.isTextTrackVisible()).toBe(true);
+      });
+    });  // IF_PREFERRED_TEXT_LANGUAGE
+
+    describe('ALWAYS', () => {
+      beforeEach(() => {
+        player.configure('autoShowText', shaka.config.AutoShowText.ALWAYS);
+      });
+
+      it('enables text if text matches and audio does not', async () => {
+        await textMatchesAudioDoesNot();
+        expect(player.isTextTrackVisible()).toBe(true);
+      });
+
+      it('enables text if text does not match', async () => {
+        await textDoesNotMatch();
+        expect(player.isTextTrackVisible()).toBe(true);
+      });
+
+      it('enables text if both text and audio match', async () => {
+        await textAndAudioMatch();
+        expect(player.isTextTrackVisible()).toBe(true);
+      });
+    });  // ALWAYS
+
+    describe('NEVER', () => {
+      beforeEach(() => {
+        player.configure('autoShowText', shaka.config.AutoShowText.NEVER);
+      });
+
+      it('disables text if text matches and audio does not', async () => {
+        await textMatchesAudioDoesNot();
+        expect(player.isTextTrackVisible()).toBe(false);
+      });
+
+      it('disables text if text does not match', async () => {
+        await textDoesNotMatch();
+        expect(player.isTextTrackVisible()).toBe(false);
+      });
+
+      it('disables text if both text and audio match', async () => {
+        await textAndAudioMatch();
+        expect(player.isTextTrackVisible()).toBe(false);
+      });
+    });  // NEVER
+  });  // AutoShowText
+
   describe('plays', () => {
     it('with external text tracks', async () => {
       await player.load('test:sintel_no_text_compiled');
@@ -1152,4 +1224,74 @@ describe('Player', () => {
       expect(chapter3.endTime).toBe(61.349);
     });
   });  // describe('addChaptersTrack')
+
+  it('requires a license server for HLS ClearKey content', async () => {
+    const expectedError = Util.jasmineError(new shaka.util.Error(
+        shaka.util.Error.Severity.CRITICAL,
+        shaka.util.Error.Category.DRM,
+        shaka.util.Error.Code.NO_LICENSE_SERVER_GIVEN,
+        'org.w3.clearkey'));
+    await expectAsync(player.load('test:sintel-hls-clearkey'))
+        .toBeRejectedWith(expectedError);
+  });
+
+  describe('addThumbnailsTrack', () => {
+    it('appends thumbnails for external thumbnails with sprites',
+        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/thumbnails-sprites.vtt');
+          const absoluteUri = locationUri.resolve(partialUri);
+          const newTrack =
+              await player.addThumbnailsTrack(absoluteUri.toString());
+
+          expect(player.getImageTracks()).toEqual([newTrack]);
+
+          const thumbnail1 = await player.getThumbnails(newTrack.id, 0);
+          expect(thumbnail1.startTime).toBe(0);
+          expect(thumbnail1.duration).toBe(5);
+          expect(thumbnail1.height).toBe(90);
+          expect(thumbnail1.positionX).toBe(0);
+          expect(thumbnail1.positionY).toBe(0);
+          expect(thumbnail1.width).toBe(160);
+          const thumbnail2 = await player.getThumbnails(newTrack.id, 10);
+          expect(thumbnail2.startTime).toBe(5);
+          expect(thumbnail2.duration).toBe(25);
+          expect(thumbnail2.height).toBe(90);
+          expect(thumbnail2.positionX).toBe(160);
+          expect(thumbnail2.positionY).toBe(0);
+          expect(thumbnail2.width).toBe(160);
+          const thumbnail3 = await player.getThumbnails(newTrack.id, 40);
+          expect(thumbnail3.startTime).toBe(30);
+          expect(thumbnail3.duration).toBe(30);
+          expect(thumbnail3.height).toBe(90);
+          expect(thumbnail3.positionX).toBe(160);
+          expect(thumbnail3.positionY).toBe(90);
+          expect(thumbnail3.width).toBe(160);
+        });
+
+    it('appends thumbnails for external thumbnails without sprites',
+        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/thumbnails.vtt');
+          const absoluteUri = locationUri.resolve(partialUri);
+          const newTrack =
+              await player.addThumbnailsTrack(absoluteUri.toString());
+
+          expect(player.getImageTracks()).toEqual([newTrack]);
+
+          const thumbnail1 = await player.getThumbnails(newTrack.id, 0);
+          expect(thumbnail1.startTime).toBe(0);
+          expect(thumbnail1.duration).toBe(5);
+          const thumbnail2 = await player.getThumbnails(newTrack.id, 10);
+          expect(thumbnail2.startTime).toBe(5);
+          expect(thumbnail2.duration).toBe(25);
+          const thumbnail3 = await player.getThumbnails(newTrack.id, 40);
+          expect(thumbnail3.startTime).toBe(30);
+          expect(thumbnail3.duration).toBe(30);
+        });
+  });  // describe('addThumbnailsTrack')
 });

package/test/player_unit.js

@@ -123,6 +123,7 @@ describe('Player', () => {
       streamingEngine = new shaka.test.FakeStreamingEngine();
       mediaSourceEngine = {
         init: jasmine.createSpy('init').and.returnValue(Promise.resolve()),
+        configure: jasmine.createSpy('configure'),
         open: jasmine.createSpy('open').and.returnValue(Promise.resolve()),
         destroy:
             jasmine.createSpy('destroy').and.returnValue(Promise.resolve()),
@@ -130,6 +131,8 @@ describe('Player', () => {
         getUseEmbeddedText: jasmine.createSpy('getUseEmbeddedText'),
         setSegmentRelativeVttTiming:
             jasmine.createSpy('setSegmentRelativeVttTiming'),
+        updateLcevcDil:
+            jasmine.createSpy('updateLcevcDil'),
         getTextDisplayer: () => textDisplayer,
         getBufferedInfo: () => bufferedInfo,
         ended: jasmine.createSpy('ended').and.returnValue(false),
@@ -626,13 +629,13 @@ describe('Player', () => {
       // Try a bogus streaming config (number instead of Object)
       logErrorSpy.calls.reset();
       player.configure({
-        streaming: 5,
+        drm: 5,
       });
 
       newConfig = player.getConfiguration();
       expect(newConfig).toEqual(defaultConfig);
       expect(logErrorSpy).toHaveBeenCalledWith(
-          stringContaining('.streaming'));
+          stringContaining('.drm'));
     });
 
     it('accepts synchronous function values for async function fields', () => {
@@ -3940,6 +3943,93 @@ describe('Player', () => {
     });
   });
 
+  describe('config streaming.failureCallback default', () => {
+    /** @type {jasmine.Spy} */
+    let retryStreaming;
+    /** @type {jasmine.Spy} */
+    let isLive;
+
+    /**
+     * @suppress {accessControls}
+     * @param {!shaka.util.Error} error
+     */
+    function defaultStreamingFailureCallback(error) {
+      player.defaultStreamingFailureCallback_(error);
+    }
+
+    beforeEach(() => {
+      retryStreaming = jasmine.createSpy('retryStreaming');
+      isLive = jasmine.createSpy('isLive');
+
+      player.retryStreaming = Util.spyFunc(retryStreaming);
+      player.isLive = Util.spyFunc(isLive);
+    });
+
+    it('ignores VOD failures', () => {
+      isLive.and.returnValue(false);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.BAD_HTTP_STATUS,
+          /* url= */ '',
+          /* http_status= */ 404);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).not.toHaveBeenCalled();
+    });
+
+    it('retries live on HTTP 404', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.BAD_HTTP_STATUS,
+          /* url= */ '',
+          /* http_status= */ 404);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).toHaveBeenCalled();
+    });
+
+    it('retries live on generic HTTP error', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.HTTP_ERROR);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).toHaveBeenCalled();
+    });
+
+    it('retries live on HTTP timeout', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.NETWORK,
+          shaka.util.Error.Code.TIMEOUT);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).toHaveBeenCalled();
+    });
+
+    it('ignores other live failures', () => {
+      isLive.and.returnValue(true);
+
+      const error = new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MEDIA,
+          shaka.util.Error.Code.VIDEO_ERROR);
+
+      defaultStreamingFailureCallback(error);
+      expect(retryStreaming).not.toHaveBeenCalled();
+    });
+  });
+
   /**
    * Gets the currently active variant track.
    * @return {shaka.extern.Track}

package/test/polyfill/patchedmediakeys_apple_unit.js

@@ -0,0 +1,124 @@
+describe('PatchedMediaKeys_Apple', () => {
+  const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
+  let originalMediaKeys;
+  let originalHTMLMediaElementPrototypeSetMediaKeys;
+  let originalWindowMediaKeys;
+  let originalWindowMediaKeySystemAccess;
+  let originalNavigatorRequestMediaKeySystemAccess;
+  let originalHTMLSVideoElement;
+  let originalWebKitMediaKeys;
+
+  beforeEach(() => {
+    originalHTMLSVideoElement = window.HTMLVideoElement;
+    originalWebKitMediaKeys = window.WebKitMediaKeys;
+
+    Object.defineProperty(window,
+        'HTMLVideoElement', {value: {}, configurable: true, writable: true});
+    Object.defineProperty(window,
+        'WebKitMediaKeys', {value: {}, configurable: true, writable: true});
+
+    originalMediaKeys = /** @type {!Object} */ (
+      Object.getOwnPropertyDescriptor(
+          // eslint-disable-next-line no-restricted-syntax
+          HTMLMediaElement.prototype, 'mediaKeys',
+      )
+    );
+
+    // eslint-disable-next-line no-restricted-syntax
+    originalHTMLMediaElementPrototypeSetMediaKeys = HTMLMediaElement
+        .prototype.setMediaKeys;
+    originalWindowMediaKeys = window.MediaKeys;
+    originalWindowMediaKeySystemAccess = window.MediaKeySystemAccess;
+    originalNavigatorRequestMediaKeySystemAccess = navigator
+        .requestMediaKeySystemAccess;
+
+    delete window.shakaMediaKeysPolyfill;
+  });
+
+  afterEach(() => {
+    window.HTMLVideoElement = originalHTMLSVideoElement;
+    window.WebKitMediaKeys = originalWebKitMediaKeys;
+
+    Object.defineProperty(
+        // eslint-disable-next-line no-restricted-syntax
+        HTMLMediaElement.prototype,
+        'mediaKeys',
+        originalMediaKeys,
+    );
+
+    // eslint-disable-next-line no-restricted-syntax
+    HTMLMediaElement
+        .prototype.setMediaKeys =
+        originalHTMLMediaElementPrototypeSetMediaKeys;
+    window.MediaKeys = originalWindowMediaKeys;
+    window.MediaKeySystemAccess = originalWindowMediaKeySystemAccess;
+    navigator
+        .requestMediaKeySystemAccess =
+      originalNavigatorRequestMediaKeySystemAccess;
+
+    delete window.shakaMediaKeysPolyfill;
+  });
+
+  describe('install', () => {
+    it('should override browser globals', () => {
+      shaka.polyfill.PatchedMediaKeysApple.install();
+
+      expect(shaka.polyfill.PatchedMediaKeysApple.enableUninstall)
+          .toBe(undefined);
+
+      expect(
+          originalHTMLMediaElementPrototypeSetMediaKeys,
+      ).not.toEqual(
+          // eslint-disable-next-line no-restricted-syntax
+          HTMLMediaElement.prototype.setMediaKeys,
+      );
+
+      expect(
+          Object.getOwnPropertyDescriptor(
+          // eslint-disable-next-line no-restricted-syntax
+              HTMLMediaElement.prototype, 'mediaKeys',
+          ).value,
+      ).toBeNull();
+
+      // eslint-disable-next-line no-restricted-syntax
+      expect(HTMLMediaElement.prototype.setMediaKeys)
+          .toEqual(PatchedMediaKeysApple.setMediaKeys);
+
+      expect(window.MediaKeys).toEqual(PatchedMediaKeysApple.MediaKeys);
+      expect(window.MediaKeySystemAccess)
+          .toEqual(PatchedMediaKeysApple.MediaKeySystemAccess);
+      expect(navigator.requestMediaKeySystemAccess)
+          .toEqual(PatchedMediaKeysApple.requestMediaKeySystemAccess);
+      expect(window.shakaMediaKeysPolyfill).toBe(true);
+    });
+  });
+
+  describe('uninstall', () => {
+    it('should restore browser globals', () => {
+      shaka.polyfill.PatchedMediaKeysApple.install(true);
+
+      expect(shaka.polyfill.PatchedMediaKeysApple.enableUninstall)
+          .toBe(true);
+
+      shaka.polyfill.PatchedMediaKeysApple.uninstall();
+
+      expect(
+          Object.getOwnPropertyDescriptor(
+          // eslint-disable-next-line no-restricted-syntax
+              HTMLMediaElement.prototype, 'mediaKeys',
+          ).value,
+      ).not.toBeNull();
+
+      // eslint-disable-next-line no-restricted-syntax
+      expect(HTMLMediaElement.prototype.setMediaKeys)
+          .toEqual(originalHTMLMediaElementPrototypeSetMediaKeys);
+
+      expect(window.MediaKeys).toEqual(originalWindowMediaKeys);
+      expect(window.MediaKeySystemAccess)
+          .toEqual(originalWindowMediaKeySystemAccess);
+      expect(navigator.requestMediaKeySystemAccess)
+          .toEqual(originalNavigatorRequestMediaKeySystemAccess);
+      expect(window.shakaMediaKeysPolyfill).toBe(false);
+    });
+  });
+});

package/test/test/assets/thumbnails-sprites.vtt

@@ -0,0 +1,10 @@
+WEBVTT
+
+00:00.000 --> 00:05.000
+image1.jpg#xywh=0,0,160,90
+
+00:05.000 --> 00:30.000
+image2.jpg#xywh=160,0,160,90
+
+00:30.000 --> 01:00.000
+image3.jpg#xywh=160,90,160,90

package/test/test/assets/thumbnails.vtt

@@ -0,0 +1,10 @@
+WEBVTT
+
+00:00.000 --> 00:05.000
+image1.jpg
+
+00:05.000 --> 00:30.000
+image2.jpg
+
+00:30.000 --> 01:00.000
+image3.jpg

package/test/test/util/dash_parser_util.js

@@ -44,6 +44,7 @@ shaka.test.Dash = class {
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
+      newDrmInfo: (stream) => {},
     };
     const manifest = await dashParser.start('dummy://foo', playerInterface);
     const stream = manifest.variants[0].video;
@@ -79,6 +80,7 @@ shaka.test.Dash = class {
       isAutoLowLatencyMode: () => false,
       enableLowLatencyMode: () => {},
       updateDuration: () => {},
+      newDrmInfo: (stream) => {},
     };
     const p = dashParser.start('dummy://foo', playerInterface);
     await expectAsync(p).toBeRejectedWith(

package/test/test/util/fake_ad.js

@@ -34,6 +34,12 @@ shaka.test.FakeAd = class {
 
     /** @private {number} */
     this.volume_ = 1;
+
+    /** @private {string} */
+    this.title_ = 'Test Title';
+
+    /** @private {string} */
+    this.description_ = 'Test Description';
   }
 
   /**
@@ -190,6 +196,21 @@ shaka.test.FakeAd = class {
     return this.position_;
   }
 
+  /**
+   * @override
+   * @export
+   */
+  getTitle() {
+    return this.title_;
+  }
+
+  /**
+   * @override
+   * @export
+   */
+  getDescription() {
+    return this.description_;
+  }
 
   /**
    * @override

package/test/test/util/fake_media_source_engine.js

@@ -54,6 +54,9 @@ shaka.test.FakeMediaSourceEngine = class {
     /** @type {!jasmine.Spy} */
     this.open = jasmine.createSpy('open').and.returnValue(Promise.resolve());
 
+    /** @type {!jasmine.Spy} */
+    this.configure = jasmine.createSpy('configure').and.stub();
+
     /** @type {!jasmine.Spy} */
     this.reinitText = jasmine.createSpy('reinitText').and.stub();
 
@@ -129,6 +132,10 @@ shaka.test.FakeMediaSourceEngine = class {
     /** @type {!jasmine.Spy} */
     this.setSegmentRelativeVttTiming =
         jasmine.createSpy('setSegmentRelativeVttTiming').and.stub();
+
+    /** @type {!jasmine.Spy} */
+    this.updateLcevcDil =
+        jasmine.createSpy('updateLcevcDil').and.stub();
   }
 
   /** @override */