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

package/src/core/decrypt/__tests__/__global__/server_certificate.test.ts

@@ -0,0 +1,262 @@
+/**
+ * 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 */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-restricted-properties */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+
+import {
+  MediaKeysImpl,
+  MediaKeySystemAccessImpl,
+  mockCompat,
+} from "./utils";
+
+describe("core - decrypt - global tests - server certificate", () => {
+
+  const getLicenseSpy = jest.fn(() => {
+    return new Promise(() => { /* noop */ });
+  });
+
+  /** Default video element used in our tests. */
+  const videoElt = document.createElement("video");
+
+  const serverCertificate = [1, 2, 3];
+
+  /** Default keySystems configuration used in our tests. */
+  const ksConfigCert = [{ type: "com.widevine.alpha",
+                          getLicense: getLicenseSpy,
+                          serverCertificate }];
+
+  beforeEach(() => {
+    jest.resetModules();
+    jest.restoreAllMocks();
+  });
+
+  it("should set the serverCertificate only after the MediaKeys is attached", (done) => {
+    const { setMediaKeysSpy } = mockCompat();
+    setMediaKeysSpy.mockImplementation(() => {
+      expect(createSessionSpy).not.toHaveBeenCalled();
+      expect(serverCertificateSpy).not.toHaveBeenCalled();
+    });
+    const createSessionSpy = jest.spyOn(MediaKeysImpl.prototype, "createSession");
+    const serverCertificateSpy =
+      jest.spyOn(MediaKeysImpl.prototype, "setServerCertificate")
+        .mockImplementation((_serverCertificate : BufferSource) => {
+          expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+          expect(createSessionSpy).not.toHaveBeenCalled();
+          return Promise.resolve(true);
+        });
+
+    const { ContentDecryptorState } = require("../../content_decryptor");
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
+
+    contentDecryptor.addEventListener("stateChange", (state: any) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+        setTimeout(() => {
+          expect(setMediaKeysSpy).not.toHaveBeenCalled();
+          expect(createSessionSpy).not.toHaveBeenCalled();
+          expect(serverCertificateSpy).not.toHaveBeenCalled();
+          contentDecryptor.attach();
+        }, 5);
+      }
+    });
+    setTimeout(() => {
+      contentDecryptor.dispose();
+      expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+      expect(serverCertificateSpy).toHaveBeenCalledTimes(1);
+      expect(createSessionSpy).not.toHaveBeenCalled();
+      done();
+    }, 10);
+  });
+
+  it("should not call serverCertificate multiple times on init data", (done) => {
+    const { setMediaKeysSpy } = mockCompat();
+    setMediaKeysSpy.mockImplementation(() => {
+      expect(createSessionSpy).not.toHaveBeenCalled();
+      expect(serverCertificateSpy).not.toHaveBeenCalled();
+    });
+    const createSessionSpy = jest.spyOn(MediaKeysImpl.prototype, "createSession");
+    const serverCertificateSpy =
+      jest.spyOn(MediaKeysImpl.prototype, "setServerCertificate")
+        .mockImplementation((_serverCertificate : BufferSource) => {
+          expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+          expect(createSessionSpy).not.toHaveBeenCalled();
+          return Promise.resolve(true);
+        });
+
+    const { ContentDecryptorState } = require("../../content_decryptor");
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
+
+    contentDecryptor.addEventListener("stateChange", (state: any) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+        setTimeout(() => {
+          expect(setMediaKeysSpy).not.toHaveBeenCalled();
+          expect(createSessionSpy).not.toHaveBeenCalled();
+          expect(serverCertificateSpy).not.toHaveBeenCalled();
+          const initData = new Uint8Array([54, 55, 75]);
+          contentDecryptor.onInitializationData({
+            type: "cenc2",
+            values: [ { systemId: "15", data: initData } ],
+          });
+          contentDecryptor.attach();
+        }, 5);
+      }
+    });
+    setTimeout(() => {
+      contentDecryptor.dispose();
+      expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+      expect(serverCertificateSpy).toHaveBeenCalledTimes(1);
+      expect(createSessionSpy).toHaveBeenCalledTimes(1);
+      done();
+    }, 10);
+  });
+
+  /* eslint-disable max-len */
+  it("should emit warning if serverCertificate call rejects but still continue", (done) => {
+  /* eslint-enable max-len */
+
+    const { setMediaKeysSpy } = mockCompat();
+    const createSessionSpy = jest.spyOn(MediaKeysImpl.prototype, "createSession");
+    const serverCertificateSpy =
+      jest.spyOn(MediaKeysImpl.prototype, "setServerCertificate")
+        .mockImplementation((_serverCertificate : BufferSource) => {
+          throw new Error("some error");
+        });
+
+    const { ContentDecryptorState } = require("../../content_decryptor");
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
+
+    contentDecryptor.addEventListener("stateChange", (state: any) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+        contentDecryptor.attach();
+      }
+    });
+
+    let warningsReceived = 0;
+    contentDecryptor.addEventListener("warning", (w: any) => {
+      expect(w.code).toEqual("LICENSE_SERVER_CERTIFICATE_ERROR");
+      expect(w.type).toEqual("ENCRYPTED_MEDIA_ERROR");
+      warningsReceived++;
+    });
+    setTimeout(() => {
+      contentDecryptor.dispose();
+      expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+      expect(serverCertificateSpy).toHaveBeenCalledTimes(1);
+      expect(createSessionSpy).not.toHaveBeenCalled();
+      expect(warningsReceived).toEqual(1);
+      done();
+    }, 10);
+  });
+
+  /* eslint-disable max-len */
+  it("should emit warning if serverCertificate call throws but still continue", (done) => {
+  /* eslint-enable max-len */
+
+    const { setMediaKeysSpy } = mockCompat();
+    const createSessionSpy = jest.spyOn(MediaKeysImpl.prototype, "createSession");
+    const serverCertificateSpy =
+      jest.spyOn(MediaKeysImpl.prototype, "setServerCertificate")
+        .mockImplementation((_serverCertificate : BufferSource) => {
+          return Promise.reject(new Error("some error"));
+        });
+
+    const { ContentDecryptorState } = require("../../content_decryptor");
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
+
+    contentDecryptor.addEventListener("stateChange", (state: any) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+        contentDecryptor.attach();
+      }
+    });
+
+    let warningsReceived = 0;
+    contentDecryptor.addEventListener("warning", (w: any) => {
+      expect(w.code).toEqual("LICENSE_SERVER_CERTIFICATE_ERROR");
+      expect(w.type).toEqual("ENCRYPTED_MEDIA_ERROR");
+      warningsReceived++;
+    });
+    setTimeout(() => {
+      contentDecryptor.dispose();
+      expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+      expect(serverCertificateSpy).toHaveBeenCalledTimes(1);
+      expect(createSessionSpy).not.toHaveBeenCalled();
+      expect(warningsReceived).toEqual(1);
+      done();
+    }, 10);
+  });
+
+  /* eslint-disable max-len */
+  it("should just continue if setServerCertificate is undefined", (done) => {
+  /* eslint-enable max-len */
+    const { setMediaKeysSpy } = mockCompat();
+    jest.spyOn(MediaKeySystemAccessImpl.prototype, "createMediaKeys")
+      .mockImplementation(() => {
+        const mediaKeys = new MediaKeysImpl();
+        (mediaKeys as { setServerCertificate? : unknown })
+          .setServerCertificate = undefined;
+        return Promise.resolve(mediaKeys);
+      });
+    setMediaKeysSpy.mockImplementation(() => {
+      expect(createSessionSpy).not.toHaveBeenCalled();
+      expect(serverCertificateSpy).not.toHaveBeenCalled();
+    });
+    const createSessionSpy = jest.spyOn(MediaKeysImpl.prototype, "createSession");
+    const serverCertificateSpy = jest.spyOn(MediaKeysImpl.prototype,
+                                            "setServerCertificate");
+    const { ContentDecryptorState } = require("../../content_decryptor");
+    const ContentDecryptor = require("../../content_decryptor").default;
+    const contentDecryptor = new ContentDecryptor(videoElt, ksConfigCert);
+
+    contentDecryptor.addEventListener("stateChange", (state: any) => {
+      if (state === ContentDecryptorState.WaitingForAttachment) {
+        contentDecryptor.removeEventListener("stateChange");
+        setTimeout(() => {
+          expect(setMediaKeysSpy).not.toHaveBeenCalled();
+          expect(createSessionSpy).not.toHaveBeenCalled();
+          expect(serverCertificateSpy).not.toHaveBeenCalled();
+          const initData = new Uint8Array([54, 55, 75]);
+          contentDecryptor.onInitializationData({
+            type: "cenc2",
+            values: [ { systemId: "15", data: initData } ],
+          });
+
+          contentDecryptor.attach();
+        }, 5);
+      }
+    });
+    setTimeout(() => {
+      contentDecryptor.dispose();
+      expect(setMediaKeysSpy).toHaveBeenCalledTimes(1);
+      expect(serverCertificateSpy).not.toHaveBeenCalled();
+      expect(createSessionSpy).toHaveBeenCalledTimes(1);
+      done();
+    }, 10);
+  });
+});

