shaka-player 3.2.15 → 3.2.17

package/test/player_integration.js

@@ -779,7 +779,7 @@ describe('Player', () => {
       expect(getBufferedBehind()).toBe(20);  // Buffered to start still.
       video.currentTime = 50;
       await waitUntilBuffered(30);
-      expect(getBufferedBehind()).toBeLessThan(30);
+      expect(getBufferedBehind()).toBeLessThan(40);  // 30 + segment_size
 
       player.configure('streaming.bufferBehind', 10);
       // We only evict content when we append a segment, so increase the
@@ -806,7 +806,7 @@ describe('Player', () => {
     }
 
     async function waitUntilBuffered(amount) {
-      for (let i = 0; i < 25; i++) {
+      for (let i = 0; i < 50; i++) {
         // We buffer from an internal segment, so this shouldn't take long to
         // buffer.
         await Util.delay(0.1);  // eslint-disable-line no-await-in-loop
@@ -814,7 +814,14 @@ describe('Player', () => {
           return;
         }
       }
-      throw new Error('Timeout waiting to buffer');
+
+      const ranges =
+          shaka.media.TimeRangesUtils.getBufferedInfo(video.buffered);
+      const currentTime = video.currentTime;
+      const target = currentTime + amount;
+
+      throw new Error('Timeout waiting to buffer! ' +
+          JSON.stringify({ranges, currentTime, target}));
     }
   });  // describe('buffering')
 

package/test/polyfill/media_capabilities_unit.js

@@ -0,0 +1,261 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('MediaCapabilities', () => {
+  const Util = shaka.test.Util;
+  const originalCast = window['cast'];
+  const originalVendor = navigator.vendor;
+  const originalUserAgent = navigator.userAgent;
+  const originalRequestMediaKeySystemAccess =
+    navigator.requestMediaKeySystemAccess;
+  const originalMediaCapabilities = navigator.mediaCapabilities;
+
+  /** @type {MediaDecodingConfiguration} */
+  let mockDecodingConfig;
+  /** @type {!jasmine.Spy} */
+  let mockCanDisplayType;
+
+  beforeAll(() => {
+    Object.defineProperty(window['navigator'],
+        'userAgent', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'vendor', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess', {
+          value: 'unknown', configurable: true,
+          writable: true,
+        });
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {
+          value: undefined, configurable: true,
+          writable: true,
+        });
+  });
+
+  beforeEach(() => {
+    mockDecodingConfig = {
+      audio: {
+        bitrate: 100891,
+        channels: 2,
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        samplerate: 48000,
+        spatialRendering: false,
+      },
+      keySystemConfiguration: {
+        audio: {robustness: 'SW_SECURE_CRYPTO'},
+        distinctiveIdentifier: 'optional',
+        initDataType: 'cenc',
+        keySystem: 'com.widevine.alpha',
+        persistentState: 'optional',
+        sessionTypes: ['temporary'],
+        video: {robustness: 'SW_SECURE_CRYPTO'},
+      },
+      type: 'media-source',
+      video: {
+        bitrate: 349265,
+        contentType: 'video/mp4; codecs="avc1.4D4015"',
+        framerate: 23.976023976023978,
+        height: 288,
+        width: 512,
+      },
+    };
+    shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
+
+    mockCanDisplayType = jasmine.createSpy('canDisplayType');
+    mockCanDisplayType.and.returnValue(false);
+  });
+
+  afterEach(() => {
+    window['cast'] = originalCast;
+  });
+
+  afterAll(() => {
+    window['cast'] = originalCast;
+    Object.defineProperty(window['navigator'],
+        'userAgent', {value: originalUserAgent});
+    Object.defineProperty(window['navigator'],
+        'vendor', {value: originalVendor});
+    Object.defineProperty(window['navigator'],
+        'requestMediaKeySystemAccess',
+        {value: originalRequestMediaKeySystemAccess});
+    Object.defineProperty(window['navigator'],
+        'mediaCapabilities', {value: originalMediaCapabilities});
+  });
+
+  describe('install', () => {
+    it('should define decoding info method', () => {
+      shaka.polyfill.MediaCapabilities.install();
+
+      expect(navigator.mediaCapabilities.decodingInfo).toBeDefined();
+    });
+  });
+
+  describe('decodingInfo', () => {
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "media-source"', () => {
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(isTypeSupportedSpy).toHaveBeenCalledTimes(2);
+      expect(isTypeSupportedSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.video.contentType,
+      );
+      expect(isTypeSupportedSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.audio.contentType,
+      );
+    });
+
+    it('should check codec support when MediaDecodingConfiguration.type ' +
+      'is "file"', () => {
+      const supportsMediaTypeSpy =
+          spyOn(shaka['util']['Platform'],
+              'supportsMediaType').and.returnValue(true);
+      mockDecodingConfig.type = 'file';
+      shaka.polyfill.MediaCapabilities.install();
+      navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      expect(supportsMediaTypeSpy).toHaveBeenCalledTimes(2);
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.video.contentType,
+      );
+      expect(supportsMediaTypeSpy).toHaveBeenCalledWith(
+          mockDecodingConfig.audio.contentType,
+      );
+    });
+
+    it('should check MediaKeySystem when keySystemConfiguration is present',
+        async () => {
+          const mockResult = {mockKeySystemAccess: 'mockKeySystemAccess'};
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+          const requestKeySystemAccessSpy =
+          spyOn(window['navigator'],
+              'requestMediaKeySystemAccess').and.returnValue(mockResult);
+
+          shaka.polyfill.MediaCapabilities.install();
+          const result = await navigator.mediaCapabilities
+              .decodingInfo(mockDecodingConfig);
+
+          expect(requestKeySystemAccessSpy).toHaveBeenCalledWith(
+              'com.widevine.alpha',
+              [{
+                audioCapabilities: [
+                  {
+                    robustness: 'SW_SECURE_CRYPTO',
+                    contentType: 'audio/mp4; codecs="mp4a.40.2"',
+                  },
+                ],
+                distinctiveIdentifier: 'optional',
+                initDataTypes: ['cenc'],
+                persistentState: 'optional',
+                sessionTypes: ['temporary'],
+                videoCapabilities: [{
+                  robustness: 'SW_SECURE_CRYPTO',
+                  contentType: 'video/mp4; codecs="avc1.4D4015"',
+                }],
+              }],
+          );
+          expect(result.keySystemAccess).toEqual(mockResult);
+        });
+
+    it('throws when the cast namespace is not available', async () => {
+      // Temporarily remove window.cast to trigger error. It's restored after
+      // every test.
+      delete window['cast'];
+
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      const expected = Util.jasmineError(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.CAST,
+          shaka.util.Error.Code.CAST_API_UNAVAILABLE));
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+
+      shaka.polyfill.MediaCapabilities.install();
+      await expectAsync(
+          navigator.mediaCapabilities.decodingInfo(mockDecodingConfig))
+          .toBeRejectedWith(expected);
+
+      expect(isTypeSupportedSpy).not.toHaveBeenCalled();
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('falls back to isTypeSupported() when canDisplayType() missing',
+        async () => {
+          // We only set the cast namespace, but not the canDisplayType() API.
+          window['cast'] = {};
+          const isChromecastSpy =
+              spyOn(shaka['util']['Platform'],
+                  'isChromecast').and.returnValue(true);
+          const isTypeSupportedSpy =
+              spyOn(window['MediaSource'], 'isTypeSupported')
+                  .and.returnValue(true);
+
+          shaka.polyfill.MediaCapabilities.install();
+          await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+          expect(mockCanDisplayType).not.toHaveBeenCalled();
+          // 1 (during install()) + 1 (for video config check).
+          expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+          // 1 (fallback in canCastDisplayType()) +
+          // 1 (mockDecodingConfig.audio).
+          expect(isTypeSupportedSpy).toHaveBeenCalledTimes(2);
+        });
+
+    it('should use cast.__platform__.canDisplayType for "supported" field ' +
+        'when platform is Cast', async () => {
+      // We're using quotes to access window.cast because the compiler
+      // knows about lots of Cast-specific APIs we aren't mocking.  We
+      // don't need this mock strictly type-checked.
+      window['cast'] = {
+        __platform__: {canDisplayType: mockCanDisplayType},
+      };
+      const isChromecastSpy =
+          spyOn(shaka['util']['Platform'],
+              'isChromecast').and.returnValue(true);
+      const isTypeSupportedSpy =
+          spyOn(window['MediaSource'], 'isTypeSupported').and.returnValue(true);
+
+      // Tests an HDR stream's extended MIME type is correctly provided.
+      mockDecodingConfig.video.transferFunction = 'pq';
+      mockDecodingConfig.video.contentType =
+          'video/mp4; codecs="hev1.2.4.L153.B0"';
+      // Round to a whole number since we can't rely on number => string
+      // conversion precision on all devices.
+      mockDecodingConfig.video.framerate = 24;
+      mockCanDisplayType.and.callFake((type) => {
+        expect(type).toBe(
+            'video/mp4; ' +
+            'codecs="hev1.2.4.L153.B0"; ' +
+            'width=512; ' +
+            'height=288; ' +
+            'framerate=24; ' +
+            'eotf=smpte2084');
+        return true;
+      });
+
+      shaka.polyfill.MediaCapabilities.install();
+      await navigator.mediaCapabilities.decodingInfo(mockDecodingConfig);
+
+      // 1 (during install()) + 1 (for video config check).
+      expect(isChromecastSpy).toHaveBeenCalledTimes(2);
+      // 1 (mockDecodingConfig.audio).
+      expect(isTypeSupportedSpy).toHaveBeenCalledTimes(1);
+      // Called once in canCastDisplayType.
+      expect(mockCanDisplayType).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/test/test/boot.js

@@ -66,22 +66,40 @@ function failTestsOnNamespacedElementOrAttributeNames() {
 }
 
 /**
- * Listen for unhandled Promise rejections (which may occur after a test) and
- * convert them into test failures.
+ * Fail the current test on a given error, constructed with a given header and
+ * the full stack trace of the error.
+ *
+ * @param {string} messageHeader
+ * @param {!Error} error
  */
-function failTestsOnUnhandledRejections() {
+function failOnError(messageHeader, error) {
+  let message = `${messageHeader}: ${error}`;
+  // Shaka errors have the stack trace in their toString() already, so don't
+  // add it again.  For native errors, we need to see where it came from.
+  if (error && error.stack && !(error instanceof shaka.util.Error)) {
+    message += '\n' + error.stack;
+  }
+  fail(message);
+}
+
+/**
+ * Listen for unhandled errors and Promise rejections (which may occur after a
+ * test) and convert them into test failures.
+ */
+function failTestsOnUnhandledErrors() {
   // https://developer.mozilla.org/en-US/docs/Web/Events/unhandledrejection
   window.addEventListener('unhandledrejection', (event) => {
     /** @type {?} */
     const error = event.reason;
-    let message = 'Unhandled rejection in Promise: ' + error;
+    failOnError('Unhandled rejection in Promise', error);
+  });
 
-    // Shaka errors have the stack trace in their toString() already, so don't
-    // add it again.  For native errors, we need to see where it came from.
-    if (error && error.stack && !(error instanceof shaka.util.Error)) {
-      message += '\n' + error.stack;
-    }
-    fail(message);
+  // https://developer.mozilla.org/en-US/docs/Web/API/Window/error_event
+  // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+  window.addEventListener('error', (event) => {
+    /** @type {?} */
+    const error = event['error'];
+    failOnError('Unhandled error', error);
   });
 }
 
@@ -387,7 +405,7 @@ function configureJasmineEnvironment() {
 function setupTestEnvironment() {
   failTestsOnFailedAssertions();
   failTestsOnNamespacedElementOrAttributeNames();
-  failTestsOnUnhandledRejections();
+  failTestsOnUnhandledErrors();
   disableScrollbars();
   workAroundLegacyEdgePromiseIssues();
 

package/test/test/util/test_scheme.js

@@ -389,7 +389,7 @@ const sintelAudioSegment = {
   mdhdOffset: 0x1b6,
   segmentUri: '/base/test/test/assets/sintel-audio-segment.mp4',
   tfdtOffset: 0x3c,
-  segmentDuration: 10.005,
+  segmentDuration: 10,
   mimeType: 'audio/mp4',
   codecs: 'mp4a.40.2',
 };
@@ -415,7 +415,7 @@ const sintelEncryptedAudio = {
   mdhdOffset: 0x1b6,
   segmentUri: '/base/test/test/assets/encrypted-sintel-audio-segment.mp4',
   tfdtOffset: 0x3c,
-  segmentDuration: 10.005,
+  segmentDuration: 10,
   mimeType: 'audio/mp4',
   codecs: 'mp4a.40.2',
   initData:

package/test/text/mp4_ttml_parser_unit.js

@@ -41,7 +41,7 @@ describe('Mp4TtmlParser', () => {
   it('handles media segments with multiple mdats', () => {
     const parser = new shaka.text.Mp4TtmlParser();
     parser.parseInit(ttmlInitSegment);
-    const time = {periodStart: 0, segmentStart: 0, segmentEnd: 0};
+    const time = {periodStart: 0, segmentStart: 60, segmentEnd: 0};
     const ret = parser.parseMedia(ttmlSegmentMultipleMDAT, time);
     // Bodies.
     expect(ret.length).toBe(2);
@@ -54,8 +54,8 @@ describe('Mp4TtmlParser', () => {
   });
 
   it('accounts for offset', () => {
-    const time1 = {periodStart: 0, segmentStart: 0, segmentEnd: 0};
-    const time2 = {periodStart: 7, segmentStart: 0, segmentEnd: 0};
+    const time1 = {periodStart: 0, segmentStart: 0, segmentEnd: 70};
+    const time2 = {periodStart: 7, segmentStart: 0, segmentEnd: 70};
 
     const parser = new shaka.text.Mp4TtmlParser();
     parser.parseInit(ttmlInitSegment);
@@ -159,7 +159,7 @@ describe('Mp4TtmlParser', () => {
     ];
     const parser = new shaka.text.Mp4TtmlParser();
     parser.parseInit(ttmlInitSegment);
-    const time = {periodStart: 0, segmentStart: 0, segmentEnd: 0};
+    const time = {periodStart: 0, segmentStart: 0, segmentEnd: 60};
     const result = parser.parseMedia(ttmlSegment, time);
     shaka.test.TtmlUtils.verifyHelper(
         cues, result, {startTime: 23, endTime: 53.5});