rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023022200

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, {
@@ -125,21 +125,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();
     });
   }
 
@@ -192,7 +193,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
   }
 
   private _onFatalError(err : unknown) {
-    if (this._initCanceller.isUsed) {
+    if (this._initCanceller.isUsed()) {
       return;
     }
     this._initCanceller.cancel();
@@ -206,13 +207,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 =
@@ -227,9 +224,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();
@@ -238,7 +234,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 });
@@ -246,7 +241,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 });
@@ -254,7 +248,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
             }
           })
           .catch((err) => {
-            if (mediaSourceCanceller.isUsed) {
+            if (mediaSourceCanceller.isUsed()) {
               return;
             }
             this._onFatalError(err);
@@ -311,7 +305,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                                             initCanceller.signal);
 
     this.trigger("manifestReady", manifest);
-    if (initCanceller.isUsed) {
+    if (initCanceller.isUsed()) {
       return ;
     }
 
@@ -359,15 +353,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) {
+        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,
@@ -376,7 +371,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                          newCanceller);
           })
           .catch((err) => {
-            if (newCanceller.isUsed) {
+            if (newCanceller.isUsed()) {
               return;
             }
             onFatalError(err);
@@ -431,7 +426,7 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
                                 (err) => this.trigger("warning", err),
                                 cancelSignal);
 
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return;
     }
 
@@ -483,7 +478,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);
@@ -519,7 +514,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
           }
 
@@ -560,7 +555,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,
@@ -570,7 +565,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);
@@ -584,7 +579,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);
@@ -615,7 +610,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
             }
           }
@@ -674,7 +669,8 @@ export default class MediaSourceContentInitializer extends ContentInitializer {
     });
     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);
       }

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

@@ -112,7 +112,7 @@ export default class ContentTimeBoundariesObserver
 
     manifest.addEventListener("manifestUpdate", () => {
       this.trigger("durationUpdate", getManifestDuration());
-      if (cancelSignal.isCancelled) {
+      if (cancelSignal.isCancelled()) {
         return;
       }
       this._checkEndOfStream();
@@ -161,7 +161,7 @@ export default class ContentTimeBoundariesObserver
         }
       }
     }
-    if (this._canceller.isUsed) {
+    if (this._canceller.isUsed()) {
       return;
     }
     if (adaptation === null) {

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);
   });
 }

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