package/src/core/{eme → decrypt}/__tests__/__global__/utils.ts

@@ -21,20 +21,17 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 /* eslint-disable no-restricted-properties */
 
-import {
-  defer as observableDefer,
-  Observable,
-  of as observableOf,
-  Subject,
-} from "rxjs";
+import { Subject } from "rxjs";
 import { IEncryptedEventData } from "../../../../compat/eme";
 import {
   base64ToBytes,
   bytesToBase64,
 } from "../../../../utils/base64";
-import castToObservable from "../../../../utils/cast_to_observable";
 import EventEmitter, { fromEvent } from "../../../../utils/event_emitter";
 import flatMap from "../../../../utils/flat_map";
 import {
@@ -170,15 +167,17 @@ export class MediaKeySessionImpl extends EventEmitter<Record<string, unknown>> {
 
   public generateRequest(initDataType: string, initData: BufferSource) : Promise<void> {
     const msg = formatFakeChallengeFromInitData(initData, initDataType);
-    const event : MediaKeyMessageEvent =
-      Object.assign(new CustomEvent("message"),
-                    { message: msg.buffer,
-                      messageType: "license-request" as const });
-
-    this.trigger("message", event);
-    if (this.onmessage !== null && this.onmessage !== undefined) {
-      this.onmessage(event);
-    }
+    setTimeout(() => {
+      const event : MediaKeyMessageEvent =
+        Object.assign(new CustomEvent("message"),
+                      { message: msg.buffer,
+                        messageType: "license-request" as const });
+
+      this.trigger("message", event);
+      if (this.onmessage !== null && this.onmessage !== undefined) {
+        this.onmessage(event);
+      }
+    }, 5);
     return Promise.resolve();
   }
 
@@ -240,8 +239,8 @@ export class MediaKeySystemAccessImpl {
 export function requestMediaKeySystemAccessImpl(
   keySystem : string,
   config : MediaKeySystemConfiguration[]
-) : Observable<MediaKeySystemAccessImpl> {
-  return observableOf(new MediaKeySystemAccessImpl(keySystem, config));
+) : Promise<MediaKeySystemAccessImpl> {
+  return Promise.resolve(new MediaKeySystemAccessImpl(keySystem, config));
 }
 
 /**
@@ -267,16 +266,14 @@ export function mockCompat(exportedFunctions = {}) {
   };
 
   const rmksaSpy = jest.fn(requestMediaKeySystemAccessImpl);
-  const setMediaKeysSpy = jest.fn(() => observableOf(null));
+  const setMediaKeysSpy = jest.fn();
   const generateKeyRequestSpy = jest.fn((
     mks : MediaKeySessionImpl,
     initializationDataType,
     initializationData
   ) => {
-    return observableDefer(() => {
-      return castToObservable(mks.generateRequest(initializationDataType,
-                                                  initializationData));
-    });
+    return mks.generateRequest(initializationDataType,
+                               initializationData);
   });
 
   const getInitDataSpy = jest.fn((encryptedEvent : IEncryptedEventData) => {
@@ -303,9 +300,7 @@ export function mockCompat(exportedFunctions = {}) {
 }
 
 /**
- * Check that the EMEManager, when called with those arguments, throws
- * directly without any event emitted.
- *
+ * Check that the ContentDecryptor, when called with those arguments, throws.
  * If that's the case, resolve with the corresponding error.
  * Else, reject.
  * @param {HTMLMediaElement} mediaElement
@@ -313,79 +308,22 @@ export function mockCompat(exportedFunctions = {}) {
  * @param {Observable} contentProtections$
  * @returns {Promise}
  */
-export function testEMEManagerImmediateError(
-  /* eslint-disable @typescript-eslint/naming-convention */
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  EMEManager : any,
-  /* eslint-enable @typescript-eslint/no-explicit-any */
-  /* eslint-enable @typescript-eslint/naming-convention */
+export function testContentDecryptorError(
+  ContentDecryptor : any,
   mediaElement : HTMLMediaElement,
-  keySystemsConfigs : unknown[],
-  contentProtections$ : Observable<unknown>
+  keySystemsConfigs : unknown[]
 ) : Promise<unknown> {
   return new Promise((res, rej) => {
-    EMEManager(mediaElement, keySystemsConfigs, contentProtections$)
-      .subscribe(
-        (evt : unknown) => {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const eventStr = JSON.stringify(evt as any);
-          rej(new Error("Received an EMEManager event: " + eventStr));
-        },
-        (err : unknown) => { res(err); },
-        () => rej(new Error("EMEManager completed."))
-      );
+    const contentDecryptor = new ContentDecryptor(mediaElement, keySystemsConfigs);
+    contentDecryptor.addEventListener("error", (error: any) => {
+      res(error);
+    });
+    setTimeout(() => {
+      rej(new Error("Timeout exceeded"));
+    }, 10);
   });
 }
 
-/**
- * Check that the event received corresponds to the session-message event for a
- * license request.
- * @param {Object} evt
- * @param {Object} initDataVal
- */
-export function expectLicenseRequestMessage(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  evt : { type : string; value : any },
-  initDataVal : { type : string | undefined;
-                  values : Array<{ systemId : string | unknown;
-                                   data : Uint8Array; }>; }
-) : void {
-  expect(evt.type).toEqual("session-message");
-  expect(evt.value.messageType).toEqual("license-request");
-  expect(evt.value.initializationData).toEqual(initDataVal);
-}
-
-/**
- * @param {Object} evt
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- */
-export function expectInitDataIgnored(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  evt : { type : string; value : any },
-  initDataVal : { type : string | undefined;
-                  values : Array<{ systemId : string | undefined;
-                                   data : Uint8Array; }>; }
-) : void {
-  expect(evt.type).toEqual("init-data-ignored");
-  expect(evt.value.initializationData).toEqual(initDataVal);
-}
-
-/**
- * @param {Object} evt
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- */
-export function expectEncryptedEventReceived(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  evt : { type : string; value : any },
-  initData : IEncryptedEventData
-) : void {
-  expect(evt.type).toEqual("encrypted-event-received");
-  expect(evt.value).toEqual(initData);
-}
-
 /**
  * Does the reverse operation than what `formatFakeChallengeFromInitData` does:
  * Retrieve initialization data from a fake challenge done in our tests

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

@@ -14,51 +14,27 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  mergeMap,
-  tap,
-  Observable,
-  of as observableOf,
-} from "rxjs";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
   setMediaKeys,
 } from "../../compat";
 import log from "../../log";
-import MediaKeysInfosStore from "./media_keys_infos_store";
+import { CancellationSignal } from "../../utils/task_canceller";
 import {
   IKeySystemOption,
 } from "./types";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 /**
- * Dispose the media keys on media element.
+ * Dispose of the MediaKeys instance attached to the given media element, if
+ * one.
  * @param {Object} mediaElement
- * @returns {Observable}
  */
-export function disableMediaKeys(
-  mediaElement : HTMLMediaElement
-): Observable<unknown> {
-  return observableDefer(() => {
-    MediaKeysInfosStore.setState(mediaElement, null);
-    return setMediaKeys(mediaElement, null);
-  });
-}
-
-/** MediaKeys and associated state attached to a media element. */
-export interface IMediaKeysState {
-  /** Options set when the MediaKeys has been attached. */
-  keySystemOptions : IKeySystemOption;
-  /** LoadedSessionsStore associated to the MediaKeys instance. */
-  loadedSessionsStore : LoadedSessionsStore;
-  /** The MediaKeySystemAccess allowing to create MediaKeys instances. */
-  mediaKeySystemAccess: MediaKeySystemAccess |
-                        ICustomMediaKeySystemAccess;
-  /** The MediaKeys instance to attach to the media element. */
-  mediaKeys : MediaKeys |
-              ICustomMediaKeys;
+export function disableMediaKeys(mediaElement : HTMLMediaElement): void {
+  MediaKeysInfosStore.setState(mediaElement, null);
+  setMediaKeys(mediaElement, null);
 }
 
 /**
@@ -69,34 +45,50 @@ export interface IMediaKeysState {
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-export default function attachMediaKeys(
+export default async function attachMediaKeys(
   mediaElement : HTMLMediaElement,
   { keySystemOptions,
     loadedSessionsStore,
     mediaKeySystemAccess,
-    mediaKeys } : IMediaKeysState
-) : Observable<unknown> {
-  return observableDefer(() => {
-    const previousState = MediaKeysInfosStore.getState(mediaElement);
-    const closeAllSessions$ = previousState !== null &&
-                              previousState.loadedSessionsStore !== loadedSessionsStore ?
-                                previousState.loadedSessionsStore.closeAllSessions() :
-                                observableOf(null);
+    mediaKeys } : IMediaKeysState,
+  cancelSignal : CancellationSignal
+) : Promise<void> {
+  const previousState = MediaKeysInfosStore.getState(mediaElement);
+  const closeAllSessions = previousState !== null &&
+                           previousState.loadedSessionsStore !== loadedSessionsStore ?
+                             previousState.loadedSessionsStore.closeAllSessions() :
+                             Promise.resolve();
 
-    return closeAllSessions$.pipe(
-      mergeMap(() => {
-        MediaKeysInfosStore.setState(mediaElement,
-                                     { keySystemOptions,
-                                       mediaKeySystemAccess,
-                                       mediaKeys,
-                                       loadedSessionsStore });
-        if (mediaElement.mediaKeys === mediaKeys) {
-          return observableOf(null);
-        }
-        log.info("EME: Attaching MediaKeys to the media element");
-        return setMediaKeys(mediaElement, mediaKeys)
-          .pipe(tap(() => { log.info("EME: MediaKeys attached with success"); }));
-      })
-    );
-  });
+  await closeAllSessions;
+
+  // If this task has been cancelled while we were closing previous sessions,
+  // stop now (and thus avoid setting the new media keys);
+  if (cancelSignal.isCancelled) {
+    throw cancelSignal.cancellationError;
+  }
+
+  MediaKeysInfosStore.setState(mediaElement, { keySystemOptions,
+                                               mediaKeySystemAccess,
+                                               mediaKeys,
+                                               loadedSessionsStore });
+  if (mediaElement.mediaKeys === mediaKeys) {
+    return ;
+  }
+  log.info("DRM: Attaching MediaKeys to the media element");
+  setMediaKeys(mediaElement, mediaKeys);
+  log.info("DRM: MediaKeys attached with success");
+}
+
+/** MediaKeys and associated state attached to a media element. */
+export interface IMediaKeysState {
+  /** Options set when the MediaKeys has been attached. */
+  keySystemOptions : IKeySystemOption;
+  /** LoadedSessionsStore associated to the MediaKeys instance. */
+  loadedSessionsStore : LoadedSessionsStore;
+  /** The MediaKeySystemAccess allowing to create MediaKeys instances. */
+  mediaKeySystemAccess: MediaKeySystemAccess |
+                        ICustomMediaKeySystemAccess;
+  /** The MediaKeys instance to attach to the media element. */
+  mediaKeys : MediaKeys |
+              ICustomMediaKeys;
 }

package/src/core/decrypt/clear_on_stop.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { shouldUnsetMediaKeys } from "../../compat/";
+import log from "../../log";
+import disposeDecryptionResources from "./dispose_decryption_resources";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+
+/**
+ * Clear DRM-related resources that should be cleared when the current content
+ * stops its playback.
+ * @param {HTMLMediaElement} mediaElement
+ * @returns {Observable}
+ */
+export default function clearOnStop(
+  mediaElement : HTMLMediaElement
+) : Promise<void> {
+  log.info("DRM: Clearing-up DRM session.");
+  if (shouldUnsetMediaKeys()) {
+    log.info("DRM: disposing current MediaKeys.");
+    return disposeDecryptionResources(mediaElement);
+  }
+
+  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  if (currentState !== null &&
+      currentState.keySystemOptions.closeSessionsOnStop === true)
+  {
+    log.info("DRM: closing all current sessions.");
+    return currentState.loadedSessionsStore.closeAllSessions();
+  }
+  log.info("DRM: Nothing to clear. Returning right away. No state =",
+           currentState === null);
+  return Promise.resolve();
+}