rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/README.md

@@ -33,12 +33,12 @@ To better understand the player's architecture, you can find below a
   Facilitate track                V ~                  | ~     Abstract the streaming ^ ~
   switching for           +---------------+            | ~     protocol               | ~
   the API                 |               |            | V                            | ~
- +--------------+         |               |         +--------------------------+      | ~
- |              |         |     Init      | ------> |                          |      | ~
- |  EMEManager  | <------ | (./core/init) | <~~~~~~ |     Manifest Fetcher     |      | ~
- | (./core/eme) | ~~~~~~> |               |         |(./core/fetchers/manifest)|      | ~
- |              |         |               |         |                          |      | ~
- +--------------+         +---------------+         +--------------------------+      | ~
+ +----------------+       |               |         +--------------------------+      | ~
+ |    Content     |       |     Init      | ------> |                          |      | ~
+ |   Decryptor    | <---- | (./core/init) | <~~~~~~ |     Manifest Fetcher     |      | ~
+ |(./core/decrypt)| ~~~~> |               |         |(./core/fetchers/manifest)|      | ~
+ |                |       |               |         |                          |      | ~
+ +----------------+       +---------------+         +--------------------------+      | ~
  Negotiate content               | ^  Initialize     Load and refresh the Manifest    | ~
  decryption                      | ~  playback and                                    | ~
                                  | ~  create/connect                                  | ~

package/src/compat/__tests__/fullscreen.test.ts

@@ -23,15 +23,15 @@
 
 interface IFakeDocument {
   createElement(eltType: string) : HTMLElement;
-  fullscreenElement? : Element | null;
-  mozCancelFullScreen? : () => void;
-  mozFullScreenElement? : HTMLElement;
-  msExitFullscreen? : () => void;
-  exitFullscreen? : () => void;
-  msFullscreenElement? : Element | null;
+  fullscreenElement? : Element | null | undefined;
+  mozCancelFullScreen? : (() => void) | undefined;
+  mozFullScreenElement? : HTMLElement | undefined;
+  msExitFullscreen? : (() => void) | undefined;
+  exitFullscreen? : (() => void) | undefined;
+  msFullscreenElement? : Element | null | undefined;
   webkitExitFullscreen : () => void;
   webkitFullscreenElement : Element | null | undefined;
-  webkitHidden? : boolean;
+  webkitHidden? : boolean | undefined;
 }
 
 const doc = document as unknown as IFakeDocument;

package/src/compat/__tests__/is_vtt_cue.test.ts

