rx-player 3.33.0 → 3.33.1

package/src/core/decrypt/utils/__tests__/clean_old_loaded_sessions.test.ts

@@ -1,158 +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.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-
-import cleanOldLoadedSessions from "../clean_old_loaded_sessions";
-import LoadedSessionsStore from "../loaded_sessions_store";
-
-
-const entry1 = { initializationData: { data: new Uint8Array([1, 6, 9]),
-                                       type: "test" },
-                 mediaKeySession: { sessionId: "toto" },
-                 sessionType: "" };
-
-const entry2 = { initializationData: { data: new Uint8Array([4, 8]),
-                                       type: "foo" },
-                 mediaKeySession: { sessionId: "titi" },
-                 sessionType: "" };
-
-const entry3 = { initializationData: { data: new Uint8Array([7, 3, 121, 87]),
-                                       type: "bar" },
-                 mediaKeySession: { sessionId: "tutu" },
-                 sessionType: "" };
-
-function createLoadedSessionsStore() : LoadedSessionsStore {
-  return {
-    getLength() {
-      return 3;
-    },
-    getAll() {
-      return [entry1, entry2, entry3];
-    },
-    closeSession() {
-      return new Promise((res) => {
-        setTimeout(res, Math.random() * 50);
-      });
-    },
-  } as unknown as LoadedSessionsStore;
-}
-
-const emptyLoadedSessionsStore = {
-  getLength() { return 0; },
-  getAll() { return []; },
-  closeSession() { throw new Error("closeSession should not have been called"); },
-} as unknown as LoadedSessionsStore;
-
-/**
- * Call `cleanOldLoadedSessions` with the given loadedSessionsStore and
- * limit and make sure that:
- *   - no side-effect happen when running
- *   - nothing is emitted
- *   - it just complete without an error
- * Call `done` when done.
- * @param {Object} loadedSessionsStore
- * @param {number} limit
- * @param {Function} done
- */
-async function checkNothingHappen(
-  loadedSessionsStore : LoadedSessionsStore,
-  limit : number
-) : Promise<void> {
-  const mockCloseSession = jest.spyOn(loadedSessionsStore, "closeSession");
-  await cleanOldLoadedSessions(loadedSessionsStore, limit);
-  expect(mockCloseSession).not.toHaveBeenCalled();
-  mockCloseSession.mockRestore();
-}
-
-/**
- * Call `cleanOldLoadedSessions` with the given loadedSessionsStore, limit and
- * entries and make sure that:
- *   - closeSession is called on the specific entries a single time
- *   - it completes without an error
- * Call `done` when done.
- * @param {Object} loadedSessionsStore
- * @param {number} limit
- * @param {Array.<Object>} entries
- */
-async function checkEntriesCleaned(
-  loadedSessionsStore : LoadedSessionsStore,
-  limit : number,
-  entries : Array<{ sessionId: string }>
-) : Promise<void> {
-  const mockCloseSession = jest.spyOn(loadedSessionsStore, "closeSession");
-  const prom = cleanOldLoadedSessions(loadedSessionsStore, limit).then(() => {
-    expect(mockCloseSession).toHaveBeenCalledTimes(entries.length);
-    mockCloseSession.mockRestore();
-  });
-  expect(mockCloseSession).toHaveBeenCalledTimes(entries.length);
-  for (let i = 0; i < entries.length; i++) {
-    expect(mockCloseSession)
-      .toHaveBeenNthCalledWith(i + 1, entries[i]);
-  }
-  return prom;
-}
-
-describe("core - decrypt - cleanOldLoadedSessions", () => {
-  it("should do nothing with a negative limit", async () => {
-    await checkNothingHappen(createLoadedSessionsStore(), -1);
-    await checkNothingHappen(createLoadedSessionsStore(), -20);
-    await checkNothingHappen(emptyLoadedSessionsStore, -20);
-  });
-
-  it("should do nothing with a limit equal to NaN", async () => {
-    await checkNothingHappen(createLoadedSessionsStore(), NaN);
-    await checkNothingHappen(emptyLoadedSessionsStore, NaN);
-  });
-
-  it("should do nothing with a limit equal to -infinity", async () => {
-    await checkNothingHappen(createLoadedSessionsStore(), -Infinity);
-    await checkNothingHappen(emptyLoadedSessionsStore, -Infinity);
-  });
-
-  it("should do nothing if the limit is superior to the current length", async () => {
-    await checkNothingHappen(createLoadedSessionsStore(), 4);
-    await checkNothingHappen(createLoadedSessionsStore(), 5);
-    await checkNothingHappen(createLoadedSessionsStore(), 6);
-    await checkNothingHappen(createLoadedSessionsStore(), +Infinity);
-    await checkNothingHappen(emptyLoadedSessionsStore, 1);
-    await checkNothingHappen(emptyLoadedSessionsStore, 2);
-    await checkNothingHappen(emptyLoadedSessionsStore, 1000);
-    await checkNothingHappen(emptyLoadedSessionsStore, +Infinity);
-
-  });
-
-  it("should do nothing if the limit is equal to the current length", async () => {
-    await checkNothingHappen(createLoadedSessionsStore(), 3);
-    await checkNothingHappen(emptyLoadedSessionsStore, 0);
-  });
-
-  it("should remove some if the limit is inferior to the current length", async () => {
-    await checkEntriesCleaned(createLoadedSessionsStore(), 1, [ entry1.mediaKeySession,
-                                                                entry2.mediaKeySession ]);
-    await checkEntriesCleaned(createLoadedSessionsStore(), 2, [ entry1.mediaKeySession ]);
-  });
-
-  it("should remove all if the limit is equal to 0", async () => {
-    await checkEntriesCleaned(createLoadedSessionsStore(), 0, [ entry1.mediaKeySession,
-                                                                entry2.mediaKeySession,
-                                                                entry3.mediaKeySession ]);
-  });
-});

