rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.2022032100

package/src/compat/eme/custom_media_keys/index.ts

@@ -14,15 +14,8 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  Observable,
-  of as observableOf,
-  throwError as observableThrow,
-} from "rxjs";
 import { MediaError } from "../../../errors";
 import assert from "../../../utils/assert";
-import castToObservable from "../../../utils/cast_to_observable";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import { isIE11 } from "../../browser_detection";
 import isNode from "../../is_node";
@@ -47,12 +40,18 @@ import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 /** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
 type ICompatRequestMediaKeySystemAccessFn =
   (keyType : string, config : MediaKeySystemConfiguration[]) =>
-    Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+    Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
 
-let requestMediaKeySystemAccess : null | ICompatRequestMediaKeySystemAccessFn = null;
+let requestMediaKeySystemAccess : ICompatRequestMediaKeySystemAccessFn | null = null;
 
-let _setMediaKeys :
-((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void) =
+/**
+ * Set the given MediaKeys on the given HTMLMediaElement.
+ * Emits null when done then complete.
+ * @param {HTMLMediaElement} elt
+ * @param {Object} mediaKeys
+ */
+let setMediaKeys :
+((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown) =
   function defaultSetMediaKeys(
     mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys | ICustomMediaKeys | null
@@ -92,11 +91,8 @@ let _setMediaKeys :
 if (isNode ||
     (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())
 ) {
-  requestMediaKeySystemAccess = (
-    a : string,
-    b : MediaKeySystemConfiguration[]
-  ) : Observable<MediaKeySystemAccess> =>
-    castToObservable(navigator.requestMediaKeySystemAccess(a, b));
+  requestMediaKeySystemAccess = (...args) =>
+    navigator.requestMediaKeySystemAccess(...args);
 } else {
   let isTypeSupported: (keyType: string) => boolean;
   let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
@@ -106,23 +102,23 @@ if (isNode ||
     const callbacks = getOldKitWebKitMediaKeyCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   // This is for WebKit with prefixed EME api
   } else if (WebKitMediaKeysConstructor !== undefined) {
     const callbacks = getWebKitMediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
     const callbacks = getIE11MediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else if (MozMediaKeysConstructor !== undefined) {
     const callbacks = getMozMediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else {
     const MK = window.MediaKeys as unknown as typeof MediaKeys & {
       isTypeSupported? : (keyType : string) => boolean;
@@ -155,9 +151,9 @@ if (isNode ||
   requestMediaKeySystemAccess = function(
     keyType : string,
     keySystemConfigurations : MediaKeySystemConfiguration[]
-  ) : Observable<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
+  ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
     if (!isTypeSupported(keyType)) {
-      return observableThrow(() => new Error("Unsupported key type"));
+      return Promise.reject(new Error("Unsupported key type"));
     }
 
     for (let i = 0; i < keySystemConfigurations.length; i++) {
@@ -188,7 +184,7 @@ if (isNode ||
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const customMediaKeys = createCustomMediaKeys(keyType);
-        return observableOf(
+        return Promise.resolve(
           new CustomMediaKeySystemAccess(keyType,
                                          customMediaKeys,
                                          keySystemConfigurationResponse)
@@ -196,24 +192,10 @@ if (isNode ||
       }
     }
 
-    return observableThrow(() => new Error("Unsupported configuration"));
+    return Promise.reject(new Error("Unsupported configuration"));
   };
 }
 
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- * @returns {Observable}
- */
-function setMediaKeys(
-  elt : HTMLMediaElement,
-  mediaKeys : MediaKeys|ICustomMediaKeys|null
-) : Observable<unknown> {
-  return observableDefer(() => castToObservable(_setMediaKeys(elt, mediaKeys)));
-}
-
 export {
   requestMediaKeySystemAccess,
   setMediaKeys,

package/src/compat/eme/custom_media_keys/old_webkit_media_keys.ts

@@ -14,16 +14,10 @@
  * limitations under the License.
  */
 
-import {
-  merge as observableMerge,
-  Subject,
-  takeUntil,
-} from "rxjs";
 import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
-import PPromise from "../../../utils/promise";
+import noop from "../../../utils/noop";
 import { utf8ToStr } from "../../../utils/string_parsing";
-import * as events from "../../event_listeners";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
@@ -54,11 +48,16 @@ export function isOldWebkitMediaElement(
     .webkitGenerateKeyRequest === "function";
 }
 
+/**
+ * MediaKeySession implementation for older versions of WebKit relying on APIs
+ * such as `webkitGenerateKeyRequest` `webkitAddKey` to be called on the
+ * HTMLMediaElement.
+ * @class OldWebkitMediaKeySession
+ */
 class OldWebkitMediaKeySession
   extends EventEmitter<IMediaKeySessionEvents>
   implements ICustomMediaKeySession
 {
-  public readonly update: (license: Uint8Array) => Promise<void>;
   public readonly closed: Promise<void>;
   public expiration: number;
   public keyStatuses: ICustomMediaKeyStatusMap;
@@ -66,75 +65,92 @@ class OldWebkitMediaKeySession
 
   private readonly _vid: IOldWebkitHTMLMediaElement;
   private readonly _key: string;
-  private readonly _closeSession$: Subject<void>;
+
+  private readonly _onSessionRelatedEvent : (evt : Event) => void;
+  private _closeSession : () => void;
 
   constructor(mediaElement: IOldWebkitHTMLMediaElement, keySystem: string) {
     super();
-    this._closeSession$ = new Subject();
     this._vid = mediaElement;
     this._key = keySystem;
 
     this.sessionId = "";
-    this.closed = new PPromise((resolve) => {
-      this._closeSession$.subscribe(resolve);
+    this._closeSession = noop; // Just here to make TypeScript happy
+    this.closed = new Promise((resolve) => {
+      this._closeSession = resolve;
     });
     this.keyStatuses = new Map();
     this.expiration = NaN;
 
-    observableMerge(events.onKeyMessage$(mediaElement),
-                    events.onKeyAdded$(mediaElement),
-                    events.onKeyError$(mediaElement))
-      .pipe(takeUntil(this._closeSession$))
-      .subscribe((evt: Event) => this.trigger(evt.type, evt));
-
-    this.update = (license: Uint8Array) => {
-      return new PPromise((resolve, reject) => {
-        try {
-          if (this._key.indexOf("clearkey") >= 0) {
-            const licenseTypedArray =
-              license instanceof ArrayBuffer ? new Uint8Array(license) :
-                                               license;
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-disable @typescript-eslint/no-unsafe-argument */
-            /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-            const json = JSON.parse(utf8ToStr(licenseTypedArray));
-            const key = base64ToBytes(json.keys[0].k);
-            const kid = base64ToBytes(json.keys[0].kid);
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-enable @typescript-eslint/no-unsafe-argument */
-            /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-            resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
-          } else {
-            resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));
-          }
-        } catch (err) {
-          reject(err);
-        }
-      });
+    this._onSessionRelatedEvent = (evt : Event) => {
+      this.trigger(evt.type, evt);
     };
+
+    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+      .forEach(evt => mediaElement.addEventListener(evt, this._onSessionRelatedEvent));
   }
 
-  generateRequest(_initDataType: string, initData: ArrayBuffer): Promise<void> {
-    return new PPromise((resolve) => {
+  public update(license: Uint8Array) : Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        if (this._key.indexOf("clearkey") >= 0) {
+          const licenseTypedArray =
+            license instanceof ArrayBuffer ? new Uint8Array(license) :
+            license;
+          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+          /* eslint-disable @typescript-eslint/no-unsafe-argument */
+          /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+          const json = JSON.parse(utf8ToStr(licenseTypedArray));
+          const key = base64ToBytes(json.keys[0].k);
+          const kid = base64ToBytes(json.keys[0].kid);
+          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+          /* eslint-enable @typescript-eslint/no-unsafe-argument */
+          /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+          resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
+        } else {
+          resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  public generateRequest(
+    _initDataType: string,
+    initData: ArrayBuffer
+  ): Promise<void> {
+    return new Promise((resolve) => {
       this._vid.webkitGenerateKeyRequest(this._key, initData);
       resolve();
     });
   }
 
-  close(): Promise<void> {
-    return new PPromise((resolve) => {
-      this._closeSession$.next();
-      this._closeSession$.complete();
+  public close(): Promise<void> {
+    return new Promise((resolve) => {
+      this._unbindSession();
+      this._closeSession();
       resolve();
     });
   }
 
-  load(): Promise<boolean> {
-    return PPromise.resolve(false);
+  /**
+   * Load a Persistent MediaKeySession.
+   * Do nothing here because this implementation doesn't handle them.
+   * @returns {Promise.<boolean>}
+   */
+  public load(): Promise<boolean> {
+    // Not implemented. Always return false as in "no session with that id".
+    return Promise.resolve(false);
+  }
+
+  public remove(): Promise<void> {
+    return Promise.resolve();
   }
 
-  remove(): Promise<void> {
-    return PPromise.resolve();
+  private _unbindSession() {
+    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+      .forEach(evt => this._vid.removeEventListener(evt, this._onSessionRelatedEvent));
   }
 }
 

package/src/compat/eme/custom_media_keys/webkit_media_keys.ts

@@ -14,15 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  merge as observableMerge,
-  Subject,
-  takeUntil,
-} from "rxjs";
 import EventEmitter from "../../../utils/event_emitter";
-import PPromise from "../../../utils/promise";
+import noop from "../../../utils/noop";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
-import * as events from "../../event_listeners";
 import getWebKitFairplayInitData from "../get_webkit_fairplay_initdata";
 import {
   ICustomMediaKeys,
@@ -80,17 +74,19 @@ class WebkitMediaKeySession
   extends EventEmitter<IMediaKeySessionEvents>
   implements ICustomMediaKeySession
 {
-  public readonly update: (license: Uint8Array) => Promise<void>;
   public readonly closed: Promise<void>;
   public expiration: number;
   public keyStatuses: ICustomMediaKeyStatusMap;
 
   private readonly _videoElement: HTMLMediaElement;
-  private readonly _closeSession$: Subject<void>;
   private readonly _keyType: string;
   private _nativeSession: undefined | MediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
+  private readonly _onEvent : (evt : Event) => void;
+  private _closeSession : () => void;
+  private _unbindSession : () => void;
+
   /**
    * @param {HTMLMediaElement} mediaElement
    * @param {string} keyType
@@ -103,60 +99,47 @@ class WebkitMediaKeySession
   ) {
     super();
     this._serverCertificate = serverCertificate;
-    this._closeSession$ = new Subject();
     this._videoElement = mediaElement;
     this._keyType = keyType;
 
-    this.closed = new PPromise((resolve) => {
-      this._closeSession$.subscribe(resolve);
+    this._unbindSession = noop;
+    this._closeSession = noop; // Just here to make TypeScript happy
+    this.closed = new Promise((resolve) => {
+      this._closeSession = resolve;
     });
     this.keyStatuses = new Map();
     this.expiration = NaN;
 
-    this.update = (license: BufferSource) => {
-      return new PPromise((resolve, reject) => {
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        if (this._nativeSession === undefined ||
-            this._nativeSession.update === undefined ||
-            typeof this._nativeSession.update !== "function") {
-          return reject("Unavailable WebKit key session.");
-        }
-        try {
-          let uInt8Arraylicense: Uint8Array;
-          if (license instanceof ArrayBuffer) {
-            uInt8Arraylicense = new Uint8Array(license);
-          } else if (license instanceof Uint8Array) {
-            uInt8Arraylicense = license;
-          } else {
-            uInt8Arraylicense = new Uint8Array(license.buffer);
-          }
-          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          resolve(this._nativeSession.update(uInt8Arraylicense));
-          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-        } catch (err) {
-          reject(err);
-        }
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      });
+    this._onEvent = (evt : Event) => {
+      this.trigger(evt.type, evt);
     };
   }
 
-  listenEvent(session: MediaKeySession) {
-    observableMerge(events.onKeyMessage$(session),
-                    events.onKeyAdded$(session),
-                    events.onKeyError$(session))
-      .pipe(takeUntil(this._closeSession$))
-      .subscribe((evt: Event) => {
-        this.trigger(evt.type, evt);
-      });
+  public update(license: BufferSource) : Promise<void> {
+    return new Promise((resolve, reject) => {
+      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+      if (this._nativeSession === undefined ||
+          this._nativeSession.update === undefined ||
+          typeof this._nativeSession.update !== "function") {
+        return reject("Unavailable WebKit key session.");
+      }
+      try {
+        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        resolve(this._nativeSession.update(license));
+        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      } catch (err) {
+        reject(err);
+      }
+      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+    });
   }
 
-  generateRequest(
+  public generateRequest(
     _initDataType: string,
     initData: ArrayBuffer
   ): Promise<void> {
-    return new PPromise((resolve) => {
+    return new Promise((resolve) => {
       const elt = this._videoElement as ICompatHTMLMediaElement;
       if (elt.webkitKeys?.createSession === undefined) {
         throw new Error("No WebKitMediaKeys API.");
@@ -178,17 +161,17 @@ class WebkitMediaKeySession
       if (keySession === undefined || keySession === null) {
         throw new Error("Impossible to get the key sessions");
       }
-      this.listenEvent(keySession);
+      this._listenEvent(keySession);
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       this._nativeSession = keySession;
       resolve();
     });
   }
 
-  close(): Promise<void> {
-    return new PPromise((resolve, reject) => {
-      this._closeSession$.next();
-      this._closeSession$.complete();
+  public close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this._unbindSession();
+      this._closeSession();
       if (this._nativeSession === undefined) {
         reject("No session to close.");
         return;
@@ -201,11 +184,11 @@ class WebkitMediaKeySession
   }
 
   load(): Promise<boolean> {
-    return PPromise.resolve(false);
+    return Promise.resolve(false);
   }
 
   remove(): Promise<void> {
-    return PPromise.resolve();
+    return Promise.resolve();
   }
 
   get sessionId(): string {
@@ -215,6 +198,24 @@ class WebkitMediaKeySession
     /* eslint-enable @typescript-eslint/no-unsafe-member-access */
     /* eslint-enable @typescript-eslint/no-unsafe-return */
   }
+
+  private _listenEvent(session: MediaKeySession) : void {
+    this._unbindSession(); // If previous session was linked
+
+    /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-disable @typescript-eslint/no-unsafe-return */
+    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+      .forEach(evt => session.addEventListener(evt, this._onEvent));
+
+    this._unbindSession = () => {
+      ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+        .forEach(evt => session.removeEventListener(evt, this._onEvent));
+    };
+    /* eslint-disable @typescript-eslint/no-unsafe-return */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-enable @typescript-eslint/no-unsafe-call */
+  }
 }
 
 class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
@@ -251,7 +252,7 @@ class WebKitCustomMediaKeys implements ICustomWebKitMediaKeys {
 
   setServerCertificate(serverCertificate: Uint8Array): Promise<void> {
     this._serverCertificate = serverCertificate;
-    return PPromise.resolve();
+    return Promise.resolve();
   }
 }
 

package/src/compat/eme/generate_key_request.ts

@@ -14,18 +14,12 @@
  * limitations under the License.
  */
 
-import {
-  catchError,
-  defer as observableDefer,
-  Observable,
-} from "rxjs";
 import log from "../../log";
 import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
 import {
   be4toi,
   concat,
 } from "../../utils/byte_parsing";
-import castToObservable from "../../utils/cast_to_observable";
 import { PSSH_TO_INTEGER } from "./constants";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 
@@ -136,37 +130,35 @@ export function patchInitData(initData : Uint8Array) : Uint8Array {
  * "encrypted" event for the corresponding request.
  * @param {string} sessionType - Type of session you want to generate. Consult
  * EME Specification for more information on session types.
- * @returns {Observable} - Emit when done. Errors if fails.
+ * @returns {Promise} - Emit when done. Errors if fails.
  */
 export default function generateKeyRequest(
   session: MediaKeySession|ICustomMediaKeySession,
   initializationDataType : string | undefined,
   initializationData : Uint8Array
-) : Observable<unknown> {
-  return observableDefer(() => {
-    log.debug("Compat: Calling generateRequest on the MediaKeySession");
-    let patchedInit : Uint8Array;
-    try {
-      patchedInit = patchInitData(initializationData);
-    } catch (_e) {
-      patchedInit = initializationData;
-    }
-    const initDataType = initializationDataType ?? "";
-    return castToObservable(session.generateRequest(initDataType, patchedInit))
-      .pipe(catchError(error => {
-        if (initDataType !== "" || !(error instanceof TypeError)) {
-          throw error;
-        }
+) : Promise<unknown> {
+  log.debug("Compat: Calling generateRequest on the MediaKeySession");
+  let patchedInit : Uint8Array;
+  try {
+    patchedInit = patchInitData(initializationData);
+  } catch (_e) {
+    patchedInit = initializationData;
+  }
+  const initDataType = initializationDataType ?? "";
+  return session.generateRequest(initDataType, patchedInit)
+    .catch((error) => {
+      if (initDataType !== "" || !(error instanceof TypeError)) {
+        throw error;
+      }
 
-        // On newer EME versions of the specification, the initialization data
-        // type given to generateRequest cannot be an empty string (it returns
-        // a rejected promise with a TypeError in that case).
-        // Retry with a default "cenc" value for initialization data type if
-        // we're in that condition.
-        log.warn("Compat: error while calling `generateRequest` with an empty " +
-                 "initialization data type. Retrying with a default \"cenc\" value.",
-                 error);
-        return castToObservable(session.generateRequest("cenc", patchedInit));
-      }));
-  });
+      // On newer EME versions of the specification, the initialization data
+      // type given to generateRequest cannot be an empty string (it returns
+      // a rejected promise with a TypeError in that case).
+      // Retry with a default "cenc" value for initialization data type if
+      // we're in that condition.
+      log.warn("Compat: error while calling `generateRequest` with an empty " +
+               "initialization data type. Retrying with a default \"cenc\" value.",
+               error);
+      return session.generateRequest("cenc", patchedInit);
+    });
 }

package/src/compat/eme/load_session.ts

@@ -14,20 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  map,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  race as observableRace,
-  take,
-  timer as observableTimer,
-} from "rxjs";
 import log from "../../log";
-import castToObservable from "../../utils/cast_to_observable";
-import tryCatch from "../../utils/rx-try_catch";
-import { onKeyStatusesChange$ } from "../event_listeners";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 
 const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
@@ -46,26 +33,36 @@ const EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES = 100;
  * @param {string} sessionId
  * @returns {Observable}
  */
-export default function loadSession(
+export default async function loadSession(
   session : MediaKeySession | ICustomMediaKeySession,
   sessionId : string
-) : Observable<boolean> {
-  return observableDefer(() => {
-    log.info("Compat/EME: Load persisted session", sessionId);
-    return tryCatch<undefined, boolean>(() => castToObservable(session.load(sessionId)),
-                                        undefined);
-  }).pipe(mergeMap((isLoaded : boolean) : Observable<boolean> => {
-    if (!isLoaded || session.keyStatuses.size > 0) {
-      return observableOf(isLoaded);
+) : Promise<boolean> {
+  log.info("Compat/DRM: Load persisted session", sessionId);
+  const isLoaded = await session.load(sessionId);
+
+  if (!isLoaded || session.keyStatuses.size > 0) {
+    return isLoaded;
+  }
+
+  // A browser race condition can exist, seen for example in some
+  // Chromium/Chrome versions where the `keyStatuses` property from a loaded
+  // MediaKeySession would not be populated directly as the load answer but
+  // asynchronously after.
+  return new Promise((resolve) => {
+    (session as MediaKeySession).addEventListener("keystatuseschange",
+                                                  resolveWithLoadedStatus);
+    const timeout = setTimeout(resolveWithLoadedStatus,
+                               EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES);
+
+    function resolveWithLoadedStatus() {
+      cleanUp();
+      resolve(isLoaded);
     }
 
-    // A browser race condition can exist, seen for example in some
-    // Chromium/Chrome versions where the `keyStatuses` property from a loaded
-    // MediaKeySession would not be populated directly as the load answer but
-    // asynchronously after.
-    return observableRace(
-      observableTimer(EME_WAITING_DELAY_LOADED_SESSION_EMPTY_KEYSTATUSES),
-      onKeyStatusesChange$(session)
-    ).pipe(take(1), map(() => isLoaded));
-  }));
+    function cleanUp() {
+      clearTimeout(timeout);
+      (session as MediaKeySession).removeEventListener("keystatuseschange",
+                                                       resolveWithLoadedStatus);
+    }
+  });
 }