@@ -63,7 +63,7 @@ describe("Compat - isVTTCue", () => {
     const originalVTTCue = window.VTTCue;
     win.VTTCue = MockVTTCue;
     const cue = new VTTCue(0, 10, "");
-    win.VTTCue = undefined;
+    delete win.VTTCue;
     const isVTTCue = require("../is_vtt_cue").default;
     expect(isVTTCue(cue)).toEqual(false);
     window.VTTCue = originalVTTCue;

package/src/compat/__tests__/should_favour_custom_safari_EME.test.ts

@@ -40,27 +40,66 @@ describe("compat - shouldFavourSafariMediaKeys", () => {
   it("should return false if we are not on Safari", () => {
     jest.mock("../browser_detection", () => {
       return { __esModule: true as const,
-               isSafari: false };
+               isSafariDesktop: false,
+               isSafariMobile: false };
     });
     const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
     expect(shouldFavourCustomSafariEME.default()).toBe(false);
   });
 
   /* eslint-disable max-len */
-  it("should return false if we are on Safari but WekitMediaKeys is not available", () => {
+  it("should return false if we are on Safari Desktop but WekitMediaKeys is not available", () => {
   /* eslint-enable max-len */
 
     win.WebKitMediaKeys = undefined;
     jest.mock("../browser_detection", () => {
       return { __esModule: true as const,
-               isSafari: true };
+               isSafariDesktop: true,
+               isSafariMobile: false };
     });
     const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
     expect(shouldFavourCustomSafariEME.default()).toBe(false);
   });
 
   /* eslint-disable max-len */
-  it("should return true if we are on Safari and a WebKitMediaKeys implementation is available", () => {
+  it("should return false if we are on Safari Mobile but WekitMediaKeys is not available", () => {
+  /* eslint-enable max-len */
+
+    win.WebKitMediaKeys = undefined;
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isSafariDesktop: false,
+               isSafariMobile: true };
+    });
+    const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
+    expect(shouldFavourCustomSafariEME.default()).toBe(false);
+  });
+
+  /* eslint-disable max-len */
+  it("should return true if we are on Safari Desktop and a WebKitMediaKeys implementation is available", () => {
+  /* eslint-enable max-len */
+
+    win.WebKitMediaKeys = {
+      isTypeSupported: () => ({}),
+      prototype: {
+        createSession: () => ({}),
+      },
+    };
+    const proto = win.HTMLMediaElement.prototype as unknown as {
+      webkitSetMediaKeys : () => Record<string, never>;
+    };
+    proto.webkitSetMediaKeys = () => ({});
+    jest.mock("../browser_detection", () => {
+      return { __esModule: true as const,
+               isSafariDesktop: true,
+               isSafariMobile: false };
+    });
+    const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
+    expect(shouldFavourCustomSafariEME.default()).toBe(true);
+  });
+
+  /* eslint-disable max-len */
+  it("should return true if we are on Safari Mobile and a WebKitMediaKeys implementation is available", () => {
   /* eslint-enable max-len */
 
     win.WebKitMediaKeys = {
@@ -75,7 +114,8 @@ describe("compat - shouldFavourSafariMediaKeys", () => {
     proto.webkitSetMediaKeys = () => ({});
     jest.mock("../browser_detection", () => {
       return { __esModule: true as const,
-               isSafari: true };
+               isSafariDesktop: false,
+               isSafariMobile: true };
     });
     const shouldFavourCustomSafariEME = require("../should_favour_custom_safari_EME");
     expect(shouldFavourCustomSafariEME.default()).toBe(true);

package/src/compat/browser_detection.ts

@@ -54,13 +54,15 @@ interface ISafariWindowObject extends Window {
   safari? : { pushNotification? : { toString() : string } };
 }
 
-const isSafari : boolean =
+/** `true` on Safari on a PC platform (i.e. not iPhone / iPad etc.) */
+const isSafariDesktop : boolean =
   !isNode && (
     Object.prototype.toString.call(window.HTMLElement).indexOf("Constructor") >= 0 ||
     (window as ISafariWindowObject).safari?.pushNotification?.toString() ===
       "[object SafariRemoteNotification]"
   );
 
+/** `true` on Safari on an iPhone, iPad & iPod platform */
 const isSafariMobile : boolean = !isNode &&
                                  typeof navigator.platform === "string" &&
                                  /iPad|iPhone|iPod/.test(navigator.platform);
@@ -70,7 +72,7 @@ export {
   isIE11,
   isIEOrEdge,
   isFirefox,
-  isSafari,
+  isSafariDesktop,
   isSafariMobile,
   isSamsungBrowser,
   isTizen,

package/src/compat/eme/close_session.ts

@@ -14,65 +14,99 @@
  * limitations under the License.
  */
 
-import {
-  catchError,
-  map,
-  mergeMap,
-  Observable,
-  of as observableOf,
-  race as observableRace,
-  timer as observableTimer,
-} from "rxjs";
-import castToObservable from "../../utils/cast_to_observable";
+import log from "../../log";
+import cancellableSleep from "../../utils/cancellable_sleep";
+import PPromise from "../../utils/promise";
+import TaskCanceller, {
+  CancellationError,
+} from "../../utils/task_canceller";
 import { ICustomMediaKeySession } from "./custom_media_keys";
 
 /**
- * Close session and returns and observable that emits when
- * the session is closed.
+ * Close the given `MediaKeySession` and returns a Promise resolving when the
+ * session is closed.
+ * This promise does not reject, even if we're unable to close the
+ * `MediaKeySession`.
+ *
+ * Note that there is a lot of browser issues linked to the impossibility to
+ * either close a MediaKeySession or to know if a MediaKeySession was closed.
+ * Due to this, the returned Promise might take some time before resolving on
+ * some devices.
  * @param {MediaKeySession|Object} session
- * @returns {Observable}
+ * @returns {Promise.<undefined>}
  */
-export default function closeSession$(
-  session: MediaKeySession|ICustomMediaKeySession
-): Observable<unknown> {
-  return observableRace(
-    castToObservable(session.close()),
-    // If the session is not closed after 1000ms, try
-    // to call another method on session to guess if
-    // session is closed or not.
-    observableTimer(1000).pipe(
-      mergeMap(() => {
-        const tryToUpdateSession$ = castToObservable(
-          session.update(new Uint8Array(1))
-        );
-        return tryToUpdateSession$.pipe(
-          // Update has resolved, so we can't know if session is closed
-          map(() => { throw new Error("Compat: Couldn't know if session is " +
-                                      "closed"); }),
-          catchError((err : unknown) => {
-            // The caught error can tell if session is closed
-            // (Chrome may throw this error)
-            if (err instanceof Error &&
-                err.message === "The session is already closed."
-            ) {
-              return observableOf(null);
-            }
-            // The `closed` promise may resolve, even if `close()` result has not
-            // (it may happen on Firefox). Wait for it and timeout after 1 second.
-            // TODO There is a subtle TypeScript issue there that made casting to
-            // a type-compatible type mandatory. If a more elegant solution can
-            // be found, it should be preffered.
-            const sessionIsClosed$ = castToObservable(session.closed as Promise<unknown>);
-            return observableRace(
-              sessionIsClosed$,
-              observableTimer(1000).pipe(
-                map(() => { throw new Error("Compat: Couldn't know if session is " +
-                                            "closed"); })
-              )
-            );
-          })
-        );
-      })
-    )
-  );
+export default function closeSession(
+  session: MediaKeySession | ICustomMediaKeySession
+): Promise<void> {
+  const timeoutCanceller = new TaskCanceller();
+
+  return PPromise.race([
+    session.close()
+      .then(() => { timeoutCanceller.cancel(); }),
+    // The `closed` promise may resolve, even if `close()` result has not
+    // (seen at some point on Firefox).
+    session.closed
+      .then(() => { timeoutCanceller.cancel(); }),
+    waitTimeoutAndCheck(),
+  ]);
+
+  /**
+   * If the session is not closed after 1000ms, try to communicate with the
+   * MediaKeySession and check if an error is returned.
+   * This is needed because on some browsers with poor EME implementation,
+   * knowing when a MediaKeySession is closed is actually a hard task.
+   *
+   * The returned Promise will never reject.
+   * @returns {Promise.<undefined>}
+   */
+  async function waitTimeoutAndCheck() : Promise<void> {
+    try {
+      await cancellableSleep(1000, timeoutCanceller.signal);
+      await tryUpdatingSession();
+    } catch (err) {
+      if (err instanceof CancellationError) { // cancelled == session closed
+        return;
+      }
+      const message = err instanceof Error ?
+        err.message :
+        "Unknown error made it impossible to close the session";
+      log.error(`DRM: ${message}`);
+    }
+  }
+
+  /**
+   * Try to update `MediaKeySession` and check its error if it failed.
+   * If we still don't know whether it closed yet, wait a second
+   * timeout then quit.
+   *
+   * The returned Promise resolves if the `MediaKeySession` seems closed and
+   * rejects if we couldn't know or it doesn't.
+   * @returns {Promise.<undefined>}
+   */
+  async function tryUpdatingSession() : Promise<void> {
+    try {
+      await session.update(new Uint8Array(1));
+    } catch (err) {
+      if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+        return;
+      }
+
+      // The caught error can tell if session is closed
+      // (Chrome may throw this error)
+      // I know... Checking the error message is not the best practice ever.
+      if (err instanceof Error &&
+          err.message === "The session is already closed."
+      ) {
+        return;
+      }
+
+      await cancellableSleep(1000, timeoutCanceller.signal);
+    }
+
+    if (timeoutCanceller.isUsed) { // Reminder: cancelled == session closed
+      return;
+    }
+
+    throw new Error("Compat: Couldn't know if session is closed");
+  }
 }

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

@@ -45,7 +45,7 @@ class IE11MediaKeySession
   public keyStatuses: ICustomMediaKeyStatusMap;
   private readonly _mk: MSMediaKeys;
   private readonly _closeSession$: Subject<void>;
-  private _ss?: MSMediaKeySession;
+  private _ss: MSMediaKeySession | undefined;
   constructor(mk: MSMediaKeys) {
     super();
     this.expiration = NaN;

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

@@ -14,15 +14,9 @@
  * limitations under the License.
  */
 
-import {
-  defer as observableDefer,
-  Observable,
-  of as observableOf,
-  throwError as observableThrow,
-} from "rxjs";
+import PPromise from "pinkie";
 import { MediaError } from "../../../errors";
 import assert from "../../../utils/assert";
-import castToObservable from "../../../utils/cast_to_observable";
 import { ICompatHTMLMediaElement } from "../../browser_compatibility_types";
 import { isIE11 } from "../../browser_detection";
 import isNode from "../../is_node";
@@ -47,12 +41,18 @@ import { WebKitMediaKeysConstructor } from "./webkit_media_keys_constructor";
 /** Generic implementation of the navigator.requestMediaKeySystemAccess API. */
 type ICompatRequestMediaKeySystemAccessFn =
   (keyType : string, config : MediaKeySystemConfiguration[]) =>
-    Observable<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+    Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
 
-let requestMediaKeySystemAccess : null | ICompatRequestMediaKeySystemAccessFn = null;
+let requestMediaKeySystemAccess : ICompatRequestMediaKeySystemAccessFn | null = null;
 
-let _setMediaKeys :
-((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => void) =
+/**
+ * Set the given MediaKeys on the given HTMLMediaElement.
+ * Emits null when done then complete.
+ * @param {HTMLMediaElement} elt
+ * @param {Object} mediaKeys
+ */
+let setMediaKeys :
+((elt: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => unknown) =
   function defaultSetMediaKeys(
     mediaElement: HTMLMediaElement,
     mediaKeys: MediaKeys | ICustomMediaKeys | null
@@ -92,11 +92,8 @@ let _setMediaKeys :
 if (isNode ||
     (navigator.requestMediaKeySystemAccess != null && !shouldFavourCustomSafariEME())
 ) {
-  requestMediaKeySystemAccess = (
-    a : string,
-    b : MediaKeySystemConfiguration[]
-  ) : Observable<MediaKeySystemAccess> =>
-    castToObservable(navigator.requestMediaKeySystemAccess(a, b));
+  requestMediaKeySystemAccess = (...args) =>
+    navigator.requestMediaKeySystemAccess(...args);
 } else {
   let isTypeSupported: (keyType: string) => boolean;
   let createCustomMediaKeys: (keyType: string) => ICustomMediaKeys;
@@ -106,23 +103,23 @@ if (isNode ||
     const callbacks = getOldKitWebKitMediaKeyCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   // This is for WebKit with prefixed EME api
   } else if (WebKitMediaKeysConstructor !== undefined) {
     const callbacks = getWebKitMediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else if (isIE11 && MSMediaKeysConstructor !== undefined) {
     const callbacks = getIE11MediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else if (MozMediaKeysConstructor !== undefined) {
     const callbacks = getMozMediaKeysCallbacks();
     isTypeSupported = callbacks.isTypeSupported;
     createCustomMediaKeys = callbacks.createCustomMediaKeys;
-    _setMediaKeys = callbacks.setMediaKeys;
+    setMediaKeys = callbacks.setMediaKeys;
   } else {
     const MK = window.MediaKeys as unknown as typeof MediaKeys & {
       isTypeSupported? : (keyType : string) => boolean;
@@ -155,9 +152,9 @@ if (isNode ||
   requestMediaKeySystemAccess = function(
     keyType : string,
     keySystemConfigurations : MediaKeySystemConfiguration[]
-  ) : Observable<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
+  ) : Promise<MediaKeySystemAccess|CustomMediaKeySystemAccess> {
     if (!isTypeSupported(keyType)) {
-      return observableThrow(() => new Error("Unsupported key type"));
+      return PPromise.reject(new Error("Unsupported key type"));
     }
 
     for (let i = 0; i < keySystemConfigurations.length; i++) {
@@ -173,18 +170,22 @@ if (isNode ||
       supported = supported && (distinctiveIdentifier !== "required");
 
       if (supported) {
-        const keySystemConfigurationResponse = {
-          videoCapabilities,
-          audioCapabilities,
+        const keySystemConfigurationResponse : MediaKeySystemConfiguration = {
           initDataTypes: ["cenc"],
           distinctiveIdentifier: "not-allowed" as const,
           persistentState: "required" as const,
           sessionTypes: ["temporary", "persistent-license"],
         };
+        if (videoCapabilities !== undefined) {
+          keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
+        }
+        if (audioCapabilities !== undefined) {
+          keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
+        }
 
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const customMediaKeys = createCustomMediaKeys(keyType);
-        return observableOf(
+        return PPromise.resolve(
           new CustomMediaKeySystemAccess(keyType,
                                          customMediaKeys,
                                          keySystemConfigurationResponse)
@@ -192,24 +193,10 @@ if (isNode ||
       }
     }
 
-    return observableThrow(() => new Error("Unsupported configuration"));
+    return PPromise.reject(new Error("Unsupported configuration"));
   };
 }
 
-/**
- * Set the given MediaKeys on the given HTMLMediaElement.
- * Emits null when done then complete.
- * @param {HTMLMediaElement} elt
- * @param {Object} mediaKeys
- * @returns {Observable}
- */
-function setMediaKeys(
-  elt : HTMLMediaElement,
-  mediaKeys : MediaKeys|ICustomMediaKeys|null
-) : Observable<unknown> {
-  return observableDefer(() => castToObservable(_setMediaKeys(elt, mediaKeys)));
-}
-
 export {
   requestMediaKeySystemAccess,
   setMediaKeys,

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

@@ -14,16 +14,11 @@
  * limitations under the License.
  */
 
-import {
-  merge as observableMerge,
-  Subject,
-  takeUntil,
-} from "rxjs";
 import { base64ToBytes } from "../../../utils/base64";
 import EventEmitter from "../../../utils/event_emitter";
+import noop from "../../../utils/noop";
 import PPromise from "../../../utils/promise";
 import { utf8ToStr } from "../../../utils/string_parsing";
-import * as events from "../../event_listeners";
 import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
@@ -54,11 +49,16 @@ export function isOldWebkitMediaElement(
     .webkitGenerateKeyRequest === "function";
 }
 
+/**
+ * MediaKeySession implementation for older versions of WebKit relying on APIs
+ * such as `webkitGenerateKeyRequest` `webkitAddKey` to be called on the
+ * HTMLMediaElement.
+ * @class OldWebkitMediaKeySession
+ */
 class OldWebkitMediaKeySession
   extends EventEmitter<IMediaKeySessionEvents>
   implements ICustomMediaKeySession
 {
-  public readonly update: (license: Uint8Array) => Promise<void>;
   public readonly closed: Promise<void>;
   public expiration: number;
   public keyStatuses: ICustomMediaKeyStatusMap;
@@ -66,76 +66,93 @@ class OldWebkitMediaKeySession
 
   private readonly _vid: IOldWebkitHTMLMediaElement;
   private readonly _key: string;
-  private readonly _closeSession$: Subject<void>;
+
+  private readonly _onSessionRelatedEvent : (evt : Event) => void;
+  private _closeSession : () => void;
 
   constructor(mediaElement: IOldWebkitHTMLMediaElement, keySystem: string) {
     super();
-    this._closeSession$ = new Subject();
     this._vid = mediaElement;
     this._key = keySystem;
 
     this.sessionId = "";
+    this._closeSession = noop; // Just here to make TypeScript happy
     this.closed = new PPromise((resolve) => {
-      this._closeSession$.subscribe(resolve);
+      this._closeSession = resolve;
     });
     this.keyStatuses = new Map();
     this.expiration = NaN;
 
-    observableMerge(events.onKeyMessage$(mediaElement),
-                    events.onKeyAdded$(mediaElement),
-                    events.onKeyError$(mediaElement))
-      .pipe(takeUntil(this._closeSession$))
-      .subscribe((evt: Event) => this.trigger(evt.type, evt));
-
-    this.update = (license: Uint8Array) => {
-      return new PPromise((resolve, reject) => {
-        try {
-          if (this._key.indexOf("clearkey") >= 0) {
-            const licenseTypedArray =
-              license instanceof ArrayBuffer ? new Uint8Array(license) :
-                                               license;
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-disable @typescript-eslint/no-unsafe-argument */
-            /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-            const json = JSON.parse(utf8ToStr(licenseTypedArray));
-            const key = base64ToBytes(json.keys[0].k);
-            const kid = base64ToBytes(json.keys[0].kid);
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-enable @typescript-eslint/no-unsafe-argument */
-            /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-            resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
-          } else {
-            resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));
-          }
-        } catch (err) {
-          reject(err);
-        }
-      });
+    this._onSessionRelatedEvent = (evt : Event) => {
+      this.trigger(evt.type, evt);
     };
+
+    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+      .forEach(evt => mediaElement.addEventListener(evt, this._onSessionRelatedEvent));
   }
 
-  generateRequest(_initDataType: string, initData: ArrayBuffer): Promise<void> {
+  public update(license: Uint8Array) : Promise<void> {
+    return new PPromise((resolve, reject) => {
+      try {
+        if (this._key.indexOf("clearkey") >= 0) {
+          const licenseTypedArray =
+            license instanceof ArrayBuffer ? new Uint8Array(license) :
+            license;
+          /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+          /* eslint-disable @typescript-eslint/no-unsafe-argument */
+          /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+          const json = JSON.parse(utf8ToStr(licenseTypedArray));
+          const key = base64ToBytes(json.keys[0].k);
+          const kid = base64ToBytes(json.keys[0].kid);
+          /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+          /* eslint-enable @typescript-eslint/no-unsafe-argument */
+          /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+          resolve(this._vid.webkitAddKey(this._key, key, kid, /* sessionId */ ""));
+        } else {
+          resolve(this._vid.webkitAddKey(this._key, license, null, /* sessionId */ ""));
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  public generateRequest(
+    _initDataType: string,
+    initData: ArrayBuffer
+  ): Promise<void> {
     return new PPromise((resolve) => {
       this._vid.webkitGenerateKeyRequest(this._key, initData);
       resolve();
     });
   }
 
-  close(): Promise<void> {
+  public close(): Promise<void> {
     return new PPromise((resolve) => {
-      this._closeSession$.next();
-      this._closeSession$.complete();
+      this._unbindSession();
+      this._closeSession();
       resolve();
     });
   }
 
-  load(): Promise<boolean> {
+  /**
+   * Load a Persistent MediaKeySession.
+   * Do nothing here because this implementation doesn't handle them.
+   * @returns {Promise.<boolean>}
+   */
+  public load(): Promise<boolean> {
+    // Not implemented. Always return false as in "no session with that id".
     return PPromise.resolve(false);
   }
 
-  remove(): Promise<void> {
+  public remove(): Promise<void> {
     return PPromise.resolve();
   }
+
+  private _unbindSession() {
+    ["keymessage", "message", "keyadded", "ready", "keyerror", "error"]
+      .forEach(evt => this._vid.removeEventListener(evt, this._onSessionRelatedEvent));
+  }
 }
 
 class OldWebKitCustomMediaKeys implements ICustomMediaKeys {