rx-player 4.0.0-beta.0 → 4.0.0-beta.2

package/src/core/fetchers/segment/task_prioritizer.ts

@@ -1,5 +1,6 @@
 import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import TaskCanceller, {
   CancellationError,
   CancellationSignal,
@@ -64,19 +65,34 @@ export default class TaskPrioritizer<T> {
     cancelSignal: CancellationSignal
   ): Promise<T> {
     let newTask: IPrioritizerTask<T>;
-
-    return new Promise<T>((resolve, reject) => {
+    return createCancellablePromise<T>(cancelSignal, (resolve, reject) => {
       /** Function allowing to start the underlying Promise. */
       const trigger = () => {
         if (newTask.hasEnded) {
-          unregisterCancelSignal();
           return;
         }
-        const interrupter =  new TaskCanceller({ cancelOn: cancelSignal });
+        const finishTask = () => {
+          unlinkInterrupter();
+          this._endTask(newTask);
+        };
+
+        const onResolve = (value: T) => {
+          callbacks.beforeEnded();
+          finishTask();
+          resolve(value);
+        };
+
+        const onReject = (err: unknown) => {
+          finishTask();
+          reject(err);
+        };
+
+        const interrupter =  new TaskCanceller();
+        const unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
         newTask.interrupter = interrupter;
         interrupter.signal.register(() => {
           newTask.interrupter = null;
-          if (!cancelSignal.isCancelled) {
+          if (!cancelSignal.isCancelled()) {
             callbacks.beforeInterrupted();
           }
         });
@@ -89,8 +105,8 @@ export default class TaskPrioritizer<T> {
         newTask.taskFn(interrupter.signal)
           .then(onResolve)
           .catch((err) => {
-            if (!cancelSignal.isCancelled &&
-                interrupter.isUsed &&
+            if (!cancelSignal.isCancelled() &&
+                interrupter.isUsed() &&
                 err instanceof CancellationError)
             {
               return;
@@ -99,29 +115,6 @@ export default class TaskPrioritizer<T> {
           });
       };
 
-      const unregisterCancelSignal = cancelSignal.register(
-        (cancellationError: CancellationError) => {
-          this._endTask(newTask);
-          reject(cancellationError);
-        }
-      );
-
-      const finishTask = () => {
-        unregisterCancelSignal();
-        this._endTask(newTask);
-      };
-
-      const onResolve = (value: T) => {
-        callbacks.beforeEnded();
-        finishTask();
-        resolve(value);
-      };
-
-      const onReject = (err: unknown) => {
-        finishTask();
-        reject(err);
-      };
-
       newTask = {
         hasEnded: false,
         priority,
@@ -146,6 +139,8 @@ export default class TaskPrioritizer<T> {
           this._interruptCancellableTasks();
         }
       }
+
+      return () => this._endTask(newTask);
     });
   }
 

package/src/core/fetchers/utils/schedule_request.ts

@@ -266,7 +266,7 @@ export async function scheduleRequestWithCdns<T>(
   async function retryWithNextCdn(prevRequestError : unknown) : Promise<T> {
     const nextCdn = getCdnToRequest();
 
-    if (cancellationSignal.isCancelled) {
+    if (cancellationSignal.isCancelled()) {
       throw cancellationSignal.cancellationError;
     }
 
@@ -275,7 +275,7 @@ export async function scheduleRequestWithCdns<T>(
     }
 
     onRetry(prevRequestError);
-    if (cancellationSignal.isCancelled) {
+    if (cancellationSignal.isCancelled()) {
       throw cancellationSignal.cancellationError;
     }
 
@@ -309,26 +309,37 @@ export async function scheduleRequestWithCdns<T>(
       return requestCdn(nextWantedCdn);
     }
 
-    const canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+    const canceller = new TaskCanceller();
+    const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
     return new Promise<T>((res, rej) => {
       /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
       cdnPrioritizer?.addEventListener("priorityChange", () => {
         const updatedPrioritaryCdn = getCdnToRequest();
-        if (cancellationSignal.isCancelled) {
+        if (cancellationSignal.isCancelled()) {
           throw cancellationSignal.cancellationError;
         }
         if (updatedPrioritaryCdn === undefined) {
-          return rej(prevRequestError);
+          return cleanAndReject(prevRequestError);
         }
         if (updatedPrioritaryCdn !== nextWantedCdn) {
           canceller.cancel();
           waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-            .then(res, rej);
+            .then(cleanAndResolve, cleanAndReject);
         }
       }, canceller.signal);
 
       cancellableSleep(blockedFor, canceller.signal)
-        .then(() => requestCdn(nextWantedCdn).then(res, rej), noop);
+        .then(() => requestCdn(nextWantedCdn)
+          .then(cleanAndResolve, cleanAndReject), noop);
+
+      function cleanAndResolve(response : T) {
+        unlinkCanceller();
+        res(response);
+      }
+      function cleanAndReject(err : unknown) {
+        unlinkCanceller();
+        rej(err);
+      }
     });
   }
 

package/src/core/init/directfile_content_initializer.ts

@@ -84,6 +84,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
      * events when it cannot, as well as "unstalled" events when it get out of one.
      */
     const rebufferingController = new RebufferingController(playbackObserver,
+                                                            null,
                                                             null,
                                                             speed);
     rebufferingController.addEventListener("stalled", (evt) =>
@@ -167,7 +168,7 @@ export default class DirectFileContentInitializer extends ContentInitializer {
             }
           }, { emitCurrentValue: true, clearSignal: cancelSignal }))
       .catch((err) => {
-        if (!cancelSignal.isCancelled) {
+        if (!cancelSignal.isCancelled()) {
           this._onFatalError(err);
         }
       });

package/src/core/init/media_source_content_initializer.ts

@@ -25,13 +25,13 @@ import {
 } from "../../public_types";
 import { ITransportPipelines } from "../../transports";
 import assert from "../../utils/assert";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import objectAssign from "../../utils/object_assign";
 import createSharedReference, {
   IReadOnlySharedReference,
   ISharedReference,
 } from "../../utils/reference";
 import TaskCanceller, {
-  CancellationError,
   CancellationSignal,
 } from "../../utils/task_canceller";
 import AdaptiveRepresentationSelector, {
@@ -67,7 +67,7 @@ import getInitialTime, {
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaDurationUpdater from "./utils/media_duration_updater";
+import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
 import RebufferingController from "./utils/rebuffering_controller";
 import streamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
@@ -124,21 +124,22 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     if (this._initialManifestProm !== null) {
       return;
     }
-    this._initialManifestProm = new Promise((res, rej) => {
-      this._initCanceller.signal.register((err : CancellationError) => {
-        this._manifestFetcher.dispose();
-        rej(err);
-      });
-      this._manifestFetcher.addEventListener("warning", (err : IPlayerError) =>
-        this.trigger("warning", err));
-      this._manifestFetcher.addEventListener("error", (err : unknown) => {
-        this.trigger("error", err);
-        rej(err);
-      });
-      this._manifestFetcher.addEventListener("manifestReady", (manifest) => {
-        res(manifest);
+    this._initialManifestProm = createCancellablePromise(
+      this._initCanceller.signal,
+      (res, rej) => {
+        this._manifestFetcher.addEventListener("warning", (err : IPlayerError) =>
+          this.trigger("warning", err));
+        this._manifestFetcher.addEventListener("error", (err : unknown) => {
+          this.trigger("error", err);
+          rej(err);
+        });
+        this._manifestFetcher.addEventListener("manifestReady", (manifest) => {
+          res(manifest);
+        });
       });
-      this._manifestFetcher.start();
+    this._manifestFetcher.start();
+    this._initCanceller.signal.register(() => {
+      this._manifestFetcher.dispose();
     });
   }
 
@@ -191,7 +192,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   private _onFatalError(err : unknown) {
-    if (this._initCanceller.isUsed) {
+    if (this._initCanceller.isUsed()) {
       return;
     }
     this._initCanceller.cancel();
@@ -205,13 +206,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 drmSystemId : string | undefined;
                 unlinkMediaSource : TaskCanceller; }>
   {
-    return new Promise((resolve, reject) => {
+    const initCanceller = this._initCanceller;
+    return createCancellablePromise(initCanceller.signal, (resolve) => {
       const { keySystems } = this._settings;
-      const initCanceller = this._initCanceller;
-
-      const unregisterReject = initCanceller.signal.register((err) => {
-        reject(err);
-      });
 
       /** Initialize decryption capabilities. */
       const drmInitRef =
@@ -226,9 +223,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         }
         stopListeningToDrmUpdates();
 
-        const mediaSourceCanceller = new TaskCanceller({
-          cancelOn: initCanceller.signal,
-        });
+        const mediaSourceCanceller = new TaskCanceller();
+        mediaSourceCanceller.linkToSignal(initCanceller.signal);
         openMediaSource(mediaElement, mediaSourceCanceller.signal)
           .then((mediaSource) => {
             const lastDrmStatus = drmInitRef.getValue();
@@ -237,7 +233,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
               drmInitRef.onUpdate((newDrmStatus, stopListeningToDrmUpdatesAgain) => {
                 if (newDrmStatus.initializationState.type === "initialized") {
                   stopListeningToDrmUpdatesAgain();
-                  unregisterReject();
                   resolve({ mediaSource,
                             drmSystemId: newDrmStatus.drmSystemId,
                             unlinkMediaSource: mediaSourceCanceller });
@@ -245,7 +240,6 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                 }
               }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
             } else if (drmStatus.initializationState.type === "initialized") {
-              unregisterReject();
               resolve({ mediaSource,
                         drmSystemId: drmStatus.drmSystemId,
                         unlinkMediaSource: mediaSourceCanceller });
@@ -253,7 +247,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             }
           })
           .catch((err) => {
-            if (mediaSourceCanceller.isUsed) {
+            if (mediaSourceCanceller.isUsed()) {
               return;
             }
             this._onFatalError(err);
@@ -307,7 +301,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                                             initCanceller.signal);
 
     this.trigger("manifestReady", manifest);
-    if (initCanceller.isUsed) {
+    if (initCanceller.isUsed()) {
       return ;
     }
 
@@ -355,15 +349,16 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                         autoPlay : boolean; }
       ) : void {
         currentCanceller.cancel();
-        if (initCanceller.isUsed) {
+        if (initCanceller.isUsed()) {
           return;
         }
-        triggerEvent("reloadingMediaSource", null);
-        if (initCanceller.isUsed) {
+        triggerEvent("reloadingMediaSource", reloadOrder);
+        if (initCanceller.isUsed()) {
           return;
         }
 
-        const newCanceller = new TaskCanceller({ cancelOn: initCanceller.signal });
+        const newCanceller = new TaskCanceller();
+        newCanceller.linkToSignal(initCanceller.signal);
         openMediaSource(mediaElement, newCanceller.signal)
           .then(newMediaSource => {
             recursivelyLoadOnMediaSource(newMediaSource,
@@ -372,7 +367,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                          newCanceller);
           })
           .catch((err) => {
-            if (newCanceller.isUsed) {
+            if (newCanceller.isUsed()) {
               return;
             }
             onFatalError(err);
@@ -427,7 +422,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                 (err) => this.trigger("warning", err),
                                 cancelSignal);
 
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
 
@@ -453,9 +448,20 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
     const rebufferingController = this._createRebufferingController(playbackObserver,
                                                                     manifest,
+                                                                    segmentBuffersStore,
                                                                     speed,
                                                                     cancelSignal);
-
+    rebufferingController.addEventListener("needsReload", () => {
+      // NOTE couldn't both be always calculated at event destination?
+      // Maybe there are exceptions?
+      const position = initialSeekPerformed.getValue() ?
+        playbackObserver.getCurrentTime() :
+        initialTime;
+      const autoplay = initialPlayPerformed.getValue() ?
+        !playbackObserver.getIsPaused() :
+        autoPlay;
+      onReloadOrder({ position, autoPlay: autoplay });
+    }, cancelSignal);
     const contentTimeBoundariesObserver = this
       ._createContentTimeBoundariesObserver(manifest,
                                             mediaSource,
@@ -479,7 +485,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
           }, { emitCurrentValue: true, clearSignal: cancelSignal });
       })
       .catch((err) => {
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return; // Current loading cancelled, no need to trigger the error
         }
         this._onFatalError(err);
@@ -503,8 +509,36 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
      */
     function handleStreamOrchestratorCallbacks() : IStreamOrchestratorCallbacks {
       return {
-        needsBufferFlush: () =>
-          playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001),
+        needsBufferFlush: () => {
+          const seekedTime = mediaElement.currentTime + 0.001;
+          playbackObserver.setCurrentTime(seekedTime);
+
+          // Seek again once data begins to be buffered.
+          // This is sadly necessary on some browsers to avoid decoding
+          // issues after a flush.
+          //
+          // NOTE: there's in theory a potential race condition in the following
+          // logic as the callback could be called when media data is still
+          // being removed by the browser - which is an asynchronous process.
+          // The following condition checking for buffered data could thus lead
+          // to a false positive where we're actually checking previous data.
+          // For now, such scenario is avoided by setting the
+          // `includeLastObservation` option to `false` and calling
+          // `needsBufferFlush` once MSE media removal operations have been
+          // explicitely validated by the browser, but that's a complex and easy
+          // to break system.
+          playbackObserver.listen((obs, stopListening) => {
+            if (
+              // Data is buffered around the current position
+              obs.currentRange !== null ||
+              // Or, for whatever reason, playback is already advancing
+              obs.position > seekedTime + 0.1
+            ) {
+              stopListening();
+              playbackObserver.setCurrentTime(obs.position + 0.001);
+            }
+          }, { includeLastObservation: false, clearSignal: cancelSignal });
+        },
 
         streamStatusUpdate(value) {
           // Announce discontinuities if found
@@ -515,7 +549,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             discontinuity: imminentDiscontinuity,
             position,
           });
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
 
@@ -556,7 +590,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         adaptationChange: (value) => {
           self.trigger("adaptationChange", value);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
           contentTimeBoundariesObserver.onAdaptationChange(value.type,
@@ -566,7 +600,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         representationChange: (value) => {
           self.trigger("representationChange", value);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
           contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
@@ -580,7 +614,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
 
         periodStreamCleared: (value) => {
           contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return; // Previous call has stopped streams due to a side-effect
           }
           self.trigger("periodStreamCleared", value);
@@ -611,7 +645,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         encryptionDataEncountered: (value) => {
           for (const protectionData of value) {
             protectionRef.setValue(protectionData);
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
               return; // Previous call has stopped streams due to a side-effect
             }
           }
@@ -645,9 +679,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     cancelSignal : CancellationSignal
   ) : ContentTimeBoundariesObserver {
     /** Maintains the MediaSource's duration up-to-date with the Manifest */
-    const mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
+    const mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
     cancelSignal.register(() => {
-      mediaDurationUpdater.stop();
+      mediaSourceDurationUpdater.stopUpdating();
     });
     /** Allows to cancel a pending `end-of-stream` operation. */
     let endOfStreamCanceller : TaskCanceller | null = null;
@@ -665,12 +699,12 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
       this.trigger("activePeriodChanged", { period });
     });
     contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
-      log.debug("Init: Duration has to be updated.", newDuration);
-      mediaDurationUpdater.updateKnownDuration(newDuration);
+      mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
     });
     contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
       if (endOfStreamCanceller === null) {
-        endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        endOfStreamCanceller = new TaskCanceller();
+        endOfStreamCanceller.linkToSignal(cancelSignal);
         log.debug("Init: end-of-stream order received.");
         maintainEndOfStream(mediaSource, endOfStreamCanceller.signal);
       }
@@ -682,6 +716,9 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
         endOfStreamCanceller = null;
       }
     });
+    const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+    mediaSourceDurationUpdater.updateDuration(currentDuration.duration,
+                                              currentDuration.isEnd);
     return contentTimeBoundariesObserver;
   }
 
@@ -706,11 +743,13 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   private _createRebufferingController(
     playbackObserver : PlaybackObserver,
     manifest : Manifest,
+    segmentBuffersStore : SegmentBuffersStore,
     speed : IReadOnlySharedReference<number>,
     cancelSignal : CancellationSignal
   ) : RebufferingController {
     const rebufferingController = new RebufferingController(playbackObserver,
                                                             manifest,
+                                                            segmentBuffersStore,
                                                             speed);
     // Bubble-up events
     rebufferingController.addEventListener("stalled",

package/src/core/init/types.ts

@@ -120,7 +120,15 @@ export interface IContentInitializerEvents {
    * Event sent when we're starting attach a new MediaSource to the media element
    * (after removing the previous one).
    */
-  reloadingMediaSource: null;
+  reloadingMediaSource: {
+    /** The position we're reloading at, in seconds. */
+    position: number;
+    /**
+     * If `true`, we'll play directly after finishing the reloading operation.
+     * If `false`, we'll be paused after it.
+     */
+    autoPlay: boolean;
+  };
   /** Event sent after the player stalled. */
   stalled : IStallingSituation;
   /** Event sent when the player goes out of a stalling situation. */

package/src/core/init/utils/content_time_boundaries_observer.ts

@@ -111,18 +111,20 @@ export default class ContentTimeBoundariesObserver
     }, { includeLastObservation: true, clearSignal: cancelSignal });
 
     manifest.addEventListener("manifestUpdate", () => {
-      this.trigger("durationUpdate", getManifestDuration());
-      if (cancelSignal.isCancelled) {
+      this.trigger("durationUpdate", this._getManifestDuration());
+      if (cancelSignal.isCancelled()) {
         return;
       }
       this._checkEndOfStream();
     }, cancelSignal);
+  }
 
-    function getManifestDuration() : number | undefined {
-      return manifest.isDynamic ?
-        maximumPositionCalculator.getMaximumAvailablePosition() :
-        maximumPositionCalculator.getEndingPosition();
-    }
+  /**
+   * Returns an estimate of the current duration of the content.
+   * @returns {Object}
+   */
+  public getCurrentDuration() : IDurationItem  {
+    return this._getManifestDuration();
   }
 
   /**
@@ -154,14 +156,17 @@ export default class ContentTimeBoundariesObserver
             this._maximumPositionCalculator
               .updateLastVideoAdaptation(adaptation);
           }
-          const newDuration = this._manifest.isDynamic ?
-            this._maximumPositionCalculator.getMaximumAvailablePosition() :
-            this._maximumPositionCalculator.getEndingPosition();
+          const endingPosition = this._maximumPositionCalculator.getEndingPosition();
+          const newDuration = endingPosition !== undefined ?
+            { isEnd: true,
+              duration: endingPosition } :
+            { isEnd: false,
+              duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
           this.trigger("durationUpdate", newDuration);
         }
       }
     }
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     if (adaptation === null) {
@@ -306,6 +311,15 @@ export default class ContentTimeBoundariesObserver
     }
   }
 
+  private _getManifestDuration() : IDurationItem {
+    const endingPosition = this._maximumPositionCalculator.getEndingPosition();
+    return endingPosition !== undefined ?
+      { isEnd: true,
+        duration: endingPosition } :
+      { isEnd: false,
+        duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+  }
+
   private _lazilyCreateActiveStreamInfo(bufferType : IBufferType) : IActiveStreamsInfo {
     let streamInfo = this._activeStreams.get(bufferType);
     if (streamInfo === undefined) {
@@ -334,6 +348,28 @@ export default class ContentTimeBoundariesObserver
   }
 }
 
+export interface IDurationItem {
+  /**
+   * The new maximum known position (note that this is the ending position
+   * currently known of the current content, it might be superior to the last
+   * position at which segments are available and it might also evolve over
+   * time), in seconds.
+   */
+  duration : number;
+  /**
+   * If `true`, the communicated `duration` is the actual end of the content.
+   * It may still be updated due to a track change or to add precision, but it
+   * is still a (rough) estimate of the maximum position that content should
+   * have.
+   *
+   * If `false`, this is the currently known maximum position associated to
+   * the content, but the content is still evolving (typically, new media
+   * segments are still being generated) and as such it can still have a
+   * longer duration in the future.
+   */
+  isEnd : boolean;
+}
+
 /**
  * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
  * event names and the value is the payload of those events.
@@ -347,7 +383,7 @@ export interface IContentTimeBoundariesObserverEvent {
    * Triggered when the duration of the currently-playing content became known
    * or changed.
    */
-  durationUpdate : number | undefined;
+  durationUpdate : IDurationItem;
   /**
    * Triggered when the last possible chronological segment for all types of
    * buffers has either been pushed or is being pushed to the corresponding

package/src/core/init/utils/create_media_source.ts

@@ -21,10 +21,9 @@ import {
 } from "../../../compat";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
-import TaskCanceller, {
-  CancellationSignal,
-} from "../../../utils/task_canceller";
+import { CancellationSignal } from "../../../utils/task_canceller";
 
 /**
  * Dispose of ressources taken by the MediaSource:
@@ -128,21 +127,10 @@ export default function openMediaSource(
   mediaElement : HTMLMediaElement,
   unlinkSignal : CancellationSignal
 ) : Promise<MediaSource> {
-  return new Promise((resolve, reject) => {
-    let hasResolved = false;
+  return createCancellablePromise(unlinkSignal, (resolve) => {
     const mediaSource = createMediaSource(mediaElement, unlinkSignal);
-    const eventListenerCanceller = new TaskCanceller({ cancelOn: unlinkSignal });
-
     events.onSourceOpen(mediaSource, () => {
-      eventListenerCanceller.cancel();
-      hasResolved = true;
       resolve(mediaSource);
-    }, eventListenerCanceller.signal);
-
-    unlinkSignal.register((error) => {
-      if (!hasResolved) {
-        reject(error);
-      }
-    });
+    }, unlinkSignal);
   });
 }