rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/src/core/decrypt/dispose_decryption_resources.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { setMediaKeys } from "../../compat";
 import log from "../../log";
+import sleep from "../../utils/sleep";
 import MediaKeysInfosStore from "./utils/media_keys_infos_store";
 
 /**
@@ -25,15 +25,30 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  */
 export default async function disposeDecryptionResources(
   mediaElement : HTMLMediaElement
-) : Promise<void> {
+) : Promise<unknown> {
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   if (currentState === null) {
-    return ;
+    return undefined;
   }
 
   log.info("DRM: Disposing of the current MediaKeys");
   const { loadedSessionsStore } = currentState;
   MediaKeysInfosStore.clearState(mediaElement);
   await loadedSessionsStore.closeAllSessions();
-  setMediaKeys(mediaElement, null);
+
+  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),
+    ]
+  );
 }

package/src/core/decrypt/find_key_system.ts

@@ -15,10 +15,11 @@
  */
 
 import {
-  ICustomMediaKeySystemAccess,
-  requestMediaKeySystemAccess,
   shouldRenewMediaKeySystemAccess,
 } from "../../compat";
+import eme, {
+  ICustomMediaKeySystemAccess,
+} from "../../compat/eme";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
@@ -279,20 +280,22 @@ export default function getMediaKeySystemAccess(
 ) : Promise<IFoundMediaKeySystemAccessEvent> {
   log.info("DRM: Searching for compatible MediaKeySystemAccess");
   const currentState = MediaKeysInfosStore.getState(mediaElement);
-  if (currentState != null) {
-    // Fast way to find a compatible keySystem if the currently loaded
-    // one as exactly the same compatibility options.
-    const cachedKeySystemAccess =
-      checkCachedMediaKeySystemAccess(keySystemsConfigs,
-                                      currentState.mediaKeySystemAccess,
-                                      currentState.keySystemOptions);
-    if (cachedKeySystemAccess !== null) {
-      log.info("DRM: Found cached compatible keySystem");
-      return Promise.resolve({
-        type: "reuse-media-key-system-access" as const,
-        value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-                 options: cachedKeySystemAccess.keySystemOptions },
-      });
+  if (currentState !== null) {
+    if (eme.implementation === currentState.emeImplementation.implementation) {
+      // Fast way to find a compatible keySystem if the currently loaded
+      // one as exactly the same compatibility options.
+      const cachedKeySystemAccess =
+        checkCachedMediaKeySystemAccess(keySystemsConfigs,
+                                        currentState.mediaKeySystemAccess,
+                                        currentState.keySystemOptions);
+      if (cachedKeySystemAccess !== null) {
+        log.info("DRM: Found cached compatible keySystem");
+        return Promise.resolve({
+          type: "reuse-media-key-system-access" as const,
+          value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
+                   options: cachedKeySystemAccess.keySystemOptions },
+        });
+      }
     }
   }
 
@@ -351,7 +354,7 @@ export default function getMediaKeySystemAccess(
 
     }
 
-    if (requestMediaKeySystemAccess == null) {
+    if (eme.requestMediaKeySystemAccess == null) {
       throw new Error("requestMediaKeySystemAccess is not implemented in your browser.");
     }
 
@@ -364,8 +367,10 @@ export default function getMediaKeySystemAccess(
               `${index + 1} of ${keySystemsType.length}`);
 
     try {
-      const keySystemAccess = await requestMediaKeySystemAccess(keyType,
-                                                                keySystemConfigurations);
+      const keySystemAccess = await eme.requestMediaKeySystemAccess(
+        keyType,
+        keySystemConfigurations
+      );
       log.info("DRM: Found compatible keysystem", keyType, index + 1);
       return { type: "create-media-key-system-access" as const,
                value: { options: keySystemOptions,

package/src/core/decrypt/get_media_keys.ts

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
+import { canReuseMediaKeys } from "../../compat";
 import {
-  canReuseMediaKeys,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-} from "../../compat";
+} from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import { IKeySystemOption } from "../../public_types";

package/src/core/decrypt/index.ts

@@ -20,10 +20,7 @@
  */
 
 import clearOnStop from "./clear_on_stop";
-import ContentDecryptor, {
-  ContentDecryptorState,
-  IContentDecryptorEvent,
-} from "./content_decryptor";
+import ContentDecryptor from "./content_decryptor";
 import disposeDecryptionResources from "./dispose_decryption_resources";
 import getKeySystemConfiguration from "./get_key_system_configuration";
 export * from "./types";
@@ -31,8 +28,6 @@ export * from "./types";
 export default ContentDecryptor;
 export {
   clearOnStop,
-  ContentDecryptorState,
   disposeDecryptionResources,
   getKeySystemConfiguration,
-  IContentDecryptorEvent,
 };

package/src/core/decrypt/session_events_listener.ts

@@ -14,10 +14,8 @@
  * limitations under the License.
  */
 
-import {
-  events,
-  ICustomMediaKeySession,
-} from "../../compat";
+import { events } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat/eme";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import {
@@ -236,6 +234,7 @@ export interface ISessionEventListenerCallbacks {
    */
   onKeyUpdate : (val : IKeyUpdateValue) => void;
   onWarning : (val : IPlayerError) => void;
+  /* eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents */
   onError : (val : unknown | BlacklistedSessionError) => void;
 }
 

package/src/core/decrypt/set_server_certificate.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeys } from "../../compat";
+import { ICustomMediaKeys } from "../../compat/eme";
 import {
   EncryptedMediaError,
   isKnownError,

package/src/core/decrypt/types.ts

@@ -19,10 +19,79 @@ import Manifest, {
   Period,
   Representation,
 } from "../../manifest";
+import { IPlayerError } from "../../public_types";
 import InitDataValuesContainer from "./utils/init_data_values_container";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 import PersistentSessionsStore from "./utils/persistent_sessions_store";
 
+/** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */
+export interface IContentDecryptorEvent {
+  /**
+   * Event emitted when a major error occured which made the ContentDecryptor
+   * stopped.
+   * When that event is sent, the `ContentDecryptor` is in the `Error` state and
+   * cannot be used anymore.
+   */
+  error : Error;
+
+  /**
+   * Event emitted when a minor error occured which the ContentDecryptor can
+   * recover from.
+   */
+  warning : IPlayerError;
+
+  /**
+   * Event emitted when the `ContentDecryptor`'s state changed.
+   * States are a central aspect of the `ContentDecryptor`, be sure to check the
+   * ContentDecryptorState type.
+   */
+  stateChange: ContentDecryptorState;
+}
+
+/** Enumeration of the various "state" the `ContentDecryptor` can be in. */
+export enum ContentDecryptorState {
+  /**
+   * The `ContentDecryptor` is not yet ready to create key sessions and request
+   * licenses.
+   * This is is the initial state of the ContentDecryptor.
+   */
+  Initializing,
+
+  /**
+   * The `ContentDecryptor` has been initialized.
+   * You should now called the `attach` method when you want to add decryption
+   * capabilities to the HTMLMediaElement. The ContentDecryptor won't go to the
+   * `ReadyForContent` state until `attach` is called.
+   *
+   * For compatibility reasons, this should be done after the HTMLMediaElement's
+   * src attribute is set.
+   *
+   * It is also from when this state is reached that the `ContentDecryptor`'s
+   * `systemId` property may be known.
+   *
+   * This state is always coming after the `Initializing` state.
+   */
+  WaitingForAttachment,
+
+  /**
+   * Content (encrypted or not) can begin to be pushed on the HTMLMediaElement
+   * (this state was needed because some browser quirks sometimes forces us to
+   * call EME API before this can be done).
+   *
+   * This state is always coming after the `WaitingForAttachment` state.
+   */
+  ReadyForContent,
+
+  /**
+   * The `ContentDecryptor` has encountered a fatal error and has been stopped.
+   * It is now unusable.
+   */
+  Error,
+
+  /** The `ContentDecryptor` has been disposed of and is now unusable. */
+  Disposed,
+}
+
 /** Information about the encryption initialization data. */
 export interface IProtectionData {
   /**

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../../compat";
+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";

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../../compat";
+import { ICustomMediaKeySession } from "../../../compat/eme";
 import log from "../../../log";
 import arrayIncludes from "../../../utils/array_includes";
 

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

@@ -16,31 +16,6 @@
 
 import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
 
-/**
- * Returns `true` if both given key id appear to be equal.
- * @param {Uint8Array} keyId1
- * @param {Uint8Array} keyId2
- * @returns {boolean}
- */
-export function areKeyIdsEqual(
-  keyId1 : Uint8Array,
-  keyId2 : Uint8Array
-) : boolean {
-  return keyId1 === keyId2 || areArraysOfNumbersEqual(keyId1, keyId2);
-}
-
-/**
- * @param {Uint8Array} wantedKeyId
- * @param {Array.<Uint8Array>} keyIdsArr
- * @returns {boolean}
- */
-export function isKeyIdContainedIn(
-  wantedKeyId : Uint8Array,
-  keyIdsArr : Uint8Array[]
-) : boolean {
-  return keyIdsArr.some(k => areKeyIdsEqual(k, wantedKeyId));
-}
-
 /**
  * Returns `true` if all key ids in `wantedKeyIds` are present in the
  * `keyIdsArr` array.
@@ -53,7 +28,7 @@ export function areAllKeyIdsContainedIn(
   keyIdsArr : Uint8Array[]
 ) : boolean {
   for (const keyId of wantedKeyIds) {
-    const found = keyIdsArr.some(k => areKeyIdsEqual(k, keyId));
+    const found = keyIdsArr.some(k => areArraysOfNumbersEqual(k, keyId));
     if (!found) {
       return false;
     }
@@ -73,7 +48,7 @@ export function areSomeKeyIdsContainedIn(
   keyIdsArr : Uint8Array[]
 ) : boolean {
   for (const keyId of wantedKeyIds) {
-    const found = keyIdsArr.some(k => areKeyIdsEqual(k, keyId));
+    const found = keyIdsArr.some(k => areArraysOfNumbersEqual(k, keyId));
     if (found) {
       return true;
     }

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

@@ -14,11 +14,9 @@
  * limitations under the License.
  */
 
+import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
 import { IProcessedProtectionData } from "../types";
-import {
-  areKeyIdsEqual,
-  areAllKeyIdsContainedIn,
-} from "./key_id_comparison";
+import { areAllKeyIdsContainedIn } from "./key_id_comparison";
 
 /**
  * Class storing key-related information linked to a created `MediaKeySession`.
@@ -107,7 +105,7 @@ export default class KeySessionRecord {
       return false;
     }
     for (const storedKeyId of this._keyIds) {
-      if (areKeyIdsEqual(storedKeyId, keyId)) {
+      if (areArraysOfNumbersEqual(storedKeyId, keyId)) {
         return true;
       }
     }

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

@@ -20,7 +20,7 @@ import {
   ICustomMediaKeys,
   ICustomMediaKeySession,
   loadSession,
-} from "../../../compat";
+} from "../../../compat/eme";
 import log from "../../../log";
 import assert from "../../../utils/assert";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
@@ -47,7 +47,7 @@ export default class LoadedSessionsStore {
    * loaded MediaKeySessions on the given MediaKeys instance.
    * @param {MediaKeys} mediaKeys
    */
-  constructor(mediaKeys : MediaKeys|ICustomMediaKeys) {
+  constructor(mediaKeys : MediaKeys | ICustomMediaKeys) {
     this._mediaKeys = mediaKeys;
     this._storage = [];
   }

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

@@ -17,12 +17,15 @@
 import {
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
-} from "../../../compat";
+  IEmeApiImplementation,
+} from "../../../compat/eme";
 import { IKeySystemOption } from "../../../public_types";
 import LoadedSessionsStore from "./loaded_sessions_store";
 
 /** DRM-related state that can be associated to a single HTMLMediaElement. */
 export interface IMediaElementMediaKeysInfos {
+  emeImplementation : IEmeApiImplementation;
+
   /** Last keySystemOptions used with that HTMLMediaElement. */
   keySystemOptions : IKeySystemOption;
 

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeySession } from "../../../compat";
+import { ICustomMediaKeySession } from "../../../compat/eme";
 import log from "../../../log";
 import {
   IPersistentLicenseConfig,
@@ -29,7 +29,6 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import { IProcessedProtectionData } from "../types";
 import areInitializationValuesCompatible from "./are_init_values_compatible";
 import { IFormattedInitDataValue } from "./init_data_values_container";
-import { areKeyIdsEqual } from "./key_id_comparison";
 import SerializableBytes from "./serializable_bytes";
 
 /**
@@ -256,9 +255,7 @@ export default class PersistentSessionsStore {
                     if (keyIdB64 === entryKid) {
                       return true;
                     }
-                  } else if (areKeyIdsEqual(entryKid.initData,
-                                            keyId))
-                  {
+                  } else if (areArraysOfNumbersEqual(entryKid.initData, keyId)) {
                     return true;
                   }
                 }

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { ICustomMediaKeys } from "../../../compat";
+import { ICustomMediaKeys } from "../../../compat/eme";
 import hashBuffer from "../../../utils/hash_buffer";
 
 /**

package/src/core/fetchers/cdn_prioritizer.ts

@@ -121,7 +121,7 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
     const { DEFAULT_CDN_DOWNGRADE_TIME } = config.getCurrent();
     const downgradeTime = DEFAULT_CDN_DOWNGRADE_TIME;
     this._downgradedCdnList.metadata.push(metadata);
-    const timeout = window.setTimeout(() => {
+    const timeout = setTimeout(() => {
       const newIndex = indexOfMetadata(this._downgradedCdnList.metadata, metadata);
       if (newIndex >= 0) {
         this._removeIndexFromDowngradeList(newIndex);

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -30,6 +30,7 @@ import {
 } from "../../../transports";
 import EventEmitter from "../../../utils/event_emitter";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import getMonotonicTimeStamp from "../../../utils/monotonic_timestamp";
 import noop from "../../../utils/noop";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
@@ -282,7 +283,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     parserOptions : IManifestFetcherParserOptions,
     requestUrl : string | undefined
   ) : Promise<IManifestFetcherParsedResult> {
-    const parsingTimeStart = performance.now();
+    const parsingTimeStart = getMonotonicTimeStamp();
     const cancelSignal = this._canceller.signal;
     const trigger = this.trigger.bind(this);
     const { sendingTime, receivedTime } = loaded;
@@ -302,10 +303,10 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
                                                 cancelSignal,
                                                 scheduleRequest);
       if (!isPromise(res)) {
-        return finish(res.manifest);
+        return finish(res.manifest, res.warnings);
       } else {
-        const { manifest } = await res;
-        return finish(manifest);
+        const { manifest, warnings } = await res;
+        return finish(manifest, warnings);
       }
     } catch (err) {
       const formattedError = formatError(err, {
@@ -356,9 +357,12 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
      * To call once the Manifest has been parsed.
      * @param {Object} manifest
      */
-    function finish(manifest : Manifest) : IManifestFetcherParsedResult {
-      onWarnings(manifest.contentWarnings);
-      const parsingTime = performance.now() - parsingTimeStart;
+    function finish(
+      manifest : Manifest,
+      warnings: IPlayerError[]
+    ) : IManifestFetcherParsedResult {
+      onWarnings(warnings);
+      const parsingTime = getMonotonicTimeStamp() - parsingTimeStart;
       log.info(`MF: Manifest parsed in ${parsingTime}ms`);
 
       return { manifest,
@@ -432,7 +436,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     /** Time elapsed since the beginning of the Manifest request, in milliseconds. */
     const timeSinceRequest = sendingTime === undefined ?
       0 :
-      performance.now() - sendingTime;
+      getMonotonicTimeStamp() - sendingTime;
 
     /** Minimum update delay we should not go below, in milliseconds. */
     const minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
@@ -455,7 +459,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
       // (to avoid asking for it too often).
       const timeSinceLastRefresh = sendingTime === undefined ?
                                      0 :
-                                     performance.now() - sendingTime;
+                                     getMonotonicTimeStamp() - sendingTime;
       const _minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
                                       timeSinceLastRefresh,
                                     0);
@@ -595,7 +599,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
         const { manifest: newManifest,
                 sendingTime: newSendingTime,
                 parsingTime } = res;
-        const updateTimeStart = performance.now();
+        const updateTimeStart = getMonotonicTimeStamp();
 
         if (fullRefresh) {
           manifest.replace(newManifest);
@@ -612,8 +616,8 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
             // The value allows to set a delay relatively to the last Manifest refresh
             // (to avoid asking for it too often).
             const timeSinceLastRefresh = newSendingTime === undefined ?
-                                           0 :
-                                           performance.now() - newSendingTime;
+              0 :
+              getMonotonicTimeStamp() - newSendingTime;
             const _minInterval = Math.max(this._settings.minimumManifestUpdateInterval -
                                             timeSinceLastRefresh,
                                           0);
@@ -632,7 +636,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
             return;
           }
         }
-        const updatingTime = performance.now() - updateTimeStart;
+        const updatingTime = getMonotonicTimeStamp() - updateTimeStart;
         this._recursivelyRefreshManifest(manifest, { sendingTime: newSendingTime,
                                                      parsingTime,
                                                      updatingTime });
@@ -667,11 +671,11 @@ interface IManifestFetcherParsedResult {
   /** The resulting Manifest */
   manifest : Manifest;
   /**
-   * The time (`performance.now()`) at which the request was started (at which
-   * the JavaScript call was done).
+   * Monotonically-raising timestamp (common one used by the RxPlayer's logic)
+   * at which the request was started (at which the JavaScript call was done).
    */
   sendingTime? : number | undefined;
-  /** The time (`performance.now()`) at which the request was fully received. */
+  /** Monotonically-raising timestamp at which the request was fully received. */
   receivedTime? : number | undefined;
   /* The time taken to parse the Manifest through the corresponding parse function. */
   parsingTime? : number | undefined;
@@ -686,8 +690,8 @@ interface IManifestFetcherResponse {
 
 interface IManifestFetcherParserOptions {
   /**
-   * If set, offset to add to `performance.now()` to obtain the current
-   * server's time.
+   * If set, offset to add to the monotonically-raising timestamp used by the
+   * RxPlayer to obtain the current server's time.
    */
   externalClockOffset? : number | undefined;
   /** The previous value of the Manifest (when updating). */

package/src/core/fetchers/segment/segment_fetcher.ts

@@ -38,6 +38,7 @@ import arrayIncludes from "../../../utils/array_includes";
 import idGenerator from "../../../utils/id_generator";
 import InitializationSegmentCache from "../../../utils/initialization_segment_cache";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import getTimestamp from "../../../utils/monotonic_timestamp";
 import objectAssign from "../../../utils/object_assign";
 import {
   CancellationError,
@@ -179,7 +180,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
           lifecycleCallbacks.onProgress?.({ duration: info.duration,
                                             size: info.size,
                                             totalSize: info.totalSize,
-                                            timestamp: performance.now(),
+                                            timestamp: getTimestamp(),
                                             id: requestId });
         }
       },
@@ -205,7 +206,7 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
     }
 
     log.debug("SF: Beginning request", segmentIdString);
-    lifecycleCallbacks.onRequestBegin?.({ requestTimestamp: performance.now(),
+    lifecycleCallbacks.onRequestBegin?.({ requestTimestamp: getTimestamp(),
                                           id: requestId,
                                           content });
 

package/src/core/fetchers/utils/schedule_request.ts

@@ -24,6 +24,7 @@ import log from "../../../log";
 import { ICdnMetadata } from "../../../parsers/manifest";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
+import getTimestamp from "../../../utils/monotonic_timestamp";
 import noop from "../../../utils/noop";
 import TaskCanceller, {
   CancellationSignal,
@@ -248,7 +249,7 @@ export async function scheduleRequestWithCdns<T>(
         const delay = Math.min(baseDelay * Math.pow(2, errorCounter - 1),
                                maxDelay);
         const fuzzedDelay = getFuzzedDelay(delay);
-        missedAttemptsObj.blockedUntil = performance.now() + fuzzedDelay;
+        missedAttemptsObj.blockedUntil = getTimestamp() + fuzzedDelay;
       }
 
       return retryWithNextCdn(error);
@@ -303,7 +304,7 @@ export async function scheduleRequestWithCdns<T>(
       return requestCdn(nextWantedCdn);
     }
 
-    const now = performance.now();
+    const now = getTimestamp();
     const blockedFor = nextCdnAttemptObj.blockedUntil - now;
     if (blockedFor <= 0) {
       return requestCdn(nextWantedCdn);
@@ -360,7 +361,7 @@ export async function scheduleRequestWithCdns<T>(
     if (missedAttempts.size === 0) {
       return sortedCdns[0];
     }
-    const now = performance.now();
+    const now = getTimestamp();
     return sortedCdns
       .filter(c =>  missedAttempts.get(c)?.isBlacklisted !== true)
       .reduce((
@@ -427,8 +428,8 @@ interface ICdnAttemptMetadata {
    */
   errorCounter : number;
   /**
-   * Timestamp, in terms of `performance.now()`, until which it should be
-   * forbidden to request this CDN.
+   * Monotonically-raising timestamp, until which it should be forbidden to
+   * request this CDN.
    * Enforcing this delay allows to prevent making too much requests to a given
    * CDN.
    *