shaka-player 4.6.3 → 4.7.0

package/test/test/util/waiter.js

@@ -1,406 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-shaka.test.Waiter = class {
-  /** @param {!shaka.util.EventManager} eventManager */
-  constructor(eventManager) {
-    /** @private {shaka.util.EventManager} */
-    this.eventManager_ = eventManager;
-
-    /** @private {boolean} */
-    this.failOnTimeout_ = true;
-
-    /** @private {number} */
-    this.timeoutSeconds_ = 5;
-
-    /** @private {shaka.Player} */
-    this.player_ = null;
-
-    /** @private {shaka.media.MediaSourceEngine} */
-    this.mediaSourceEngine_ = null;
-  }
-
-  // TODO: Consider replacing this with a settings argument on the individual
-  // waiters, or resetting these settings after each wait.
-  /**
-   * Change the timeout time for subsequent wait operations.
-   *
-   * @param {number} timeoutSeconds
-   * @return {!shaka.test.Waiter}
-   */
-  timeoutAfter(timeoutSeconds) {
-    this.timeoutSeconds_ = timeoutSeconds;
-    return this;
-  }
-
-  // TODO: Consider replacing this with a settings argument on the individual
-  // waiters, or resetting these settings after each wait.
-  /**
-   * Change the timeout behavior (pass or fail) for subsequent wait operations.
-   *
-   * @param {boolean} shouldFailOnTimeout
-   * @return {!shaka.test.Waiter}
-   */
-  failOnTimeout(shouldFailOnTimeout) {
-    this.failOnTimeout_ = shouldFailOnTimeout;
-    return this;
-  }
-
-  /**
-   * For tests with access to MediaSourceEngine, this can provide better
-   * debugging for buffered ranges on failure.
-   *
-   * @param {shaka.Player} player
-   * @return {!shaka.test.Waiter}
-   */
-  setPlayer(player) {
-    this.player_ = player;
-    return this;
-  }
-
-  /**
-   * For tests with access to MediaSourceEngine, this can provide better
-   * debugging for buffered ranges on failure.
-   *
-   * @param {shaka.media.MediaSourceEngine} mediaSourceEngine
-   * @return {!shaka.test.Waiter}
-   */
-  setMediaSourceEngine(mediaSourceEngine) {
-    this.mediaSourceEngine_ = mediaSourceEngine;
-    return this;
-  }
-
-  /**
-   * Wait for the video playhead to move forward by some meaningful delta.  The
-   * Promise is resolved when the playhead moves or the video ends.
-   *
-   * @param {!HTMLMediaElement} mediaElement
-   * @return {!Promise}
-   */
-  waitForMovement(mediaElement) {
-    console.assert(!mediaElement.ended, 'Video should not be ended!');
-    const timeGoal = mediaElement.currentTime + 1;
-    return this.waitUntilPlayheadReaches(mediaElement, timeGoal);
-  }
-
-  /**
-   * Wait for the video playhead to move forward by some meaningful delta.
-   * If this happens before |timeout| seconds pass, the Promise is resolved.
-   * Otherwise, the Promise is rejected.
-   *
-   * @param {!HTMLMediaElement} target
-   * @param {number} timeout in seconds, after which the Promise fails
-   * @return {!Promise}
-   */
-  waitForMovementOrFailOnTimeout(target, timeout) {
-    this.timeoutAfter(timeout).failOnTimeout(true);
-    return this.waitForMovement(target);
-  }
-
-  /**
-   * Wait for the video playhead to reach a certain target time.
-   * Promise is resolved when the playhead reaches |timeGoal| or the video ends.
-   *
-   * @param {!HTMLMediaElement} mediaElement
-   * @param {number} timeGoal
-   * @return {!Promise}
-   */
-  waitUntilPlayheadReaches(mediaElement, timeGoal) {
-    this.macPlaybackWorkaround_(mediaElement);
-
-    // The name of what we're waiting for
-    const goalName = 'movement from ' + mediaElement.currentTime +
-                     ' to ' + timeGoal;
-
-    // The conditions for success
-    const p = new Promise((resolve) => {
-      this.eventManager_.listen(mediaElement, 'timeupdate', () => {
-        if (mediaElement.currentTime >= timeGoal || mediaElement.ended) {
-          this.eventManager_.unlisten(mediaElement, 'timeupdate');
-          resolve();
-        }
-      });
-    });
-
-    // The cleanup on timeout
-    const cleanup = () => {
-      this.eventManager_.unlisten(mediaElement, 'timeupdate');
-    };
-
-    return this.waitUntilGeneric_(goalName, p, cleanup, mediaElement);
-  }
-
-  /**
-   * Wait for the video playhead to reach a certain target time.
-   * If the playhead reaches |timeGoal| or the video ends before |timeout|
-   * seconds pass, the Promise is resolved.
-   * Otherwise, the Promise is rejected.
-   * @param {!HTMLMediaElement} mediaElement
-   * @param {number} timeGoal The time to wait for the playhead to reach.
-   * @param {number} timeout Timeout in seconds, after which the Promise fails.
-   * @return {!Promise}
-   */
-  waitUntilPlayheadReachesOrFailOnTimeout(mediaElement, timeGoal, timeout) {
-    this.timeoutAfter(timeout).failOnTimeout(true);
-    return this.waitUntilPlayheadReaches(mediaElement, timeGoal);
-  }
-
-  /**
-   * Wait for the video to end.
-   *
-   * @param {!HTMLMediaElement} mediaElement
-   * @return {!Promise}
-   */
-  waitForEnd(mediaElement) {
-    this.macPlaybackWorkaround_(mediaElement);
-
-    // The name of what we're waiting for.
-    const goalName = 'end of media';
-
-    // The conditions for success.  Don't rely on either time, or the ended
-    // flag, or the ended event, specifically.  Any of these is sufficient.
-    // This flexibility cuts down on test flake on Safari (currently 14) in
-    // particular, where the flag might be set, but the ended event did not
-    // fire.  We also see flake on Firefox (currently 99), where test playbacks
-    // sometimes stop right before duration is reached.  (Duration 60.01, audio
-    // buffered to 60.01, video buffered to exactly 60.)
-    const hasEnded = () => {
-      return mediaElement.currentTime >= mediaElement.duration - 0.1 ||
-          mediaElement.ended;
-    };
-
-    if (hasEnded()) {
-      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 (hasEnded()) {
-          cleanup();
-          resolve();
-        }
-      };
-
-      // In Firefox 99, there appears to be some bug in the browser preventing
-      // events from being triggered at the end of the presentation.  So we
-      // check for the end once per second.  Without this, StreamingEngine
-      // integration tests were failing.
-      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);
-  }
-
-  /**
-   * 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} mediaElement
-   * @param {number} timeout in seconds, after which the Promise succeeds
-   * @return {!Promise}
-   */
-  waitForEndOrTimeout(mediaElement, timeout) {
-    this.failOnTimeout(false).timeoutAfter(timeout);
-    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);
-  }
-
-  /**
-   * Wait for the given event.
-   *
-   * @param {!EventTarget} target
-   * @param {string} eventName
-   * @return {!Promise}
-   */
-  waitForEvent(target, eventName) {
-    // The name of what we're waiting for
-    const goalName = 'event ' + eventName;
-
-    // The conditions for success
-    const p = new Promise((resolve) => {
-      this.eventManager_.listenOnce(target, eventName, resolve);
-    });
-
-    // The cleanup on timeout
-    const cleanup = () => {
-      this.eventManager_.unlisten(target, eventName);
-    };
-
-    return this.waitUntilGeneric_(goalName, p, cleanup, target);
-  }
-
-  /**
-   * Wait for a certain Promise to be resolved, or throw on timeout.
-   *
-   * @param {!Promise} p
-   * @param {string} label A name to give the Promise in error messages.
-   * @return {!Promise}
-   */
-  waitForPromise(p, label) {
-    const cleanup = () => {};
-    const target = null;
-    return this.waitUntilGeneric_(label, p, cleanup, target);
-  }
-
-  /**
-   * Wait for a certain Promise to be resolved, or throw on timeout.
-   * Handles all debug logging and timeouts generically.
-   *
-   * @param {string} goalName
-   * @param {!Promise} p
-   * @param {function()} cleanupOnTimeout
-   * @param {EventTarget} target
-   * @return {!Promise}
-   * @private
-   */
-  waitUntilGeneric_(goalName, p, cleanupOnTimeout, target) {
-    let goalMet = false;
-    const startTime = Date.now();
-    shaka.log.debug('Waiting for ' + goalName);
-
-    // Cache the value of this when we start, in case it changes during the
-    // async work below.
-    const failOnTimeout = this.failOnTimeout_;
-
-    // The original stacktrace will be lost if we create the Error in the
-    // timeout callback below.  Create the Error now so that it has a more
-    // useful stacktrace on timeout.
-    const error = new Error('Timeout waiting for ' + goalName);
-
-    const success = p.then(() => {
-      goalMet = true;
-      const endTime = Date.now();
-      const seconds = ((endTime - startTime) / 1000).toFixed(2);
-      shaka.log.debug(goalName + ' after ' + seconds + ' seconds');
-    });
-
-    const timeout = shaka.test.Util.delay(this.timeoutSeconds_).then(() => {
-      // Avoid error logs and cleanup callback if we've already met the goal.
-      if (goalMet) {
-        return;
-      }
-
-      cleanupOnTimeout();
-
-      // Improve the error message with media-specific debug info.
-      if (target instanceof HTMLMediaElement) {
-        this.logDebugInfoForMedia_(error, target);
-      }
-
-      // Reject or resolve based on our settings.
-      if (failOnTimeout) {
-        throw error;
-      }
-    });
-
-    return Promise.race([success, timeout]);
-  }
-
-  /**
-   * @param {!Error} error
-   * @param {!HTMLMediaElement} mediaElement
-   * @private
-   */
-  logDebugInfoForMedia_(error, mediaElement) {
-    let buffered;
-    if (this.player_) {
-      buffered = this.player_.getBufferedInfo();
-    } else if (this.mediaSourceEngine_) {
-      buffered = this.mediaSourceEngine_.getBufferedInfo();
-    } else {
-      buffered = shaka.media.TimeRangesUtils.getBufferedInfo(
-          mediaElement.buffered);
-    }
-
-    error.message += '\n' +
-        `current time: ${mediaElement.currentTime}\n` +
-        `duration: ${mediaElement.duration}\n` +
-        `ready state: ${mediaElement.readyState}\n` +
-        `playback rate: ${mediaElement.playbackRate}\n` +
-        `paused: ${mediaElement.paused}\n` +
-        `ended: ${mediaElement.ended}\n` +
-        `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/text/cue_integration.js

@@ -1,51 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-describe('Cue', () => {
-  // This integration test checks platform support for various cue scenarios
-  // that have caused platform-specific issues.  The unit tests for each parser
-  // use a mocked VTTCue implementation, so they do not find platform issues.
-
-  // The scenarios under test are not specific to WebVTT, but WebVTT is used to
-  // exercise the platform's native cues and ensure that no errors occur.
-
-  it('handles offsets', () => {
-    // Offsets must be handled early.
-    // See issue #502
-    const cues = parseVtt(
-        'WEBVTT\n\n' +
-        '00:00:20.000 --> 00:00:40.000\n' +
-        'Test',
-        {periodStart: 7, segmentStart: 10, segmentEnd: 60, vttOffset: 7});
-    expect(cues.length).toBe(1);
-    expect(cues[0].startTime).toBe(27);
-    expect(cues[0].endTime).toBe(47);
-  });
-
-  it('does not object to extra settings', () => {
-    // To simplify refactoring, we are no longer checking for VTTCue before
-    // setting properties that only exist on VTTCue.  So we want to ensure that
-    // errors are not thrown when the extra settings are assigned.
-    const cues = parseVtt(
-        'WEBVTT\n\n' +
-        'ID1\n' +
-        '00:00:20.000 --> 00:00:40.000 align:middle size:56% vertical:lr\n' +
-        'Test',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-    expect(cues.length).toBe(1);
-  });
-
-  /**
-   * @param {string} text
-   * @param {!shaka.extern.TextParser.TimeContext} time
-   * @return {!Array.<!shaka.text.Cue>}
-   */
-  function parseVtt(text, time) {
-    const data =
-        shaka.util.BufferUtils.toUint8(shaka.util.StringUtils.toUTF8(text));
-    return new shaka.text.VttTextParser().parseMedia(data, time);
-  }
-});

package/test/text/lrc_text_parser_unit.js

@@ -1,98 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-describe('LrcTextParser', () => {
-  it('supports no cues', () => {
-    verifyHelper([],
-        '',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-  });
-
-  it('handles a blank line at the start of the file', () => {
-    verifyHelper(
-        [
-          {startTime: 0, endTime: 2, payload: 'Test'},
-        ],
-        '\n\n' +
-        '[00:00.00]Test',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-  });
-
-  it('handles a blank line at the end of the file', () => {
-    verifyHelper(
-        [
-          {startTime: 0, endTime: 2, payload: 'Test'},
-        ],
-        '[00:00.00]Test' +
-        '\n\n',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-  });
-
-  it('handles no blank line at the end of the file', () => {
-    verifyHelper(
-        [
-          {startTime: 0, endTime: 2, payload: 'Test'},
-        ],
-        '[00:00.00]Test',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-  });
-
-  it('supports multiple cues', () => {
-    verifyHelper(
-        [
-          {startTime: 0, endTime: 10, payload: 'Test'},
-          {startTime: 10, endTime: 20, payload: 'Test2'},
-          {startTime: 20, endTime: 22, payload: 'Test3'},
-        ],
-        '[00:00.00]Test\n' +
-        '[00:10.00]Test2\n' +
-        '[00:20.00]Test3',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-  });
-
-  it('supports different time formats', () => {
-    verifyHelper(
-        [
-          {startTime: 0.1, endTime: 10.001, payload: 'Test'},
-          {startTime: 10.001, endTime: 20.02, payload: 'Test2'},
-          {startTime: 20.02, endTime: 30.1, payload: 'Test3'},
-          {startTime: 30.1, endTime: 40.001, payload: 'Test4'},
-          {startTime: 40.001, endTime: 50.02, payload: 'Test5'},
-          {startTime: 50.02, endTime: 52.02, payload: 'Test6'},
-        ],
-        '[00:00.1]Test\n' +
-        '[00:10.001]Test2\n' +
-        '[00:20.02]Test3\n' +
-        '[00:30,1]Test4\n' +
-        '[00:40,001]Test5\n' +
-        '[00:50,02]Test6',
-        {periodStart: 0, segmentStart: 0, segmentEnd: 0, vttOffset: 0});
-  });
-
-  /**
-   * @param {!Array} cues
-   * @param {string} text
-   * @param {shaka.extern.TextParser.TimeContext} time
-   */
-  function verifyHelper(cues, text, time) {
-    const BufferUtils = shaka.util.BufferUtils;
-    const StringUtils = shaka.util.StringUtils;
-
-    const data = BufferUtils.toUint8(StringUtils.toUTF8(text));
-
-    const parser = new shaka.text.LrcTextParser();
-    const result = parser.parseMedia(data, time);
-
-    const expected = cues.map((cue) => {
-      if (cue.nestedCues) {
-        cue.nestedCues = cue.nestedCues.map(
-            (nestedCue) => jasmine.objectContaining(nestedCue));
-      }
-      return jasmine.objectContaining(cue);
-    });
-    expect(result).toEqual(expected);
-  }
-});