rx-player 3.33.0 → 3.33.1

package/src/core/decrypt/create_or_load_session.ts

@@ -1,133 +0,0 @@
-/**
- * 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/eme";
-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,
-                                  cancelSignal);
-  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

@@ -1,214 +0,0 @@
-/**
- * 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/eme";
-import log from "../../log";
-import { CancellationSignal } from "../../utils/task_canceller";
-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
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-export default function createSession(
-  stores : IMediaKeySessionStores,
-  initData : IProcessedProtectionData,
-  wantedSessionType : MediaKeySessionType,
-  cancelSignal : CancellationSignal
-) : 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,
-                                                 cancelSignal);
-}
-
-/**
- * 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
- * @param {Object} cancelSignal
- * @returns {Promise}
- */
-async function createAndTryToRetrievePersistentSession(
-  loadedSessionsStore : LoadedSessionsStore,
-  persistentSessionsStore : PersistentSessionsStore,
-  initData : IProcessedProtectionData,
-  cancelSignal : CancellationSignal
-) : Promise<INewSessionCreatedEvent | IPersistentSessionRecoveryEvent> {
-  if (cancelSignal.cancellationError !== null) {
-    throw cancelSignal.cancellationError;
-  }
-  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 loadedSessionsStore.loadPersistentSession(
-      entry.mediaKeySession,
-      storedEntry.sessionId
-    );
-    if (!hasLoadedSession) {
-      log.warn("DRM: No data stored for the loaded session");
-      persistentSessionsStore.delete(storedEntry.sessionId);
-
-      // The EME specification is kind of implicit about it but it seems from my
-      // understanding (Paul B.) that a MediaKeySession on wich a `load` attempt
-      // did not succeed due to the loaded session not being found by the
-      // browser/CDM, should neither be used anymore nor closed.
-      // Thus, we're creating another `"persistent-license"` `MediaKeySession`
-      // in that specific case.
-      loadedSessionsStore.removeSessionWithoutClosingIt(entry.mediaKeySession);
-      const newEntry = loadedSessionsStore.createSession(initData,
-                                                         "persistent-license");
-      return { type: MediaKeySessionLoadingType.Created,
-               value: newEntry };
-    }
-
-    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 {Promise.<Object>}
-   */
-  async function recreatePersistentSession() : Promise<INewSessionCreatedEvent> {
-    if (cancelSignal.cancellationError !== null) {
-      throw cancelSignal.cancellationError;
-    }
-    log.info("DRM: Removing previous persistent session.");
-    const persistentEntry = persistentSessionsStore.get(initData);
-    if (persistentEntry !== null) {
-      persistentSessionsStore.delete(persistentEntry.sessionId);
-    }
-
-    try {
-      await loadedSessionsStore.closeSession(entry.mediaKeySession);
-    } catch (err) {
-      // From reading the EME specification in details, it seems that a
-      // `MediaKeySession`'s ability to be closed is tightly linked to its
-      // possession of a "sanitized session ID" set as `sessionId`.
-      // This is never clearly stated however and I'm (Paul B.) always afraid of
-      // breaking compatibility when it comes to EME code.
-      // So we still try to close the `MediaKeySession` in any case, only, if it
-      // fails and it didn't had any `sessionId` set, we just ignore the error.
-      // Note that trying to close the `MediaKeySession` might incur some delays
-      // in those rare cases.
-      if (entry.mediaKeySession.sessionId !== "") {
-        throw err;
-      }
-      loadedSessionsStore.removeSessionWithoutClosingIt(entry.mediaKeySession);
-    }
-    if (cancelSignal.cancellationError !== null) {
-      throw cancelSignal.cancellationError;
-    }
-    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

@@ -1,54 +0,0 @@
-/**
- * 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 log from "../../log";
-import sleep from "../../utils/sleep";
-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<unknown> {
-  const currentState = MediaKeysInfosStore.getState(mediaElement);
-  if (currentState === null) {
-    return undefined;
-  }
-
-  log.info("DRM: Disposing of the current MediaKeys");
-  const { loadedSessionsStore } = currentState;
-  MediaKeysInfosStore.clearState(mediaElement);
-  await loadedSessionsStore.closeAllSessions();
-
-  return Promise.race(
-    [
-      currentState.emeImplementation.setMediaKeys(mediaElement, null)
-        .catch(err => {
-          log.error(
-            "DRM: Could not reset MediaKeys",
-            err instanceof Error ? err : "Unknown Error"
-          );
-        }),
-
-      // Because we know how much EME has implementation issues, let's not block
-      // everything because that API hangs
-      sleep(1000),
-    ]
-  );
-}