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

package/src/core/decrypt/create_or_load_session.ts

@@ -0,0 +1,130 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ICustomMediaKeySession } from "../../compat";
+import log from "../../log";
+import { CancellationSignal } from "../../utils/task_canceller";
+import createSession from "./create_session";
+import {
+  IProcessedProtectionData,
+  IMediaKeySessionStores,
+  MediaKeySessionLoadingType,
+} from "./types";
+import cleanOldLoadedSessions from "./utils/clean_old_loaded_sessions";
+import isSessionUsable from "./utils/is_session_usable";
+import KeySessionRecord from "./utils/key_session_record";
+
+/**
+ * Handle MediaEncryptedEvents sent by a HTMLMediaElement:
+ * Either create a MediaKeySession, recuperate a previous MediaKeySession or
+ * load a persistent session.
+ *
+ * Some previously created MediaKeySession can be closed in this process to
+ * respect the maximum limit of concurrent MediaKeySession, as defined by the
+ * `EME_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS` config property.
+ *
+ * You can refer to the events emitted to know about the current situation.
+ * @param {Object} initializationData
+ * @param {Object} stores
+ * @param {string} wantedSessionType
+ * @param {number} maxSessionCacheSize
+ * @param {Object} cancelSignal
+ * @returns {Promise}
+ */
+export default async function createOrLoadSession(
+  initializationData : IProcessedProtectionData,
+  stores : IMediaKeySessionStores,
+  wantedSessionType : MediaKeySessionType,
+  maxSessionCacheSize : number,
+  cancelSignal : CancellationSignal
+) : Promise<ICreateOrLoadSessionResult> {
+  /** Store previously-loaded compatible MediaKeySession, if one. */
+  let previousLoadedSession : MediaKeySession |
+                              ICustomMediaKeySession |
+                              null = null;
+
+  const { loadedSessionsStore, persistentSessionsStore } = stores;
+  const entry = loadedSessionsStore.reuse(initializationData);
+  if (entry !== null) {
+    previousLoadedSession = entry.mediaKeySession;
+    if (isSessionUsable(previousLoadedSession)) {
+      log.info("DRM: Reuse loaded session", previousLoadedSession.sessionId);
+      return { type: MediaKeySessionLoadingType.LoadedOpenSession,
+               value: { mediaKeySession: previousLoadedSession,
+                        sessionType: entry.sessionType,
+                        keySessionRecord: entry.keySessionRecord } };
+    } else if (persistentSessionsStore !== null) {
+      // If the session is not usable anymore, we can also remove it from the
+      // PersistentSessionsStore.
+      // TODO Are we sure this is always what we want?
+      if (entry.mediaKeySession.sessionId !== "") {
+        persistentSessionsStore.delete(entry.mediaKeySession.sessionId);
+      }
+    }
+  }
+
+  if (previousLoadedSession !== null) {
+    await loadedSessionsStore.closeSession(previousLoadedSession);
+    if (cancelSignal.cancellationError !== null) {
+      throw cancelSignal.cancellationError; // stop here if cancelled since
+    }
+  }
+
+  await cleanOldLoadedSessions(loadedSessionsStore, maxSessionCacheSize);
+  if (cancelSignal.cancellationError !== null) {
+    throw cancelSignal.cancellationError; // stop here if cancelled since
+  }
+
+  const evt = await createSession(stores, initializationData, wantedSessionType);
+  return { type: evt.type,
+           value: { mediaKeySession: evt.value.mediaKeySession,
+                    sessionType: evt.value.sessionType,
+                    keySessionRecord: evt.value.keySessionRecord } };
+}
+
+/** Information concerning a MediaKeySession. */
+export interface IMediaKeySessionContext {
+  /** The MediaKeySession itself. */
+  mediaKeySession : MediaKeySession |
+                    ICustomMediaKeySession;
+  /** The type of MediaKeySession (e.g. "temporary"). */
+  sessionType : MediaKeySessionType;
+  /** `KeySessionRecord` assiociated to this MediaKeySession. */
+  keySessionRecord : KeySessionRecord;
+}
+
+/** Event emitted when a new MediaKeySession has been created. */
+export interface ICreatedSession {
+  type : MediaKeySessionLoadingType.Created;
+  value : IMediaKeySessionContext;
+}
+
+/** Event emitted when an already-loaded MediaKeySession is used. */
+export interface ILoadedOpenSession {
+  type : MediaKeySessionLoadingType.LoadedOpenSession;
+  value : IMediaKeySessionContext;
+}
+
+/** Event emitted when a persistent MediaKeySession has been loaded. */
+export interface ILoadedPersistentSessionEvent {
+  type : MediaKeySessionLoadingType.LoadedPersistentSession;
+  value : IMediaKeySessionContext;
+}
+
+/** Every possible result returned by `createOrLoadSession`. */
+export type ICreateOrLoadSessionResult = ICreatedSession |
+                                         ILoadedOpenSession |
+                                         ILoadedPersistentSessionEvent;

