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

package/src/transports/utils/call_custom_manifest_loader.ts

@@ -62,7 +62,7 @@ export default function callCustomManifestLoader(
                                  receivingTime? : number | undefined;
                                  sendingTime? : number | undefined; }) =>
       {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -87,7 +87,7 @@ export default function callCustomManifestLoader(
        * @param {*} err - The corresponding error encountered
        */
       const reject = (err : unknown) : void => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;
@@ -113,7 +113,7 @@ export default function callCustomManifestLoader(
        * the "regular" implementation
        */
       const fallback = () => {
-        if (hasFinished || cancelSignal.isCancelled) {
+        if (hasFinished || cancelSignal.isCancelled()) {
           return;
         }
         hasFinished = true;

package/src/typings/globals.d.ts

@@ -33,6 +33,7 @@ declare const __FEATURES__ : {
   HTML_VTT : number;
   LOCAL_MANIFEST : number;
   METAPLAYLIST : number;
+  DEBUG_ELEMENT : number;
   NATIVE_SAMI : number;
   NATIVE_SRT : number;
   NATIVE_TTML : number;
@@ -54,6 +55,7 @@ declare const enum FEATURES_ENUM {
   HTML_VTT,
   LOCAL_MANIFEST,
   METAPLAYLIST,
+  DEBUG_ELEMENT,
   NATIVE_SAMI,
   NATIVE_SRT,
   NATIVE_TTML,

package/src/utils/cancellable_sleep.ts

@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-import {
-  CancellationError,
-  CancellationSignal,
-} from "./task_canceller";
+import createCancellablePromise from "./create_cancellable_promise";
+import { CancellationSignal } from "./task_canceller";
 
 /**
  * Wait the given `delay`, resolving the Promise when finished.
@@ -36,15 +34,8 @@ export default function cancellableSleep(
   delay: number,
   cancellationSignal: CancellationSignal
 ) : Promise<void> {
-  return new Promise((res, rej) => {
-    const timeout = setTimeout(() => {
-      unregisterCancelSignal();
-      res();
-    }, delay);
-    const unregisterCancelSignal = cancellationSignal
-      .register(function onCancel(cancellationError : CancellationError) {
-        clearTimeout(timeout);
-        rej(cancellationError);
-      });
+  return createCancellablePromise(cancellationSignal, (res) => {
+    const timeout = setTimeout(() => res(), delay);
+    return () => clearTimeout(timeout);
   });
 }

package/src/utils/create_cancellable_promise.ts

@@ -0,0 +1,69 @@
+import {
+  CancellationError,
+  CancellationSignal,
+} from "./task_canceller";
+
+/**
+ * Returns a Promise linked to a `CancellationSignal`, which will reject the
+ * corresponding `CancellationError` if that signal emits before the wanted
+ * task finishes (either on success or on error).
+ *
+ * The given callback mimicks the Promise interface with the added possibility
+ * of returning a callback which will be called when and if the task is
+ * cancelled before being either resolved or rejected.
+ * In that case, that logic will be called just before the Promise is rejected
+ * with the corresponding `CancellationError`.
+ * The point of this callback is to implement aborting logic, such as for
+ * example aborting a request.
+ *
+ * @param {Object} cancellationSignal - The `CancellationSignal` the returned
+ * Promise will be linked to.
+ * @param {Function} cb - The function implementing the cancellable Promise. Its
+ * arguments follow Promise's semantics but it can also return a function which
+ * will be called when and if `cancellationSignal` emits before either arguments
+ * are called.
+ * @returns {Promise} - The created Promise, which will resolve when and if the
+ * first argument to `cb` is called first and reject either if the second
+ * argument to `cb` is called first or if the given `CancellationSignal` emits
+ * before either of the two previous conditions.
+ */
+export default function createCancellablePromise<T>(
+  cancellationSignal : CancellationSignal,
+  cb : (
+    resolve : (val : T) => void,
+    reject : (err : unknown) => void,
+  ) => (() => void) | void
+) : Promise<T> {
+  let abortingLogic : (() => void) | void;
+  return new Promise((res, rej) => {
+    if (cancellationSignal.cancellationError !== null) {
+      // If the signal was already triggered before, do not even call `cb`
+      return rej(cancellationSignal.cancellationError);
+    }
+
+    let hasUnregistered = false;
+    abortingLogic = cb(
+      function onCancellablePromiseSuccess(val : T) {
+        cancellationSignal.deregister(onCancellablePromiseCancellation);
+        hasUnregistered = true;
+        res(val);
+      },
+      function onCancellablePromiseFailure(err : unknown) {
+        cancellationSignal.deregister(onCancellablePromiseCancellation);
+        hasUnregistered = true;
+        rej(err);
+      }
+    );
+
+    if (!hasUnregistered) {
+      cancellationSignal.register(onCancellablePromiseCancellation);
+    }
+
+    function onCancellablePromiseCancellation(error : CancellationError) {
+      if (abortingLogic !== undefined) {
+        abortingLogic();
+      }
+      rej(error);
+    }
+  });
+}

package/src/utils/reference.ts

@@ -294,6 +294,9 @@ export default function createSharedReference<T>(
       options.clearSignal.register(unlisten);
 
       function unlisten() : void {
+        if (options?.clearSignal !== undefined) {
+          options.clearSignal.deregister(unlisten);
+        }
         if (cbObj.hasBeenCleared) {
           return;
         }
@@ -339,6 +342,9 @@ export default function createSharedReference<T>(
     finish,
   };
   function finish() {
+    if (cancelSignal !== undefined) {
+      cancelSignal.deregister(finish);
+    }
     isFinished = true;
     const clonedCbs = cbs.slice();
     for (const cbObj of clonedCbs) {

package/src/utils/request/xhr.ts

@@ -125,7 +125,7 @@ export default function request<T>(
           reject(err);
         });
 
-      if (cancelSignal.isCancelled) {
+      if (cancelSignal.isCancelled()) {
         return;
       }
     }

package/src/utils/task_canceller.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import log from "../log";
 import assert from "./assert";
 import noop from "./noop";
 
@@ -120,12 +121,12 @@ export default class TaskCanceller {
    * notified that it should be aborted when this `TaskCanceller` is triggered
    * (through its `cancel` method).
    */
-  public signal : CancellationSignal;
+  public readonly signal : CancellationSignal;
   /**
    * `true` if this `TaskCanceller` has already been triggered.
    * `false` otherwise.
    */
-  public isUsed : boolean;
+  private _isUsed : boolean;
   /**
    * @private
    * Internal function called when the `TaskCanceller` is triggered`.
@@ -136,28 +137,43 @@ export default class TaskCanceller {
    * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
    * as its `signal` provide.
    * You can then pass this property to async task you wish to be cancellable.
-   * @param {Object|undefined} options
    */
-  constructor(options? : {
-    /**
-     * If set the TaskCanceller created here will automatically be triggered
-     * when that signal emits.
-     */
-    cancelOn? : CancellationSignal | undefined;
-  } | undefined) {
+  constructor() {
     const [trigger, register] = createCancellationFunctions();
-    this.isUsed = false;
+    this._isUsed = false;
     this._trigger = trigger;
     this.signal = new CancellationSignal(register);
+  }
 
-    if (options?.cancelOn !== undefined) {
-      const unregisterParent = options.cancelOn.register(() => {
-        this.cancel();
-      });
-      this.signal.register(unregisterParent);
-    }
+  /**
+   * Returns `true` if this `TaskCanceller` has already been triggered.
+   * `false` otherwise.
+   */
+  public isUsed() : boolean {
+    return this._isUsed;
   }
 
+  /**
+   * Bind this `TaskCanceller` to a `CancellationSignal`, so the former
+   * is automatically cancelled when the latter is triggered.
+   *
+   * Note that this call registers a callback on the given signal, until either
+   * the current `TaskCanceller` is cancelled or until this given
+   * `CancellationSignal` is triggered.
+   * To avoid leaking memory, the returned callback allow to undo this link.
+   * It should be called if/when that link is not needed anymore, such as when
+   * there is no need for this `TaskCanceller` anymore.
+   *
+   * @param {Object} signal
+   * @returns {Function}
+   */
+  public linkToSignal(signal : CancellationSignal) : () => void {
+    const unregister = signal.register(() => {
+      this.cancel();
+    });
+    this.signal.register(unregister);
+    return unregister;
+  }
 
   /**
    * "Trigger" the `TaskCanceller`, notify through its associated
@@ -171,10 +187,10 @@ export default class TaskCanceller {
    * @param {Error} [srcError]
    */
   public cancel(srcError? : CancellationError) : void {
-    if (this.isUsed) {
+    if (this._isUsed) {
       return ;
     }
-    this.isUsed = true;
+    this._isUsed = true;
     const cancellationError = srcError ?? new CancellationError();
     this._trigger(cancellationError);
   }
@@ -196,11 +212,6 @@ export default class TaskCanceller {
  * @class
  */
 export class CancellationSignal {
-  /**
-   * True when the cancellation order was already triggered, meaning that the
-   * linked task needs to be aborted.
-   */
-  public isCancelled : boolean;
   /**
    * Error associated to the cancellation, only set if the `CancellationSignal`
    * has been used (which means that the task has been cancelled).
@@ -220,6 +231,12 @@ export class CancellationSignal {
    */
   private _listeners : Array<(error : CancellationError) => void>;
 
+  /**
+   * True when the cancellation order was already triggered, meaning that the
+   * linked task needs to be aborted.
+   */
+  private _isCancelled : boolean;
+
   /**
    * Creates a new CancellationSignal.
    * /!\ Note: Only a `TaskCanceller` is supposed to be able to create one.
@@ -227,20 +244,35 @@ export class CancellationSignal {
    * cancelled.
    */
   constructor(registerToSource : (listener: ICancellationListener) => void) {
-    this.isCancelled = false;
+    this._isCancelled = false;
     this.cancellationError = null;
     this._listeners = [];
 
     registerToSource((cancellationError : CancellationError) : void => {
       this.cancellationError = cancellationError;
-      this.isCancelled = true;
+      this._isCancelled = true;
       while (this._listeners.length > 0) {
-        const listener = this._listeners.splice(this._listeners.length - 1, 1)[0];
-        listener(cancellationError);
+        try {
+          const listener = this._listeners.pop();
+          listener?.(cancellationError);
+        } catch (err) {
+          log.error("Error while calling clean up listener",
+                    err instanceof Error ? err.toString() :
+                                           "Unknown error");
+        }
       }
     });
   }
 
+  /**
+   * Returns `true` when the cancellation order was already triggered, meaning
+   * that the linked task needs to be aborted.
+   * @returns boolean
+   */
+  public isCancelled() : boolean {
+    return this._isCancelled;
+  }
+
   /**
    * Registers a function that will be called when/if the current task is
    * cancelled.
@@ -263,9 +295,10 @@ export class CancellationSignal {
    * performed.
    */
   public register(fn : ICancellationListener) : () => void {
-    if (this.isCancelled) {
+    if (this._isCancelled) {
       assert(this.cancellationError !== null);
       fn(this.cancellationError);
+      return noop;
     }
     this._listeners.push(fn);
     return () => this.deregister(fn);
@@ -280,13 +313,9 @@ export class CancellationSignal {
    * @param {Function} fn
    */
   public deregister(fn : ICancellationListener) : void {
-    if (this.isCancelled) {
-      return;
-    }
-    for (let i = 0; i < this._listeners.length; i++) {
+    for (let i = this._listeners.length - 1; i >= 0; i--) {
       if (this._listeners[i] === fn) {
         this._listeners.splice(i, 1);
-        return;
       }
     }
   }