package/src/core/decrypt/utils/__tests__/clean_old_stored_persistent_info.test.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.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-
-function createPersistentSessionsStore() {
-  return {
-    getLength() : number {
-      return 3;
-    },
-    deleteOldSessions() : void {
-      return ;
-    },
-  };
-}
-
-const emptyPersistentSessionsStore = {
-  getLength() { return 0; },
-  getAll() { return []; },
-  deleteOldSessions() : void { return ; },
-};
-
-/**
- * Call `cleanOldStoredPersistentInfo` with the given persistentSessionsStore
- * and limit and make sure that no side-effect happen when running.
- * @param {Object} persistentSessionsStore
- * @param {number} limit
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function checkNothingHappen(persistentSessionsStore : any, limit : number) {
-  const mockDeleteLast = jest.spyOn(persistentSessionsStore, "deleteOldSessions");
-  const mockLogInfo = jest.fn();
-  jest.mock("../../../../log", () => ({ __esModule: true as const,
-                                        default: { info: mockLogInfo } }));
-  const cleanOldStoredPersistentInfo =
-    jest.requireActual("../clean_old_stored_persistent_info").default;
-  cleanOldStoredPersistentInfo(persistentSessionsStore, limit);
-  expect(mockDeleteLast).not.toHaveBeenCalled();
-  expect(mockLogInfo).not.toHaveBeenCalled();
-  jest.resetModules();
-}
-
-/**
- * Call `cleanOldStoredPersistentInfo` with the given persistentSessionsStore
- * and limit and check that the right number of session information is removed.
- * @param {Object} persistentSessionsStore
- * @param {number} limit
- * @param {number} numberToRemove
- */
-function checkRemoved(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  persistentSessionsStore : any,
-  limit : number,
-  numberToRemove : number
-) {
-  const mockDeleteLast = jest.spyOn(persistentSessionsStore, "deleteOldSessions");
-  const mockLogInfo = jest.fn();
-  jest.mock("../../../../log", () => ({ __esModule: true as const,
-                                        default: { info: mockLogInfo } }));
-  const cleanOldStoredPersistentInfo =
-    jest.requireActual("../clean_old_stored_persistent_info").default;
-  cleanOldStoredPersistentInfo(persistentSessionsStore, limit);
-  expect(mockDeleteLast).toHaveBeenCalledTimes(1);
-  expect(mockDeleteLast).toHaveBeenCalledWith(numberToRemove);
-  expect(mockLogInfo).toHaveBeenCalledTimes(1);
-  expect(mockLogInfo).toHaveBeenCalledWith("DRM: Too many stored persistent sessions," +
-                                            " removing some.",
-                                           persistentSessionsStore.getLength(),
-                                           numberToRemove);
-  jest.resetModules();
-}
-
-describe("core - decrypt - cleanOldStoredPersistentInfo", () => {
-  it("should do nothing with a negative limit", () => {
-    checkNothingHappen(createPersistentSessionsStore(), -1);
-    checkNothingHappen(createPersistentSessionsStore(), -20);
-    checkNothingHappen(emptyPersistentSessionsStore, -20);
-  });
-
-  it("should do nothing with a limit equal to NaN", () => {
-    checkNothingHappen(createPersistentSessionsStore(), NaN);
-    checkNothingHappen(emptyPersistentSessionsStore, NaN);
-  });
-
-  it("should do nothing with a limit equal to -infinity", () => {
-    checkNothingHappen(createPersistentSessionsStore(), -Infinity);
-    checkNothingHappen(emptyPersistentSessionsStore, -Infinity);
-  });
-
-  it("should do nothing if the limit is superior to the current length", () => {
-    checkNothingHappen(createPersistentSessionsStore(), 4);
-    checkNothingHappen(createPersistentSessionsStore(), 5);
-    checkNothingHappen(createPersistentSessionsStore(), 6);
-    checkNothingHappen(createPersistentSessionsStore(), +Infinity);
-    checkNothingHappen(emptyPersistentSessionsStore, 1);
-    checkNothingHappen(emptyPersistentSessionsStore, 2);
-    checkNothingHappen(emptyPersistentSessionsStore, 1000);
-    checkNothingHappen(emptyPersistentSessionsStore, +Infinity);
-
-  });
-
-  it("should do nothing if the limit is equal to the current length", () => {
-    checkNothingHappen(createPersistentSessionsStore(), 3);
-    checkNothingHappen(emptyPersistentSessionsStore, 0);
-  });
-
-  it("should remove some if the limit is inferior to the current length", () => {
-    checkRemoved(createPersistentSessionsStore(), 1, 2);
-    checkRemoved(createPersistentSessionsStore(), 2, 1);
-  });
-
-  it("should remove all if the limit is equal to 0", () => {
-    checkRemoved(createPersistentSessionsStore(), 0, 3);
-  });
-});