@@ -70,7 +70,8 @@ export default function triggerEndOfStream(
 
   log.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
 
-  const innerCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const innerCanceller = new TaskCanceller();
+  innerCanceller.linkToSignal(cancelSignal);
   for (const sourceBuffer of updatingSourceBuffers) {
     onSourceBufferUpdate(sourceBuffer, () => {
       innerCanceller.cancel();
@@ -94,10 +95,12 @@ export function maintainEndOfStream(
   mediaSource : MediaSource,
   cancelSignal : CancellationSignal
 ) : void {
-  let endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  let endOfStreamCanceller = new TaskCanceller();
+  endOfStreamCanceller.linkToSignal(cancelSignal);
   onSourceOpen(mediaSource, () => {
     endOfStreamCanceller.cancel();
-    endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    endOfStreamCanceller = new TaskCanceller();
+    endOfStreamCanceller.linkToSignal(cancelSignal);
     triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
   }, cancelSignal);
   triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);

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

@@ -43,7 +43,8 @@ export default function getLoadedReference(
   isDirectfile : boolean,
   cancelSignal : CancellationSignal
 ) : IReadOnlySharedReference<boolean> {
-  const listenCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const listenCanceller = new TaskCanceller();
+  listenCanceller.linkToSignal(cancelSignal);
   const isLoaded = createSharedReference(false, listenCanceller.signal);
   playbackObserver.listen((observation) => {
     if (observation.rebuffering !== null ||

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

@@ -90,7 +90,7 @@ export default function performInitialSeekAndPlay(
     onLoadedMetadata();
   }
 
-  cancelSignal.register((err : CancellationError) => {
+  const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
     mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
     rejectAutoPlay(err);
   });
@@ -112,7 +112,7 @@ export default function performInitialSeekAndPlay(
                                    "falsely announced having loaded the content.");
       onWarning(error);
     }
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
       return ;
     }
 
@@ -136,6 +136,7 @@ export default function performInitialSeekAndPlay(
       }
       initialPlayPerformed.setValue(true);
       initialPlayPerformed.finish();
+      deregisterCancellation();
       return resolveAutoPlay({ type: "skipped" as const });
     }
 
@@ -143,19 +144,22 @@ export default function performInitialSeekAndPlay(
     try {
       playResult = mediaElement.play() ?? Promise.resolve();
     } catch (playError) {
+      deregisterCancellation();
       return rejectAutoPlay(playError);
     }
     playResult
       .then(() => {
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return;
         }
         initialPlayPerformed.setValue(true);
         initialPlayPerformed.finish();
+        deregisterCancellation();
         return resolveAutoPlay({ type: "autoplay" as const });
       })
       .catch((playError : unknown) => {
-        if (cancelSignal.isCancelled) {
+        deregisterCancellation();
+        if (cancelSignal.isCancelled()) {
           return;
         }
         if (playError instanceof Error && playError.name === "NotAllowedError") {
@@ -167,7 +171,7 @@ export default function performInitialSeekAndPlay(
                                        "Cannot trigger auto-play automatically: " +
                                        "your browser does not allow it.");
           onWarning(error);
-          if (cancelSignal.isCancelled) {
+          if (cancelSignal.isCancelled()) {
             return;
           }
           return resolveAutoPlay({ type: "autoplay-blocked" as const });

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

@@ -82,7 +82,8 @@ export default function initializeContentDecryption(
     return ref;
   }
 
-  const decryptorCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+  const decryptorCanceller = new TaskCanceller();
+  decryptorCanceller.linkToSignal(cancelSignal);
   const drmStatusRef = createSharedReference<IDrmInitializationStatus>({
     initializationState: { type: "uninitialized", value: null },
     drmSystemId: undefined,

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

@@ -67,7 +67,8 @@ export default class MediaDurationUpdater {
                                                                this._canceller.signal);
 
     /** TaskCanceller triggered each time the MediaSource open status changes. */
-    let msUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+    let msUpdateCanceller = new TaskCanceller();
+    msUpdateCanceller.linkToSignal(this._canceller.signal);
 
     isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged,
                                  { emitCurrentValue: true,
@@ -79,18 +80,17 @@ export default class MediaDurationUpdater {
       if (!isMediaSourceOpened.getValue()) {
         return;
       }
-      msUpdateCanceller = new TaskCanceller({ cancelOn: canceller.signal });
+      msUpdateCanceller = new TaskCanceller();
+      msUpdateCanceller.linkToSignal(canceller.signal);
 
-      /** TaskCanceller triggered each time the content's duration may have change */
-      let durationChangeCanceller = new TaskCanceller({
-        cancelOn: msUpdateCanceller.signal,
-      });
+      /** TaskCanceller triggered each time the content's duration may have changed */
+      let durationChangeCanceller = new TaskCanceller();
+      durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
 
       const reSetDuration = () => {
         durationChangeCanceller.cancel();
-        durationChangeCanceller = new TaskCanceller({
-          cancelOn: msUpdateCanceller.signal,
-        });
+        durationChangeCanceller = new TaskCanceller();
+        durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
         onDurationMayHaveChanged(durationChangeCanceller.signal);
       };
 
@@ -112,10 +112,12 @@ export default class MediaDurationUpdater {
       );
 
       /** TaskCanceller triggered each time SourceBuffers' updating status changes */
-      let sourceBuffersUpdatingCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+      let sourceBuffersUpdatingCanceller = new TaskCanceller();
+      sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
       return areSourceBuffersUpdating.onUpdate((areUpdating) => {
         sourceBuffersUpdatingCanceller.cancel();
-        sourceBuffersUpdatingCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        sourceBuffersUpdatingCanceller = new TaskCanceller();
+        sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
         if (areUpdating) {
           return;
         }
@@ -173,20 +175,23 @@ function setMediaSourceDuration(
 
   if (newDuration === undefined) {
     if (manifest.isDynamic) {
-      const maxPotentialPos = manifest.getLivePosition() ??
-                              manifest.getMaximumSafePosition();
-      // Some targets poorly support setting a very high number for durations.
-      // Yet, in dynamic contents, we would prefer setting a value as high as possible
-      // to still be able to seek anywhere we want to (even ahead of the Manifest if
-      // we want to). As such, we put it at a safe default value of 2^32 excepted
-      // when the maximum position is already relatively close to that value, where
-      // we authorize exceptionally going over it.
-      newDuration =  Math.max(Math.pow(2, 32), maxPotentialPos + YEAR_IN_SECONDS);
+      newDuration = manifest.getLivePosition() ??
+                    manifest.getMaximumSafePosition();
     } else {
       newDuration = manifest.getMaximumSafePosition();
     }
   }
 
+  if (manifest.isDynamic) {
+    // Some targets poorly support setting a very high number for durations.
+    // Yet, in dynamic contents, we would prefer setting a value as high as possible
+    // to still be able to seek anywhere we want to (even ahead of the Manifest if
+    // we want to). As such, we put it at a safe default value of 2^32 excepted
+    // when the maximum position is already relatively close to that value, where
+    // we authorize exceptionally going over it.
+    newDuration =  Math.max(Math.pow(2, 32), newDuration + YEAR_IN_SECONDS);
+  }
+
   let maxBufferedEnd : number = 0;
   for  (let i = 0; i < mediaSource.sourceBuffers.length; i++) {
     const sourceBuffer = mediaSource.sourceBuffers[i];

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

@@ -56,13 +56,15 @@ export default function streamEventsEmitter(
   }, cancelSignal);
 
   let isPollingEvents = false;
-  let cancelCurrentPolling = new TaskCanceller({ cancelOn: cancelSignal });
+  let cancelCurrentPolling = new TaskCanceller();
+  cancelCurrentPolling.linkToSignal(cancelSignal);
 
   scheduledEventsRef.onUpdate(({ length: scheduledEventsLength }) => {
     if (scheduledEventsLength === 0) {
       if (isPollingEvents) {
         cancelCurrentPolling.cancel();
-        cancelCurrentPolling = new TaskCanceller({ cancelOn: cancelSignal });
+        cancelCurrentPolling = new TaskCanceller();
+        cancelCurrentPolling.linkToSignal(cancelSignal);
         isPollingEvents = false;
       }
       return;
@@ -161,7 +163,7 @@ export default function streamEventsEmitter(
         } else {
           onEventSkip(event.value);
         }
-        if (stopSignal.isCancelled) {
+        if (stopSignal.isCancelled()) {
           return;
         }
       }
@@ -172,7 +174,7 @@ export default function streamEventsEmitter(
         if (typeof event.onExit === "function") {
           event.onExit();
         }
-        if (stopSignal.isCancelled) {
+        if (stopSignal.isCancelled()) {
           return;
         }
       }

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

@@ -28,7 +28,7 @@ export default function listenToMediaError(
   onError : (error : MediaError) => void,
   cancelSignal : CancellationSignal
 ) : void {
-  if (cancelSignal.isCancelled) {
+  if (cancelSignal.isCancelled()) {
     return;
   }
 

package/src/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.ts

@@ -24,6 +24,7 @@ import { getLoggableSegmentId } from "../../../../manifest";
 import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
 import { toUint8Array } from "../../../../utils/byte_parsing";
+import createCancellablePromise from "../../../../utils/create_cancellable_promise";
 import hashBuffer from "../../../../utils/hash_buffer";
 import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
@@ -369,15 +370,15 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
     operation : ISBOperation<BufferSource>,
     cancellationSignal : CancellationSignal
   ) : Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (cancellationSignal.cancellationError !== null) {
-        return reject(cancellationSignal.cancellationError);
-      }
+    return createCancellablePromise(cancellationSignal, (resolve, reject) => {
       const shouldRestartQueue = this._queue.length === 0 &&
                                  this._pendingTask === null;
       const queueItem = objectAssign({ resolve, reject }, operation);
       this._queue.push(queueItem);
-      cancellationSignal.register((error : CancellationError) => {
+      if (shouldRestartQueue) {
+        this._flush();
+      }
+      return () => {
         // Remove the corresponding element from the AudioVideoSegmentBuffer's
         // queue.
         // If the operation was a pending task, it should still continue to not
@@ -388,12 +389,7 @@ export default class AudioVideoSegmentBuffer extends SegmentBuffer {
         }
         queueItem.resolve = noop;
         queueItem.reject = noop;
-        reject(error);
-      });
-
-      if (shouldRestartQueue) {
-        this._flush();
-      }
+      };
     });
   }
 

package/src/core/segment_buffers/implementations/text/html/html_text_segment_buffer.ts

@@ -353,7 +353,8 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
                                element : HTMLElement; } => cue.resolution !== null);
 
     if (proportionalCues.length > 0) {
-      this._sizeUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+      this._sizeUpdateCanceller = new TaskCanceller();
+      this._sizeUpdateCanceller.linkToSignal(this._canceller.signal);
       const { TEXT_TRACK_SIZE_CHECKS_INTERVAL } = config.getCurrent();
       // update propertionally-sized elements periodically
       const heightWidthRef = onHeightWidthChange(this._textTrackElement,
@@ -382,7 +383,8 @@ export default class HTMLTextSegmentBuffer extends SegmentBuffer {
 
     const startAutoRefresh = () => {
       stopAutoRefresh();
-      autoRefreshCanceller = new TaskCanceller({ cancelOn: cancellationSignal });
+      autoRefreshCanceller = new TaskCanceller();
+      autoRefreshCanceller.linkToSignal(cancellationSignal);
       const intervalId = setInterval(() => this.refreshSubtitles(),
                                      MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
       autoRefreshCanceller.signal.register(() => {

package/src/core/segment_buffers/segment_buffers_store.ts

@@ -17,10 +17,8 @@
 import { MediaError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
-import {
-  CancellationError,
-  CancellationSignal,
-} from "../../utils/task_canceller";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   AudioVideoSegmentBuffer,
   IBufferType,
@@ -194,21 +192,26 @@ export default class SegmentBuffersStore {
     if (this._areNativeBuffersUsable()) {
       return Promise.resolve();
     }
-    return new Promise((res, rej) => {
-      const onAddedOrDisabled = () => {
+    return createCancellablePromise(cancelWaitSignal, (res) => {
+      /* eslint-disable-next-line prefer-const */
+      let onAddedOrDisabled : () => void;
+
+      const removeCallback = () => {
+        const indexOf = this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
+        if (indexOf >= 0) {
+          this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
+        }
+      };
+
+      onAddedOrDisabled = () => {
         if (this._areNativeBuffersUsable()) {
+          removeCallback();
           res();
         }
       };
       this._onNativeBufferAddedOrDisabled.push(onAddedOrDisabled);
 
-      cancelWaitSignal.register((error : CancellationError) => {
-        const indexOf = this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
-        if (indexOf >= 0) {
-          this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
-        }
-        rej(error);
-      });
+      return removeCallback;
     });
   }