shaka-player 3.2.13 → 3.2.15

package/test/offline/storage_integration.js

@@ -990,6 +990,36 @@ filterDescribe('Storage', storageSupport, () => {
       }
     });
 
+    /**
+     * In some situations, indexedDB.open() can just hang, and call neither the
+     * 'success' nor the 'error' callbacks.
+     * I'm not sure what causes it, but it seems to happen consistently between
+     * reloads when it does so it might be a browser-based issue.
+     * In that case, we should time out with an error, instead of also hanging.
+     */
+    it('throws an error if indexedDB open times out', async () => {
+      const oldOpen = window.indexedDB.open;
+      window.indexedDB.open = () => {
+        // Just return a dummy object.
+        return /** @type {!IDBOpenDBRequest} */ ({
+          onsuccess: (event) => {},
+          onerror: (error) => {},
+        });
+      };
+
+      /** @type {!shaka.offline.StorageMuxer} */
+      const muxer = new shaka.offline.StorageMuxer();
+      const expectedError = shaka.test.Util.jasmineError(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.STORAGE,
+          shaka.util.Error.Code.INDEXED_DB_INIT_TIMED_OUT));
+
+      await expectAsync(muxer.init())
+          .toBeRejectedWith(expectedError);
+
+      window.indexedDB.open = oldOpen;
+    });
+
     it('throws an error if the content is a live stream', async () => {
       const expected = Util.jasmineError(new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,

package/test/player_unit.js

@@ -3735,6 +3735,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/test/util/simple_fakes.js

@@ -333,6 +333,9 @@ shaka.test.FakePlayhead = class {
     /** @private {number} */
     this.startTime_ = 0;
 
+    /** @type {!jasmine.Spy} */
+    this.ready = jasmine.createSpy('ready');
+
     /** @type {!jasmine.Spy} */
     this.setStartTime = jasmine.createSpy('setStartTime')
         .and.callFake((value) => {

package/test/util/periods_unit.js

@@ -12,6 +12,14 @@ describe('PeriodCombiner', () => {
   /** @type {shaka.util.PeriodCombiner} */
   let combiner;
 
+  const makeAudioStreamWithRoles = (id, roles, primary = true) => {
+    const stream = makeAudioStream('en');
+    stream.originalId = id;
+    stream.roles = roles;
+    stream.primary = primary;
+    return stream;
+  };
+
   beforeEach(() => {
     combiner = new shaka.util.PeriodCombiner();
   });
@@ -1127,20 +1135,149 @@ describe('PeriodCombiner', () => {
     const variants = combiner.getVariants();
 
     expect(variants).toEqual(jasmine.arrayWithExactContents([
-      makeAVVariant(1080, 'en'),
-      makeAVVariant(1080, 'en'),
+      makeAVVariant(1080, 'en', 2, ['role1', 'role2']),
+      makeAVVariant(1080, 'en', 2, ['role1']),
     ]));
 
     // We can use the originalId field to see what each track is composed of.
-    const audio1 = variants[0].audio;
-    expect(audio1.roles).toEqual(['role1', 'role2']);
-    expect(audio1.originalId).toBe('stream1,stream3');
+    expect(variants[0].audio.originalId).toBe('stream1,stream3');
+    expect(variants[1].audio.originalId).toBe('stream2,stream4');
+  });
 
-    const audio2 = variants[1].audio;
-    expect(audio2.roles).toEqual(['role1']);
-    expect(audio2.originalId).toBe('stream2,stream4');
+  it('Matches streams with roles in common', async () => {
+    /** @type {!Array.<shaka.util.PeriodCombiner.Period>} */
+    const periods = [
+      {
+        id: '1',
+        videoStreams: [
+          makeVideoStream(720),
+          makeVideoStream(1080),
+        ],
+        audioStreams: [
+          makeAudioStreamWithRoles('stream1', ['main']),
+          makeAudioStreamWithRoles('stream2', ['description'], false),
+        ],
+        textStreams: [],
+        imageStreams: [],
+      },
+      {
+        id: '2',
+        videoStreams: [
+          makeVideoStream(720),
+          makeVideoStream(1080),
+        ],
+        audioStreams: [
+          makeAudioStreamWithRoles('stream1', ['main']),
+          makeAudioStreamWithRoles('stream2', ['description'], false),
+        ],
+        textStreams: [],
+        imageStreams: [],
+      },
+    ];
+
+    await combiner.combinePeriods(periods, /* isDynamic= */ false);
+    const variants = combiner.getVariants();
+
+    console.log(variants);
+
+    expect(variants.length).toBe(4);
+
+    expect(variants).toEqual(jasmine.arrayWithExactContents([
+      makeAVVariant(720, 'en', 2, ['main']),
+      makeAVVariant(1080, 'en', 2, ['main']),
+      makeAVVariant(720, 'en', 2, ['description']),
+      makeAVVariant(1080, 'en', 2, ['description']),
+    ]));
+
+    // We can use the originalId field to see what each track is composed of.
+    expect(variants[0].audio.originalId).toBe('stream1,stream1');
+    expect(variants[1].audio.originalId).toBe('stream1,stream1');
+    expect(variants[2].audio.originalId).toBe('stream2,stream2');
+    expect(variants[3].audio.originalId).toBe('stream2,stream2');
   });
 
+  it('Matches streams with mismatched roles', async () => {
+    /** @type {!Array.<shaka.util.PeriodCombiner.Period>} */
+    const periods = [
+      {
+        id: '0',
+        videoStreams: [
+          makeVideoStream(720),
+          makeVideoStream(1080),
+        ],
+        audioStreams: [
+          makeAudioStreamWithRoles('stream1', ['main']),
+        ],
+        textStreams: [],
+        imageStreams: [],
+      },
+      {
+        id: '1',
+        videoStreams: [
+          makeVideoStream(720),
+          makeVideoStream(1080),
+        ],
+        audioStreams: [
+          makeAudioStreamWithRoles('stream1', ['main']),
+          makeAudioStreamWithRoles('stream2', ['description'], false),
+        ],
+        textStreams: [],
+        imageStreams: [],
+      },
+      {
+        id: '2',
+        videoStreams: [
+          makeVideoStream(720),
+          makeVideoStream(1080),
+        ],
+        audioStreams: [
+          makeAudioStreamWithRoles('stream1', ['main']),
+        ],
+        textStreams: [],
+        imageStreams: [],
+      },
+      {
+        id: '3',
+        videoStreams: [
+          makeVideoStream(720),
+          makeVideoStream(1080),
+        ],
+        audioStreams: [
+          makeAudioStreamWithRoles('stream1', ['main']),
+          makeAudioStreamWithRoles('stream2', ['description'], false),
+        ],
+        textStreams: [],
+        imageStreams: [],
+      },
+    ];
+
+    await combiner.combinePeriods(periods, /* isDynamic= */ false);
+    const variants = combiner.getVariants();
+
+    console.log(variants);
+
+    expect(variants.length).toBe(4);
+
+    expect(variants).toEqual(jasmine.arrayWithExactContents([
+      makeAVVariant(720, 'en', 2, ['main']),
+      makeAVVariant(1080, 'en', 2, ['main']),
+      makeAVVariant(720, 'en', 2, ['description', 'main']),
+      makeAVVariant(1080, 'en', 2, ['description', 'main']),
+    ]));
+
+    // We can use the originalId field to see what each track is composed of.
+    expect(variants[0].audio.originalId)
+        .toBe('stream1,stream1,stream1,stream1');
+
+    expect(variants[1].audio.originalId)
+        .toBe('stream1,stream1,stream1,stream1');
+
+    expect(variants[2].audio.originalId)
+        .toBe('stream1,stream2,stream1,stream2');
+
+    expect(variants[3].audio.originalId)
+        .toBe('stream1,stream2,stream1,stream2');
+  });
 
   it('The number of variants stays stable after many periods ' +
       'when going between similar content and varying ads', async () => {
@@ -1148,7 +1285,7 @@ describe('PeriodCombiner', () => {
     // https://github.com/shaka-project/shaka-player/issues/2716
     // that used to cause our period flattening logic to keep
     // creating new variants for every new period added.
-    // It's ok to create a few additional varinats/streams,
+    // It's ok to create a few additional variants/streams,
     // but we should stabilize eventually and keep the number
     // of variants from growing indefinitely.
 
@@ -1334,7 +1471,7 @@ describe('PeriodCombiner', () => {
       expect(isCandidateBetter).toBe(WORSE);
 
       // Make sure it works correctly whether it's the candidate or the best
-      // value that is equel to the output.
+      // value that is equal to the output.
       isCandidateBetter = PeriodCombiner.compareClosestPreferLower(
           /* output= */ 5, /* bestValue= */ 3, /* candidateValue= */ 5);
       expect(isCandidateBetter).toBe(BETTER);
@@ -1461,11 +1598,12 @@ describe('PeriodCombiner', () => {
    * @param {number=} channels
    * @return {shaka.extern.Variant}
    */
-  function makeAVVariant(height, language, channels = 2) {
+  function makeAVVariant(height, language, channels = 2, roles = []) {
     const variant = jasmine.objectContaining({
       language,
       audio: jasmine.objectContaining({
         language,
+        roles,
         channelsCount: channels,
       }),
       video: jasmine.objectContaining({

package/test/util/xml_utils_unit.js

@@ -371,5 +371,69 @@ describe('XmlUtils', () => {
     expect(XmlUtils.parseFloat(HUGE_NUMBER_STRING)).toBe(Infinity);
     expect(XmlUtils.parseFloat('-' + HUGE_NUMBER_STRING)).toBe(-Infinity);
   });
+
+  describe('parseXmlString', () => {
+    it('parses a simple XML document', () => {
+      const xmlString = [
+        '<?xml version="1.0"?>',
+        '<Root>',
+        '  <Child></Child>',
+        '</Root>',
+      ].join('\n');
+      const doc = XmlUtils.parseXmlString(xmlString, 'Root');
+      expect(doc).not.toBeNull();
+      expect(doc.tagName).toBe('Root');
+    });
+
+    it('returns null on an empty XML document', () => {
+      const xmlString = '';
+      const doc = XmlUtils.parseXmlString(xmlString, 'Root');
+      expect(doc).toBeNull();
+    });
+
+    it('returns null on malformed XML', () => {
+      const xmlString = [
+        '<?xml version="1.0"?>',
+        '<Root>',
+        '  <Child</Child>',
+        '</Root>',
+      ].join('\n');
+      const doc = XmlUtils.parseXmlString(xmlString, 'Root');
+      expect(doc).toBeNull();
+    });
+
+    it('returns null on root element mismatch', () => {
+      const xmlString = [
+        '<?xml version="1.0"?>',
+        '<Root>',
+        '  <Child></Child>',
+        '</Root>',
+      ].join('\n');
+      const doc = XmlUtils.parseXmlString(xmlString, 'Document');
+      expect(doc).toBeNull();
+    });
+
+    it('returns null on XML that embeds HTML', () => {
+      const xmlString = [
+        '<?xml version="1.0"?>',
+        '<Root>',
+        '  <Child xmlns="http://www.w3.org/1999/xhtml"></Child>',
+        '</Root>',
+      ].join('\n');
+      const doc = XmlUtils.parseXmlString(xmlString, 'Root');
+      expect(doc).toBeNull();
+    });
+
+    it('returns null on XML that embeds SVG', () => {
+      const xmlString = [
+        '<?xml version="1.0"?>',
+        '<Root>',
+        '  <Child xmlns="http://www.w3.org/2000/svg"></Child>',
+        '</Root>',
+      ].join('\n');
+      const doc = XmlUtils.parseXmlString(xmlString, 'Root');
+      expect(doc).toBeNull();
+    });
+  });
 });
 

package/ui/controls.js

@@ -970,7 +970,10 @@ shaka.ui.Controls = class extends shaka.util.FakeEventTarget {
     if (!this.video_ ||
         this.video_.readyState == 0 ||
         this.castProxy_.isCasting() ||
-        !this.config_.enableFullscreenOnRotation) { return; }
+        !this.config_.enableFullscreenOnRotation ||
+        !document.fullscreenEnabled) {
+      return;
+    }
 
     if (screen.orientation.type.includes('landscape') &&
         !document.fullscreenElement) {