package/src/core/decrypt/utils/are_init_values_compatible.ts

@@ -1,140 +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 areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
-import SerializableBytes from "./serializable_bytes";
-
-/**
- * Returns `true` if both values are compatible initialization data, which
- * means that one is completely contained in the other.
- *
- * Both values given should be sorted by systemId the same way.
- * @param {Array.<Object>} stored
- * @param {Array.<Object>} newElts
- * @returns {boolean}
- */
-export default function areInitializationValuesCompatible(
-  stored : Array<{ systemId : string | undefined;
-                   hash : number;
-                   data : Uint8Array | SerializableBytes | string; }>,
-  newElts : Array<{ systemId : string | undefined;
-                    hash : number;
-                    data : Uint8Array | SerializableBytes | string; }>
-) : boolean {
-  return _isAInB(stored, newElts) ??
-         _isAInB(newElts, stored) ??
-         false;
-}
-
-/**
- * Take two arrays of initialization data values, `a` and `b`, sorted by
- * their `systemId` property in the same order.
- *
- * Returns `true` if `a` is not empty and is completely contained in the `b`
- * array.
- * This is equivalent to: "`a` is contained in `b`".
- *
- * Returns `false` either if `a` is empty or if `b` has different initialization
- * data than it for equivalent system ids.
- * This is equivalent to: "`a` represents different data than `b`".
- *
- * Returns `null` if `a` is not fully contained in `b` but can still be
- * compatible with it.
- * This is equivalent to: "`a` is not contained in `b`, but `b` could be
- * contained in `a`".
- * @param {Array.<Object>} a
- * @param {Array.<Object>} b
- * @returns {boolean}
- */
-function _isAInB(
-  a : Array<{ systemId : string | undefined;
-              hash : number;
-              data : Uint8Array | SerializableBytes | string; }>,
-  b : Array<{ systemId : string | undefined;
-              hash : number;
-              data : Uint8Array | SerializableBytes | string; }>
-) : boolean | null {
-  if (a.length === 0) {
-    return false;
-  }
-  if (b.length < a.length) {
-    return null;
-  }
-
-  const firstAElt = a[0];
-  let aIdx = 0;
-  let bIdx = 0;
-
-  for (; bIdx < b.length; bIdx++) {
-    const bElt = b[bIdx];
-    if (bElt.systemId !== firstAElt.systemId) {
-      continue;
-    }
-    if (bElt.hash !== firstAElt.hash) {
-      return false;
-    }
-
-    const aData : Uint8Array =
-      firstAElt.data instanceof Uint8Array ? firstAElt.data :
-      typeof firstAElt.data === "string"   ? SerializableBytes.decode(firstAElt.data) :
-                                             firstAElt.data.initData;
-    const bData : Uint8Array =
-      bElt.data instanceof Uint8Array ? bElt.data :
-      typeof bElt.data === "string"   ? SerializableBytes.decode(bElt.data) :
-                                             bElt.data.initData;
-    if (!areArraysOfNumbersEqual(aData, bData)) {
-      return false;
-    }
-
-    if (b.length - bIdx < a.length) {
-      // not enough place to store `a`'s initialization data.
-      return null;
-    }
-
-    // first `a` value was found. Check if all `a` values are found in `b`
-    for (aIdx = 1; aIdx < a.length; aIdx++) {
-      const aElt = a[aIdx];
-      for (bIdx += 1; bIdx < b.length; bIdx++) {
-        const bNewElt = b[bIdx];
-        if (aElt.systemId !== bNewElt.systemId) {
-          continue;
-        }
-        if (aElt.hash !== bNewElt.hash) {
-          return false;
-        }
-        const aNewData : Uint8Array =
-          aElt.data instanceof Uint8Array ? aElt.data :
-          typeof aElt.data === "string"   ? SerializableBytes.decode(aElt.data) :
-                                                 aElt.data.initData;
-        const bNewData : Uint8Array =
-          bNewElt.data instanceof Uint8Array ? bNewElt.data :
-          typeof bNewElt.data === "string"   ? SerializableBytes.decode(bNewElt.data) :
-                                               bNewElt.data.initData;
-        if (!areArraysOfNumbersEqual(aNewData, bNewData)) {
-          return false;
-        }
-        break;
-      }
-      if (aIdx === b.length) {
-        // we didn't find `aElt`'s systemId in b
-        return null;
-      }
-    }
-    // If we're here, then we've found all `a`'s systemId in `b` and they match
-    return true;
-  }
-  return null; // We didn't find the firstAElt`s systemId in `b`.
-}