package/src/core/decrypt/create_session.ts

@@ -0,0 +1,174 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  ICustomMediaKeySession,
+  loadSession,
+} from "../../compat";
+import log from "../../log";
+import {
+  IProcessedProtectionData,
+  IMediaKeySessionStores,
+  MediaKeySessionLoadingType,
+} from "./types";
+import isSessionUsable from "./utils/is_session_usable";
+import KeySessionRecord from "./utils/key_session_record";
+import LoadedSessionsStore from "./utils/loaded_sessions_store";
+import PersistentSessionsStore from "./utils/persistent_sessions_store";
+
+/**
+ * Create a new Session or load a persistent one on the given MediaKeys,
+ * according to wanted settings and what is currently stored.
+ *
+ * If session creating fails, remove the oldest MediaKeySession loaded and
+ * retry.
+ *
+ * /!\ This only creates new sessions.
+ * It will fail if loadedSessionsStore already has a MediaKeySession with
+ * the given initialization data.
+ * @param {Object} stores
+ * @param {Object} initData
+ * @param {string} wantedSessionType
+ * @returns {Promise}
+ */
+export default function createSession(
+  stores : IMediaKeySessionStores,
+  initData : IProcessedProtectionData,
+  wantedSessionType : MediaKeySessionType
+) : Promise<ICreateSessionEvent> {
+  const { loadedSessionsStore,
+          persistentSessionsStore } = stores;
+
+  if (wantedSessionType === "temporary") {
+    return createTemporarySession(loadedSessionsStore, initData);
+  } else if (persistentSessionsStore === null) {
+    log.warn("DRM: Cannot create persistent MediaKeySession, " +
+             "PersistentSessionsStore not created.");
+    return createTemporarySession(loadedSessionsStore, initData);
+  }
+  return createAndTryToRetrievePersistentSession(loadedSessionsStore,
+                                                 persistentSessionsStore,
+                                                 initData);
+}
+
+/**
+ * Create a new temporary MediaKeySession linked to the given initData and
+ * initDataType.
+ * @param {Object} loadedSessionsStore
+ * @param {Object} initData
+ * @returns {Promise}
+ */
+function createTemporarySession(
+  loadedSessionsStore : LoadedSessionsStore,
+  initData : IProcessedProtectionData
+) : Promise<INewSessionCreatedEvent> {
+  log.info("DRM: Creating a new temporary session");
+  const entry = loadedSessionsStore.createSession(initData, "temporary");
+  return Promise.resolve({ type: MediaKeySessionLoadingType.Created,
+                           value: entry });
+}
+
+/**
+ * Create a persistent MediaKeySession and try to load on it a previous
+ * MediaKeySession linked to the same initialization data.
+ * @param {Object} loadedSessionsStore
+ * @param {Object} persistentSessionsStore
+ * @param {Object} initData
+ * @returns {Promise}
+ */
+async function createAndTryToRetrievePersistentSession(
+  loadedSessionsStore : LoadedSessionsStore,
+  persistentSessionsStore : PersistentSessionsStore,
+  initData : IProcessedProtectionData
+) : Promise<INewSessionCreatedEvent | IPersistentSessionRecoveryEvent> {
+  log.info("DRM: Creating persistent MediaKeySession");
+
+  const entry = loadedSessionsStore.createSession(initData, "persistent-license");
+  const storedEntry = persistentSessionsStore.getAndReuse(initData);
+  if (storedEntry === null) {
+    return { type: MediaKeySessionLoadingType.Created,
+             value: entry };
+  }
+
+  try {
+    const hasLoadedSession = await loadSession(entry.mediaKeySession,
+                                               storedEntry.sessionId);
+    if (!hasLoadedSession) {
+      log.warn("DRM: No data stored for the loaded session");
+      persistentSessionsStore.delete(storedEntry.sessionId);
+      return { type: MediaKeySessionLoadingType.Created,
+               value: entry };
+    }
+
+    if (hasLoadedSession && isSessionUsable(entry.mediaKeySession)) {
+      persistentSessionsStore.add(initData, initData.keyIds, entry.mediaKeySession);
+      log.info("DRM: Succeeded to load persistent session.");
+      return { type: MediaKeySessionLoadingType.LoadedPersistentSession,
+               value: entry };
+    }
+
+    // Unusable persistent session: recreate a new session from scratch.
+    log.warn("DRM: Previous persistent session not usable anymore.");
+    return recreatePersistentSession();
+  } catch (err) {
+    log.warn("DRM: Unable to load persistent session: " +
+             (err instanceof Error ? err.toString() :
+                                     "Unknown Error"));
+    return recreatePersistentSession();
+  }
+
+  /**
+   * Helper function to close and restart the current persistent session
+   * considered, and re-create it from scratch.
+   * @returns {Observable}
+   */
+  async function recreatePersistentSession() : Promise<INewSessionCreatedEvent> {
+    log.info("DRM: Removing previous persistent session.");
+    const persistentEntry = persistentSessionsStore.get(initData);
+    if (persistentEntry !== null) {
+      persistentSessionsStore.delete(persistentEntry.sessionId);
+    }
+
+    await loadedSessionsStore.closeSession(entry.mediaKeySession);
+    const newEntry = loadedSessionsStore.createSession(initData,
+                                                       "persistent-license");
+    return { type: MediaKeySessionLoadingType.Created,
+             value: newEntry };
+  }
+}
+
+export interface INewSessionCreatedEvent {
+  type : MediaKeySessionLoadingType.Created;
+  value : {
+    mediaKeySession : MediaKeySession |
+                      ICustomMediaKeySession;
+    sessionType : MediaKeySessionType;
+    keySessionRecord : KeySessionRecord;
+  };
+}
+
+export interface IPersistentSessionRecoveryEvent {
+  type : MediaKeySessionLoadingType.LoadedPersistentSession;
+  value : {
+    mediaKeySession : MediaKeySession |
+                      ICustomMediaKeySession;
+    sessionType : MediaKeySessionType;
+    keySessionRecord : KeySessionRecord;
+  };
+}
+
+export type ICreateSessionEvent = INewSessionCreatedEvent |
+                                  IPersistentSessionRecoveryEvent;

