shaka-player 4.1.3 → 4.2.1

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/player_src_equals_integration.js

@@ -305,6 +305,8 @@ describe('Player Src Equals', () => {
     expect(stats.loadLatency).toBeGreaterThan(0);
     expect(stats.manifestTimeSeconds).toBeNaN(); // There's no manifest.
     expect(stats.drmTimeSeconds).toBeNaN(); // There's no DRM.
+    expect(stats.height).toBe(110);
+    expect(stats.width).toBe(256);
   });
 
   it('plays with external text tracks', async () => {

package/test/player_unit.js

@@ -422,7 +422,6 @@ describe('Player', () => {
             dispatchEventSpy.calls.reset();
             player.configure({streaming: {maxDisabledTime}});
             player.setMaxHardwareResolution(123, 456);
-            onErrorCallback(httpError);
           });
 
           afterEach(() => {
@@ -434,14 +433,18 @@ describe('Player', () => {
           });
 
           it('handles HTTP_ERROR', () => {
+            onErrorCallback(httpError);
             expect(httpError.handled).toBeTruthy();
           });
 
           it('does not dispatch any error', () => {
+            onErrorCallback(httpError);
             expect(dispatchEventSpy).not.toHaveBeenCalled();
           });
 
           it('disables the current variant and applies restrictions', () => {
+            onErrorCallback(httpError);
+
             const foundDisabledVariant =
                 manifest.variants.some(({disabledUntilTime}) =>
                   disabledUntilTime == currentTime + maxDisabledTime);
@@ -453,11 +456,46 @@ describe('Player', () => {
           });
 
           it('switches the variant', () => {
+            onErrorCallback(httpError);
+
             expect(chooseVariantSpy).toHaveBeenCalled();
             expect(getBufferedInfoSpy).toHaveBeenCalled();
             expect(switchVariantSpy)
                 .toHaveBeenCalledWith(chosenVariant, false, true, 14);
           });
+
+          describe('but browser is truly offline', () => {
+            /** @type {!Object} */
+            let navigatorOnLineDescriptor;
+
+            // eslint-disable-next-line no-restricted-syntax
+            const navigatorPrototype = Navigator.prototype;
+
+            beforeAll(() => {
+              navigatorOnLineDescriptor =
+                /** @type {!Object} */(Object.getOwnPropertyDescriptor(
+                    navigatorPrototype, 'onLine'));
+            });
+
+            beforeEach(() => {
+              // Redefine the property, replacing only the getter.
+              Object.defineProperty(navigatorPrototype, 'onLine',
+                  Object.assign(navigatorOnLineDescriptor, {
+                    get: () => false,
+                  }));
+            });
+
+            afterEach(() => {
+              // Restore the original property definition.
+              Object.defineProperty(
+                  navigatorPrototype, 'onLine', navigatorOnLineDescriptor);
+            });
+
+            it('does not handle HTTP_ERROR', () => {
+              onErrorCallback(httpError);
+              expect(httpError.handled).toBe(false);
+            });
+          });
         });
       });
     });

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} */

package/test/text/vtt_text_parser_unit.js

@@ -1008,6 +1008,32 @@ describe('VttTextParser', () => {
         {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
   });
 
+  it('supports karaoke style text', () => {
+    verifyHelper(
+        [
+          {
+            startTime: 20, endTime: 40,
+            payload: '',
+            nestedCues: [
+              {
+                startTime: 20,
+                endTime: 40,
+                payload: 'Test',
+              },
+              {
+                startTime: 25,
+                endTime: 40,
+                payload: ' 1',
+              },
+            ],
+          },
+        ],
+        'WEBVTT\n\n' +
+        '00:00:20.00 --> 00:00:40.00\n' +
+        'Test<00:00:25.00> 1',
+        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
+  });
+
   it('supports default color overriding', () => {
     verifyHelper(
         [

package/ui/less/ad_controls.less

@@ -71,6 +71,10 @@
   .ad-text-shadow();
 }
 
+.shaka-ad-controls .shaka-ad-position:not(.shaka-hidden) + .shaka-ad-counter {
+  margin-left: 0.75em;
+}
+
 .shaka-skip-ad-container {
   /* Skip button is positioned at the very right edge of the
    * video container unlike the rest of the bottom controls. */