package/src/core/decrypt/utils/check_key_statuses.ts

@@ -1,193 +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";
-/* eslint-disable-next-line max-len */
-import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
-import { EncryptedMediaError } from "../../../errors";
-import log from "../../../log";
-import {
-  IEncryptedMediaErrorKeyStatusObject,
-  IKeySystemOption,
-  IPlayerError,
-} from "../../../public_types";
-import assertUnreachable from "../../../utils/assert_unreachable";
-import { bytesToHex } from "../../../utils/string_parsing";
-
-/**
- * Error thrown when the MediaKeySession has to be closed due to a trigger
- * specified by user configuration.
- * Such MediaKeySession should be closed immediately and may be re-created if
- * needed again.
- * @class DecommissionedSessionError
- * @extends Error
- */
-export class DecommissionedSessionError extends Error {
-  public reason : IPlayerError;
-
-  /**
-   * Creates a new `DecommissionedSessionError`.
-   * @param {Error} reason - Error that led to the decision to close the
-   * current MediaKeySession. Should be used for reporting purposes.
-   */
-  constructor(reason : IPlayerError) {
-    super();
-    // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
-    Object.setPrototypeOf(this, DecommissionedSessionError.prototype);
-    this.reason = reason;
-  }
-}
-
-const KEY_STATUSES = { EXPIRED: "expired",
-                       INTERNAL_ERROR: "internal-error",
-                       OUTPUT_RESTRICTED: "output-restricted" };
-
-export type IKeyStatusesCheckingOptions =
-  Pick<IKeySystemOption, "throwOnLicenseExpiration" | "fallbackOn" | "onKeyExpiration">;
-
-/**
- * MediaKeyStatusMap's iterator seems to be quite peculiar and wrongly defined
- * by TypeScript.
- */
-type IKeyStatusesForEach = (
-  callback: (
-    ((arg1 : MediaKeyStatus, arg2 : ArrayBuffer) => void) |
-    ((arg1 : ArrayBuffer, arg2 : MediaKeyStatus) => void)
-  )
-) => void;
-
-/**
- * Look at the current key statuses in the sessions and construct the
- * appropriate warnings, whitelisted and blacklisted key ids.
- *
- * Throws if one of the keyID is on an error.
- * @param {MediaKeySession} session - The MediaKeySession from which the keys
- * will be checked.
- * @param {Object} options
- * @param {String} keySystem - The configuration keySystem used for deciphering
- * @returns {Object} - Warnings to send, whitelisted and blacklisted key ids.
- */
-export default function checkKeyStatuses(
-  session : MediaKeySession | ICustomMediaKeySession,
-  options: IKeyStatusesCheckingOptions,
-  keySystem: string
-) : { warning : EncryptedMediaError | undefined;
-      blacklistedKeyIds : Uint8Array[];
-      whitelistedKeyIds : Uint8Array[]; }
-{
-  const { fallbackOn = {},
-          throwOnLicenseExpiration,
-          onKeyExpiration } = options;
-  const blacklistedKeyIds : Uint8Array[] = [];
-  const whitelistedKeyIds : Uint8Array[] = [];
-  const badKeyStatuses: IEncryptedMediaErrorKeyStatusObject[] = [];
-
-  (session.keyStatuses.forEach as IKeyStatusesForEach)((
-    _arg1 : unknown,
-    _arg2 : unknown) => {
-    // Hack present because the order of the arguments has changed in spec
-    // and is not the same between some versions of Edge and Chrome.
-    const [keyStatus, keyStatusKeyId] = (() => {
-      return (typeof _arg1  === "string" ? [_arg1, _arg2] :
-                                           [_arg2, _arg1]) as [ MediaKeyStatus,
-                                                                ArrayBuffer ];
-    })();
-
-    const keyId = getUUIDKidFromKeyStatusKID(keySystem,
-                                             new Uint8Array(keyStatusKeyId));
-
-    const keyStatusObj = { keyId: keyId.buffer, keyStatus };
-
-    if (log.hasLevel("DEBUG")) {
-      log.debug(`DRM: key status update (${bytesToHex(keyId)}): ${keyStatus}`);
-    }
-
-    switch (keyStatus) {
-      case KEY_STATUSES.EXPIRED: {
-        const error = new EncryptedMediaError(
-          "KEY_STATUS_CHANGE_ERROR",
-          `A decryption key expired (${bytesToHex(keyId)})`,
-          { keyStatuses: [keyStatusObj, ...badKeyStatuses] });
-
-        if (onKeyExpiration === "error" ||
-            (onKeyExpiration === undefined && throwOnLicenseExpiration === false))
-        {
-          throw error;
-        }
-
-        switch (onKeyExpiration) {
-          case "close-session":
-            throw new DecommissionedSessionError(error);
-          case "fallback":
-            blacklistedKeyIds.push(keyId);
-            break;
-          default:
-            // I weirdly stopped relying on switch-cases here due to some TypeScript
-            // issue, not checking properly `case undefined` (bug?)
-            if (onKeyExpiration === "continue" || onKeyExpiration === undefined) {
-              whitelistedKeyIds.push(keyId);
-            } else {
-              // Compile-time check throwing when not all possible cases are handled
-              assertUnreachable(onKeyExpiration);
-            }
-            break;
-        }
-
-        badKeyStatuses.push(keyStatusObj);
-        break;
-      }
-
-      case KEY_STATUSES.INTERNAL_ERROR: {
-        if (fallbackOn.keyInternalError !== true) {
-          throw new EncryptedMediaError(
-            "KEY_STATUS_CHANGE_ERROR",
-            `A "${keyStatus}" status has been encountered (${bytesToHex(keyId)})`,
-            { keyStatuses: [keyStatusObj, ...badKeyStatuses] });
-        }
-        badKeyStatuses.push(keyStatusObj);
-        blacklistedKeyIds.push(keyId);
-        break;
-      }
-
-      case KEY_STATUSES.OUTPUT_RESTRICTED: {
-        if (fallbackOn.keyOutputRestricted !== true) {
-          throw new EncryptedMediaError(
-            "KEY_STATUS_CHANGE_ERROR",
-            `A "${keyStatus}" status has been encountered (${bytesToHex(keyId)})`,
-            { keyStatuses: [keyStatusObj, ...badKeyStatuses] });
-        }
-        badKeyStatuses.push(keyStatusObj);
-        blacklistedKeyIds.push(keyId);
-        break;
-      }
-
-      default:
-        whitelistedKeyIds.push(keyId);
-        break;
-    }
-  });
-
-  let warning;
-  if (badKeyStatuses.length > 0) {
-    warning = new EncryptedMediaError(
-      "KEY_STATUS_CHANGE_ERROR",
-      "One or several problematic key statuses have been encountered",
-      { keyStatuses: badKeyStatuses });
-  }
-  return { warning,
-           blacklistedKeyIds,
-           whitelistedKeyIds };
-}

package/src/core/decrypt/utils/clean_old_loaded_sessions.ts

@@ -1,45 +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 LoadedSessionsStore from "./loaded_sessions_store";
-
-/**
- * Close sessions from the loadedSessionsStore to allow at maximum `limit`
- * stored MediaKeySessions in it.
- *
- * Emit event when a MediaKeySession begin to be closed and another when the
- * MediaKeySession is closed.
- * @param {Object} loadedSessionsStore
- * @returns {Promise}
- */
-export default async function cleanOldLoadedSessions(
-  loadedSessionsStore : LoadedSessionsStore,
-  limit : number
-) : Promise<void> {
-  if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
-    return ;
-  }
-  log.info("DRM: LSS cache limit exceeded", limit, loadedSessionsStore.getLength());
-  const proms : Array<Promise<unknown>> = [];
-  const entries = loadedSessionsStore.getAll().slice(); // clone
-  const toDelete = entries.length - limit;
-  for (let i = 0; i < toDelete; i++) {
-    const entry = entries[i];
-    proms.push(loadedSessionsStore.closeSession(entry.mediaKeySession));
-  }
-  await Promise.all(proms);
-}