package/src/core/decrypt/dispose_decryption_resources.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { setMediaKeys } from "../../compat";
+import log from "../../log";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+
+/**
+ * Free up all ressources taken by the content decryption logic.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Promise}
+ */
+export default async function disposeDecryptionResources(
+  mediaElement : HTMLMediaElement
+) : Promise<void> {
+  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  if (currentState === null) {
+    return ;
+  }
+
+  log.info("DRM: Disposing of the current MediaKeys");
+  const { loadedSessionsStore } = currentState;
+  MediaKeysInfosStore.clearState(mediaElement);
+  await loadedSessionsStore.closeAllSessions();
+  setMediaKeys(mediaElement, null);
+}

package/src/core/{eme → decrypt}/find_key_system.ts

@@ -14,14 +14,6 @@
  * limitations under the License.
  */
 
-import {
-  catchError,
-  defer as observableDefer,
-  map,
-  Observable,
-  of as observableOf,
-  throwError as observableThrow,
-} from "rxjs";
 import {
   ICustomMediaKeySystemAccess,
   requestMediaKeySystemAccess,
@@ -32,8 +24,9 @@ import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import arrayIncludes from "../../utils/array_includes";
 import flatMap from "../../utils/flat_map";
-import MediaKeysInfosStore from "./media_keys_infos_store";
+import { CancellationSignal } from "../../utils/task_canceller";
 import { IKeySystemOption } from "./types";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 type MediaKeysRequirement = "optional" |
                             "required" |
@@ -65,8 +58,6 @@ interface IKeySystemType { keyName : string | undefined;
                            keyType : string;
                            keySystemOptions : IKeySystemOption; }
 
-const { EME_DEFAULT_WIDEVINE_ROBUSTNESSES,
-        EME_KEY_SYSTEMS } = config;
 
 /**
  * @param {Array.<Object>} keySystems
@@ -121,6 +112,7 @@ function checkCachedMediaKeySystemAccess(
  * @returns {string|undefined} - Either the canonical name, or undefined.
  */
 function findKeySystemCanonicalName(ksType: string) : string | undefined {
+  const { EME_KEY_SYSTEMS } = config.getCurrent();
   for (const ksName of Object.keys(EME_KEY_SYSTEMS)) {
     if (arrayIncludes(EME_KEY_SYSTEMS[ksName] as string[], ksType)) {
       return ksName;
@@ -158,6 +150,7 @@ function buildKeySystemConfigurations(
   if (keySystem.distinctiveIdentifierRequired === true) {
     distinctiveIdentifier = "required";
   }
+  const { EME_DEFAULT_WIDEVINE_ROBUSTNESSES } = config.getCurrent();
 
   // Set robustness, in order of consideration:
   //   1. the user specified its own robustnesses
@@ -235,128 +228,124 @@ function buildKeySystemConfigurations(
 /**
  * Try to find a compatible key system from the keySystems array given.
  *
- * Returns an Observable which, when subscribed to, will request a
- * MediaKeySystemAccess based on the various keySystems provided. This
- * Observable will:
- *   - emit the MediaKeySystemAccess and the keySystems as an object, when
- *     found. The object is under this form:
- *     {
- *       keySystemAccess {MediaKeySystemAccess}
- *       keySystem {Object}
- *     }
- *   - complete immediately after emitting.
- *   - throw if no  compatible key system has been found.
+ * This function will request a MediaKeySystemAccess based on the various
+ * keySystems provided.
+ *
+ * This Promise might either:
+ *   - resolves the MediaKeySystemAccess and the keySystems as an object, when
+ *     found.
+ *   - reject if no compatible key system has been found.
  *
  * @param {HTMLMediaElement} mediaElement
  * @param {Array.<Object>} keySystems - The keySystems you want to test.
- * @returns {Observable}
+ * @param {Object} cancelSignal
+ * @returns {Promise.<Object>}
  */
 export default function getMediaKeySystemAccess(
   mediaElement : HTMLMediaElement,
-  keySystemsConfigs: IKeySystemOption[]
-) : Observable<IFoundMediaKeySystemAccessEvent> {
-  return observableDefer<Observable<IFoundMediaKeySystemAccessEvent>>(() => {
-    log.info("EME: Searching for compatible MediaKeySystemAccess");
-    const currentState = MediaKeysInfosStore.getState(mediaElement);
-    if (currentState != null) {
-      // Fast way to find a compatible keySystem if the currently loaded
-      // one as exactly the same compatibility options.
-      const cachedKeySystemAccess =
-        checkCachedMediaKeySystemAccess(keySystemsConfigs,
-                                        currentState.mediaKeySystemAccess,
-                                        currentState.keySystemOptions);
-      if (cachedKeySystemAccess !== null) {
-        log.info("EME: Found cached compatible keySystem");
-        return observableOf({
-          type: "reuse-media-key-system-access" as const,
-          value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-                   options: cachedKeySystemAccess.keySystemOptions },
-        });
-      }
+  keySystemsConfigs: IKeySystemOption[],
+  cancelSignal : CancellationSignal
+) : Promise<IFoundMediaKeySystemAccessEvent> {
+  log.info("DRM: Searching for compatible MediaKeySystemAccess");
+  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  if (currentState != null) {
+    // Fast way to find a compatible keySystem if the currently loaded
+    // one as exactly the same compatibility options.
+    const cachedKeySystemAccess =
+      checkCachedMediaKeySystemAccess(keySystemsConfigs,
+                                      currentState.mediaKeySystemAccess,
+                                      currentState.keySystemOptions);
+    if (cachedKeySystemAccess !== null) {
+      log.info("DRM: Found cached compatible keySystem");
+      return Promise.resolve({
+        type: "reuse-media-key-system-access" as const,
+        value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
+                 options: cachedKeySystemAccess.keySystemOptions },
+      });
     }
+  }
 
-    /**
-     * Array of set keySystems for this content.
-     * Each item of this array is an object containing the following keys:
-     *   - keyName {string}: keySystem canonical name (e.g. "widevine")
-     *   - keyType {string}: keySystem type (e.g. "com.widevine.alpha")
-     *   - keySystem {Object}: the original keySystem object
-     * @type {Array.<Object>}
-     */
-    const keySystemsType: IKeySystemType[] = keySystemsConfigs.reduce(
-      (arr: IKeySystemType[], keySystemOptions) => {
-
-        const managedRDNs = EME_KEY_SYSTEMS[keySystemOptions.type];
-        let ksType;
-
-        if (managedRDNs != null) {
-          ksType = managedRDNs.map((keyType) => {
-            const keyName = keySystemOptions.type;
-            return { keyName, keyType, keySystemOptions };
-          });
-        }
-        else {
-          const keyName = findKeySystemCanonicalName(keySystemOptions.type);
-          const keyType = keySystemOptions.type;
-          ksType = [{ keyName, keyType, keySystemOptions }];
-        }
-
-        return arr.concat(ksType);
+  /**
+   * Array of set keySystems for this content.
+   * Each item of this array is an object containing the following keys:
+   *   - keyName {string}: keySystem canonical name (e.g. "widevine")
+   *   - keyType {string}: keySystem type (e.g. "com.widevine.alpha")
+   *   - keySystem {Object}: the original keySystem object
+   * @type {Array.<Object>}
+   */
+  const keySystemsType: IKeySystemType[] = keySystemsConfigs.reduce(
+    (arr: IKeySystemType[], keySystemOptions) => {
+
+      const { EME_KEY_SYSTEMS } = config.getCurrent();
+      const managedRDNs = EME_KEY_SYSTEMS[keySystemOptions.type];
+      let ksType;
+
+      if (managedRDNs != null) {
+        ksType = managedRDNs.map((keyType) => {
+          const keyName = keySystemOptions.type;
+          return { keyName, keyType, keySystemOptions };
+        });
       }
-      , []);
-
-    return recursivelyTestKeySystems(0);
-
-    /**
-     * Test all key system configuration stored in `keySystemsType` one by one
-     * recursively.
-     * Returns an Observable which emit the MediaKeySystemAccess if one was
-     * found compatible with one of the configurations or just throws if none
-     * were found to be compatible.
-     * @param {Number} index - The index in `keySystemsType` to start from.
-     * Should be set to `0` when calling directly.
-     * @returns {Observable}
-     */
-    function recursivelyTestKeySystems(
-      index : number
-    ) : Observable<IFoundMediaKeySystemAccessEvent> {
-      // if we iterated over the whole keySystemsType Array, quit on error
-      if (index >= keySystemsType.length) {
-        const error = new EncryptedMediaError("INCOMPATIBLE_KEYSYSTEMS",
-                                              "No key system compatible with your " +
-                                              "wanted configuration has been found " +
-                                              "in the current browser.");
-        return observableThrow(() => error);
+      else {
+        const keyName = findKeySystemCanonicalName(keySystemOptions.type);
+        const keyType = keySystemOptions.type;
+        ksType = [{ keyName, keyType, keySystemOptions }];
       }
 
-      if (requestMediaKeySystemAccess == null) {
-        const error = Error("requestMediaKeySystemAccess is not " +
-                            "implemented in your browser.");
-        return observableThrow(() => error);
-      }
+      return arr.concat(ksType);
+    }
+    , []);
+
+  return recursivelyTestKeySystems(0);
+
+  /**
+   * Test all key system configuration stored in `keySystemsType` one by one
+   * recursively.
+   * Returns a Promise which will emit the MediaKeySystemAccess if one was
+   * found compatible with one of the configurations or just reject if none
+   * were found to be compatible.
+   * @param {Number} index - The index in `keySystemsType` to start from.
+   * Should be set to `0` when calling directly.
+   * @returns {Promise.<Object>}
+   */
+  async function recursivelyTestKeySystems(
+    index : number
+  ) : Promise<IFoundMediaKeySystemAccessEvent> {
+    // if we iterated over the whole keySystemsType Array, quit on error
+    if (index >= keySystemsType.length) {
+      throw new EncryptedMediaError("INCOMPATIBLE_KEYSYSTEMS",
+                                    "No key system compatible with your wanted " +
+                                    "configuration has been found in the current " +
+                                    "browser.");
+
+    }
 
-      const { keyName, keyType, keySystemOptions } = keySystemsType[index];
-
-      const keySystemConfigurations = buildKeySystemConfigurations(keyName,
-                                                                   keySystemOptions);
-
-      log.debug(`EME: Request keysystem access ${keyType},` +
-                `${index + 1} of ${keySystemsType.length}`,
-                keySystemConfigurations);
-
-      return requestMediaKeySystemAccess(keyType, keySystemConfigurations).pipe(
-        map((keySystemAccess) => {
-          log.info("EME: Found compatible keysystem", keyType, keySystemConfigurations);
-          return { type: "create-media-key-system-access" as const,
-                   value: { options: keySystemOptions,
-                            mediaKeySystemAccess: keySystemAccess } };
-        }),
-        catchError(() => {
-          log.debug("EME: Rejected access to keysystem",
-                    keyType,
-                    keySystemConfigurations);
-          return recursivelyTestKeySystems(index + 1);
-        }));
+    if (requestMediaKeySystemAccess == null) {
+      throw new Error("requestMediaKeySystemAccess is not implemented in your browser.");
     }
-  });
+
+    const { keyName, keyType, keySystemOptions } = keySystemsType[index];
+
+    const keySystemConfigurations = buildKeySystemConfigurations(keyName,
+                                                                 keySystemOptions);
+
+    log.debug(`DRM: Request keysystem access ${keyType},` +
+              `${index + 1} of ${keySystemsType.length}`,
+              keySystemConfigurations);
+
+    try {
+      const keySystemAccess = await requestMediaKeySystemAccess(keyType,
+                                                                keySystemConfigurations);
+      log.info("DRM: Found compatible keysystem", keyType, keySystemConfigurations);
+      return { type: "create-media-key-system-access" as const,
+               value: { options: keySystemOptions,
+                        mediaKeySystemAccess: keySystemAccess } };
+    } catch (_) {
+      log.debug("DRM: Rejected access to keysystem", keyType, keySystemConfigurations);
+      if (cancelSignal.cancellationError !== null) {
+        throw cancelSignal.cancellationError;
+      }
+      return recursivelyTestKeySystems(index + 1);
+    }
+  }
 }

package/src/core/{eme → decrypt}/get_current_key_system.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import MediaKeysInfosStore from "./media_keys_infos_store";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 /**
  * Returns the name of the current key system used.