rx-player 3.27.0-dev.2022032100 → 3.27.0-dev.2022032500

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rx-player",
   "author": "Canal+",
-  "version": "3.27.0-dev.2022032100",
+  "version": "3.27.0-dev.2022032500",
   "description": "Canal+ HTML5 Video Player",
   "main": "./dist/rx-player.js",
   "keywords": [

package/sonar-project.properties

@@ -1,7 +1,7 @@
 sonar.projectKey=rx-player
 sonar.organization=rx-player
 sonar.projectName=rx-player
-sonar.projectVersion=3.27.0-dev.2022032100
+sonar.projectVersion=3.27.0-dev.2022032500
 sonar.sources=./src,./demo,./tests
 sonar.exclusions=demo/full/bundle.js,demo/standalone/lib.js,demo/bundle.js
 sonar.host.url=https://sonarcloud.io

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

@@ -66,7 +66,6 @@ class OldWebkitMediaKeySession
   private readonly _vid: IOldWebkitHTMLMediaElement;
   private readonly _key: string;
 
-  private readonly _onSessionRelatedEvent : (evt : Event) => void;
   private _closeSession : () => void;
 
   constructor(mediaElement: IOldWebkitHTMLMediaElement, keySystem: string) {
@@ -76,18 +75,23 @@ class OldWebkitMediaKeySession
 
     this.sessionId = "";
     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._onSessionRelatedEvent = (evt : Event) => {
+    const onSessionRelatedEvent = (evt : Event) => {
       this.trigger(evt.type, evt);
     };
+    this.closed = new Promise((resolve) => {
+      this._closeSession = () => {
+        ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+          .forEach(evt => mediaElement.removeEventListener(evt, onSessionRelatedEvent));
+        resolve();
+      };
+    });
+
 
     ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-      .forEach(evt => mediaElement.addEventListener(evt, this._onSessionRelatedEvent));
+      .forEach(evt => mediaElement.addEventListener(evt, onSessionRelatedEvent));
   }
 
   public update(license: Uint8Array) : Promise<void> {
@@ -128,7 +132,6 @@ class OldWebkitMediaKeySession
 
   public close(): Promise<void> {
     return new Promise((resolve) => {
-      this._unbindSession();
       this._closeSession();
       resolve();
     });
@@ -147,11 +150,6 @@ class OldWebkitMediaKeySession
   public remove(): Promise<void> {
     return Promise.resolve();
   }
-
-  private _unbindSession() {
-    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-      .forEach(evt => this._vid.removeEventListener(evt, this._onSessionRelatedEvent));
-  }
 }
 
 class OldWebKitCustomMediaKeys implements ICustomMediaKeys {

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

@@ -83,7 +83,6 @@ class WebkitMediaKeySession
   private _nativeSession: undefined | MediaKeySession;
   private _serverCertificate: Uint8Array | undefined;
 
-  private readonly _onEvent : (evt : Event) => void;
   private _closeSession : () => void;
   private _unbindSession : () => void;
 
@@ -109,10 +108,6 @@ class WebkitMediaKeySession
     });
     this.keyStatuses = new Map();
     this.expiration = NaN;
-
-    this._onEvent = (evt : Event) => {
-      this.trigger(evt.type, evt);
-    };
   }
 
   public update(license: BufferSource) : Promise<void> {
@@ -124,9 +119,17 @@ class WebkitMediaKeySession
         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(license));
+        resolve(this._nativeSession.update(uInt8Arraylicense));
         /* eslint-enable @typescript-eslint/no-unsafe-member-access */
       } catch (err) {
         reject(err);
@@ -202,15 +205,19 @@ class WebkitMediaKeySession
   private _listenEvent(session: MediaKeySession) : void {
     this._unbindSession(); // If previous session was linked
 
+    const onEvent = (evt : Event) => {
+      this.trigger(evt.type, evt);
+    };
+
     /* 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));
+      .forEach(evt => session.addEventListener(evt, onEvent));
 
     this._unbindSession = () => {
       ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
-        .forEach(evt => session.removeEventListener(evt, this._onEvent));
+        .forEach(evt => session.removeEventListener(evt, onEvent));
     };
     /* eslint-disable @typescript-eslint/no-unsafe-return */
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */

package/src/compat/eme/generate_key_request.ts

@@ -124,12 +124,10 @@ export function patchInitData(initData : Uint8Array) : Uint8Array {
  * Generate a request from session.
  * @param {MediaKeySession} session - MediaKeySession on which the request will
  * be done.
- * @param {Uint8Array} initData - Initialization data given e.g. by the
- * "encrypted" event for the corresponding request.
- * @param {string} initDataType - Initialization data type given e.g. by the
- * "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.
+ * @param {string} initializationDataType - Initialization data type given e.g.
+ * by the "encrypted" event for the corresponding request.
+ * @param {Uint8Array} initializationData - Initialization data given e.g. by
+ * the "encrypted" event for the corresponding request.
  * @returns {Promise} - Emit when done. Errors if fails.
  */
 export default function generateKeyRequest(

package/src/core/api/public_api.ts

@@ -427,7 +427,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */"3.27.0-dev.2022032100";
+    this.version = /* PLAYER_VERSION */"3.27.0-dev.2022032500";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -2946,7 +2946,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return activeRepresentations[currentPeriod.id];
   }
 }
-Player.version = /* PLAYER_VERSION */"3.27.0-dev.2022032100";
+Player.version = /* PLAYER_VERSION */"3.27.0-dev.2022032500";
 
 /** Payload emitted with a `positionUpdate` event. */
 export interface IPositionUpdateItem {

package/src/core/decrypt/content_decryptor.ts

@@ -16,7 +16,6 @@
 
 import {
   events,
-  generateKeyRequest,
   getInitData,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
@@ -567,10 +566,22 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     if (sessionRes.type === MediaKeySessionLoadingType.Created) {
       const requestData = initializationData.values.constructRequestData();
       try {
-        await generateKeyRequest(mediaKeySession,
-                                 initializationData.type,
-                                 requestData);
+        await stores.loadedSessionsStore.generateLicenseRequest(
+          mediaKeySession,
+          initializationData.type,
+          requestData);
       } catch (error) {
+        // First check that the error was not due to the MediaKeySession closing
+        // or being closed
+        const entry = stores.loadedSessionsStore.getEntryForSession(mediaKeySession);
+        if (entry === null || entry.closingStatus.type !== "none") {
+          // MediaKeySession closing/closed: Just remove from handled list and abort.
+          const indexInCurrent = this._currentSessions.indexOf(sessionInfo);
+          if (indexInCurrent >= 0) {
+            this._currentSessions.splice(indexInCurrent, 1);
+          }
+          return Promise.resolve();
+        }
         throw new EncryptedMediaError("KEY_GENERATE_REQUEST_ERROR",
                                       error instanceof Error ? error.toString() :
                                       "Unknown error");

package/src/core/decrypt/create_or_load_session.ts

@@ -88,7 +88,10 @@ export default async function createOrLoadSession(
     throw cancelSignal.cancellationError; // stop here if cancelled since
   }
 
-  const evt = await createSession(stores, initializationData, wantedSessionType);
+  const evt = await createSession(stores,
+                                  initializationData,
+                                  wantedSessionType,
+                                  cancelSignal);
   return { type: evt.type,
            value: { mediaKeySession: evt.value.mediaKeySession,
                     sessionType: evt.value.sessionType,

package/src/core/decrypt/create_session.ts

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  ICustomMediaKeySession,
-  loadSession,
-} from "../../compat";
+import { ICustomMediaKeySession } from "../../compat";
 import log from "../../log";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   IProcessedProtectionData,
   IMediaKeySessionStores,
@@ -42,12 +40,14 @@ import PersistentSessionsStore from "./utils/persistent_sessions_store";
  * @param {Object} stores
  * @param {Object} initData
  * @param {string} wantedSessionType
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
 export default function createSession(
   stores : IMediaKeySessionStores,
   initData : IProcessedProtectionData,
-  wantedSessionType : MediaKeySessionType
+  wantedSessionType : MediaKeySessionType,
+  cancelSignal : CancellationSignal
 ) : Promise<ICreateSessionEvent> {
   const { loadedSessionsStore,
           persistentSessionsStore } = stores;
@@ -61,7 +61,8 @@ export default function createSession(
   }
   return createAndTryToRetrievePersistentSession(loadedSessionsStore,
                                                  persistentSessionsStore,
-                                                 initData);
+                                                 initData,
+                                                 cancelSignal);
 }
 
 /**
@@ -87,13 +88,18 @@ function createTemporarySession(
  * @param {Object} loadedSessionsStore
  * @param {Object} persistentSessionsStore
  * @param {Object} initData
+ * @param {Object} cancelSignal
  * @returns {Promise}
  */
 async function createAndTryToRetrievePersistentSession(
   loadedSessionsStore : LoadedSessionsStore,
   persistentSessionsStore : PersistentSessionsStore,
-  initData : IProcessedProtectionData
+  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");
@@ -104,8 +110,10 @@ async function createAndTryToRetrievePersistentSession(
   }
 
   try {
-    const hasLoadedSession = await loadSession(entry.mediaKeySession,
-                                               storedEntry.sessionId);
+    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);
@@ -136,6 +144,9 @@ async function createAndTryToRetrievePersistentSession(
    * @returns {Observable}
    */
   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) {
@@ -143,6 +154,9 @@ async function createAndTryToRetrievePersistentSession(
     }
 
     await loadedSessionsStore.closeSession(entry.mediaKeySession);
+    if (cancelSignal.cancellationError !== null) {
+      throw cancelSignal.cancellationError;
+    }
     const newEntry = loadedSessionsStore.createSession(initData,
                                                        "persistent-license");
     return { type: MediaKeySessionLoadingType.Created,