shaka-player 4.2.12 → 4.2.13

package/test/test/util/util.js

@@ -255,33 +255,12 @@ shaka.test.Util = class {
    * @param {string} uri
    * @return {!Promise.<!ArrayBuffer>}
    */
-  static fetch(uri) {
-    return new Promise(((resolve, reject) => {
-      const xhr = new XMLHttpRequest();
-      xhr.open('GET', uri, /* asynchronous= */ true);
-      xhr.responseType = 'arraybuffer';
-
-      xhr.onload = (event) => {
-        if (xhr.status >= 200 &&
-            xhr.status <= 299 &&
-            !!xhr.response) {
-          resolve(/** @type {!ArrayBuffer} */(xhr.response));
-        } else {
-          let message = '';
-          if (xhr.response) {
-            message = ': ' + shaka.util.StringUtils.fromUTF8(
-                /** @type {!ArrayBuffer} */(xhr.response));
-          }
-          reject(xhr.status + message);
-        }
-      };
-
-      xhr.onerror = (event) => {
-        reject('shaka.test.Util.fetch failed: ' + uri);
-      };
-
-      xhr.send(/* body= */ null);
-    }));
+  static async fetch(uri) {
+    const response = await fetch(uri);
+    if (!response.ok) {
+      throw new Error('shaka.test.Util.fetch failed: ' + uri);
+    }
+    return response.arrayBuffer();
   }
 
   /**

package/test/test/util/waiter.js

@@ -109,6 +109,8 @@ shaka.test.Waiter = class {
    * @return {!Promise}
    */
   waitUntilPlayheadReaches(mediaElement, timeGoal) {
+    this.macPlaybackWorkaround_(mediaElement);
+
     // The name of what we're waiting for
     const goalName = 'movement from ' + mediaElement.currentTime +
                      ' to ' + timeGoal;
@@ -153,6 +155,8 @@ shaka.test.Waiter = class {
    * @return {!Promise}
    */
   waitForEnd(mediaElement) {
+    this.macPlaybackWorkaround_(mediaElement);
+
     // The name of what we're waiting for.
     const goalName = 'end of media';
 
@@ -207,13 +211,64 @@ shaka.test.Waiter = class {
    * Wait for the video to end or for |timeout| seconds to pass, whichever
    * occurs first.  The Promise is resolved when either of these happens.
    *
-   * @param {!HTMLMediaElement} target
+   * @param {!HTMLMediaElement} mediaElement
    * @param {number} timeout in seconds, after which the Promise succeeds
    * @return {!Promise}
    */
-  waitForEndOrTimeout(target, timeout) {
+  waitForEndOrTimeout(mediaElement, timeout) {
     this.failOnTimeout(false).timeoutAfter(timeout);
-    return this.waitForEnd(target);
+    return this.waitForEnd(mediaElement);
+  }
+
+  /**
+   * Wait until a certain amount of content is buffered.
+   *
+   * @param {!HTMLMediaElement} mediaElement
+   * @param {number} bufferingGoal in seconds, after which the Promise succeeds
+   * @return {!Promise}
+   */
+  waitUntilBuffered(mediaElement, bufferingGoal) {
+    // The name of what we're waiting for.
+    const goalName = `${bufferingGoal} seconds buffered`;
+
+    // The conditions for success.
+    const bufferedEnough = () => {
+      const end = shaka.media.TimeRangesUtils.bufferEnd(mediaElement.buffered);
+      if (end == null) {
+        return false;
+      }
+      return end - mediaElement.currentTime >= bufferingGoal;
+    };
+
+    if (bufferedEnough()) {
+      return Promise.resolve();
+    }
+
+    // Cleanup on timeout.
+    let timer = null;
+    const cleanup = () => {
+      if (timer) {
+        timer.stop();
+      }
+      this.eventManager_.unlisten(mediaElement, 'timeupdate');
+      this.eventManager_.unlisten(mediaElement, 'ended');
+    };
+
+    const p = new Promise((resolve) => {
+      const check = () => {
+        if (bufferedEnough()) {
+          cleanup();
+          resolve();
+        }
+      };
+
+      timer = new shaka.util.Timer(check);
+      timer.tickEvery(/* seconds= */ 1);
+      this.eventManager_.listen(mediaElement, 'timeupdate', check);
+      this.eventManager_.listen(mediaElement, 'ended', check);
+    });
+
+    return this.waitUntilGeneric_(goalName, p, cleanup, mediaElement);
   }
 
   /**
@@ -333,4 +388,19 @@ shaka.test.Waiter = class {
         `buffered: ${JSON.stringify(buffered)}\n`;
     shaka.log.error(error.message);
   }
+
+  /**
+   * @param {!HTMLMediaElement} mediaElement
+   * @private
+   */
+  macPlaybackWorkaround_(mediaElement) {
+    if (shaka.util.Platform.isMac()) {
+      // Work around bizarre playback slowdowns that only seem to occur with
+      // WebDriver and only on Mac.  Increasing the playback rate allows tests
+      // to complete without timing out.
+      if (mediaElement.playbackRate == 1) {
+        mediaElement.playbackRate = 2;
+      }
+    }
+  }
 };

package/test/ui/ad_ui_unit.js

@@ -25,15 +25,6 @@ describe('Ad UI', () => {
     shaka.Player.setAdManagerFactory(() => new shaka.test.FakeAdManager());
   });
 
-  afterEach(async () => {
-    await UiUtils.cleanupUI();
-  });
-
-  afterAll(() => {
-    document.head.removeChild(cssLink);
-    shaka.Player.setAdManagerFactory(() => new shaka.ads.AdManager());
-  });
-
   beforeEach(() => {
     container =
       /** @type {!HTMLElement} */ (document.createElement('div'));
@@ -45,6 +36,15 @@ describe('Ad UI', () => {
     adManager = video['ui'].getControls().getPlayer().getAdManager();
   });
 
+  afterEach(async () => {
+    await UiUtils.cleanupUI();
+  });
+
+  afterAll(() => {
+    document.head.removeChild(cssLink);
+    shaka.Player.setAdManagerFactory(() => new shaka.ads.AdManager());
+  });
+
   it('is invisible if no ad is playing', () => {
     const adControlsContainer =
         UiUtils.getElementByClassName(container, 'shaka-ad-controls');

package/test/util/stream_utils_unit.js

@@ -718,6 +718,52 @@ describe('StreamUtils', () => {
       expect(manifest.variants.length).toBe(1);
     });
 
+    it('supports fLaC codec', async () => {
+      if (!MediaSource.isTypeSupported('audio/mp4; codecs="flac"')) {
+        pending('Codec fLaC is not supported by the platform.');
+      }
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(0, (variant) => {
+          variant.addAudio(1, (stream) => {
+            stream.mime('audio/mp4', 'fLaC');
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.addAudio(3, (stream) => {
+            stream.mime('audio/mp4', 'flac');
+          });
+        });
+      });
+
+      await shaka.util.StreamUtils.filterManifest(
+          fakeDrmEngine, /* currentVariant= */ null, manifest);
+
+      expect(manifest.variants.length).toBe(2);
+    });
+
+    it('supports Opus codec', async () => {
+      if (!MediaSource.isTypeSupported('audio/mp4; codecs="opus"')) {
+        pending('Codec Opus is not supported by the platform.');
+      }
+      manifest = shaka.test.ManifestGenerator.generate((manifest) => {
+        manifest.addVariant(0, (variant) => {
+          variant.addAudio(1, (stream) => {
+            stream.mime('audio/mp4', 'Opus');
+          });
+        });
+        manifest.addVariant(2, (variant) => {
+          variant.addAudio(3, (stream) => {
+            stream.mime('audio/mp4', 'opus');
+          });
+        });
+      });
+
+      await shaka.util.StreamUtils.filterManifest(
+          fakeDrmEngine, /* currentVariant= */ null, manifest);
+
+      expect(manifest.variants.length).toBe(2);
+    });
+
     it('supports legacy AVC1 codec', async () => {
       if (!MediaSource.isTypeSupported('video/mp4; codecs="avc1.42001e"')) {
         pending('Codec avc1.42001e is not supported by the platform.');

package/ui/range_element.js

@@ -110,6 +110,11 @@ shaka.ui.RangeElement = class extends shaka.ui.Element {
         this.onChangeEnd();
       }
     });
+
+    this.eventManager.listen(this.bar, 'contextmenu', (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+    });
   }
 
   /** @override */