rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

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

@@ -24,6 +24,7 @@
 
 import {
   MediaKeysImpl,
+  MediaKeySystemAccessImpl,
   mockCompat,
   testContentDecryptorError,
 } from "./utils";
@@ -104,6 +105,8 @@ describe("core - decrypt - global tests - media key system access", () => {
   /* eslint-enable max-len */
     return new Promise<void>((res, rej) => {
       mockCompat({});
+      const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
+                                             "createMediaKeys");
       const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
       const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
       const contentDecryptor = new ContentDecryptor(videoElt, ksConfig);
@@ -112,6 +115,7 @@ describe("core - decrypt - global tests - media key system access", () => {
         receivedStateChange++;
         try {
           expect(newState).toEqual(ContentDecryptorState.WaitingForAttachment);
+          expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
         } catch (err) { rej(err); }
         setTimeout(() => {
           try {
@@ -126,6 +130,184 @@ describe("core - decrypt - global tests - media key system access", () => {
     });
   });
 
+  /* eslint-disable max-len */
+  it("should not call createMediaKeys again if previous one is compatible", () => {
+  /* eslint-enable max-len */
+    return new Promise<void>((res, rej) => {
+      mockCompat({});
+      const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
+                                             "createMediaKeys");
+      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
+
+      const contentDecryptor1 = new ContentDecryptor(videoElt, ksConfig);
+      let receivedStateChange1 = 0;
+      contentDecryptor1.addEventListener("error", rej);
+      contentDecryptor1.addEventListener("stateChange", (state1: any) => {
+        receivedStateChange1++;
+        try {
+          if (receivedStateChange1 === 2) {
+            expect(state1).toEqual(ContentDecryptorState.ReadyForContent);
+            return;
+          } else if (receivedStateChange1 !== 1) {
+            throw new Error("Unexpected stateChange event.");
+          }
+          expect(state1).toEqual(ContentDecryptorState.WaitingForAttachment);
+          expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
+          contentDecryptor1.attach();
+        } catch (err) { rej(err); }
+
+        setTimeout(() => {
+          contentDecryptor1.dispose();
+          const contentDecryptor2 = new ContentDecryptor(videoElt, ksConfig);
+          let receivedStateChange2 = 0;
+          contentDecryptor2.addEventListener("error", rej);
+          contentDecryptor2.addEventListener("stateChange", (state2: any) => {
+            receivedStateChange2++;
+            try {
+              if (receivedStateChange2 === 2) {
+                expect(state2).toEqual(ContentDecryptorState.ReadyForContent);
+                return;
+              } else if (receivedStateChange2 !== 1) {
+                throw new Error("Unexpected stateChange event.");
+              }
+              expect(state2).toEqual(ContentDecryptorState.WaitingForAttachment);
+              expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
+              contentDecryptor2.attach();
+              setTimeout(() => {
+                try {
+                  contentDecryptor2.dispose();
+                  expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
+                  res();
+                } catch (err) { rej(err); }
+              });
+            } catch (err) { rej(err); }
+          });
+        }, 10);
+      });
+    });
+  });
+
+  /* eslint-disable max-len */
+  it("should call createMediaKeys again if the platform needs re-creation of the MediaKeys", () => {
+  /* eslint-enable max-len */
+    return new Promise<void>((res, rej) => {
+      mockCompat({
+        canReuseMediaKeys: jest.fn(() => false),
+      });
+      const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
+                                             "createMediaKeys");
+      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
+
+      const contentDecryptor1 = new ContentDecryptor(videoElt, ksConfig);
+      let receivedStateChange1 = 0;
+      contentDecryptor1.addEventListener("error", rej);
+      contentDecryptor1.addEventListener("stateChange", (state1: any) => {
+        receivedStateChange1++;
+        try {
+          if (receivedStateChange1 === 2) {
+            expect(state1).toEqual(ContentDecryptorState.ReadyForContent);
+            return;
+          } else if (receivedStateChange1 !== 1) {
+            throw new Error("Unexpected stateChange event.");
+          }
+          expect(state1).toEqual(ContentDecryptorState.WaitingForAttachment);
+          expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
+          contentDecryptor1.attach();
+        } catch (err) { rej(err); }
+
+        setTimeout(() => {
+          contentDecryptor1.dispose();
+          const contentDecryptor2 = new ContentDecryptor(videoElt, ksConfig);
+          let receivedStateChange2 = 0;
+          contentDecryptor2.addEventListener("error", rej);
+          contentDecryptor2.addEventListener("stateChange", (state2: any) => {
+            receivedStateChange2++;
+            try {
+              if (receivedStateChange2 === 2) {
+                expect(state2).toEqual(ContentDecryptorState.ReadyForContent);
+                return;
+              } else if (receivedStateChange2 !== 1) {
+                throw new Error("Unexpected stateChange event.");
+              }
+              expect(state2).toEqual(ContentDecryptorState.WaitingForAttachment);
+              expect(mockCreateMediaKeys).toHaveBeenCalledTimes(2);
+              contentDecryptor2.attach();
+              setTimeout(() => {
+                try {
+                  contentDecryptor2.dispose();
+                  expect(mockCreateMediaKeys).toHaveBeenCalledTimes(2);
+                  res();
+                } catch (err) { rej(err); }
+              });
+            } catch (err) { rej(err); }
+          });
+        }, 10);
+      });
+    });
+  });
+
+  /* eslint-disable max-len */
+  it("should not call createMediaKeys again if the platform needs MediaKeySystemAccess renewal", () => {
+  /* eslint-enable max-len */
+    return new Promise<void>((res, rej) => {
+      mockCompat({
+        shouldRenewMediaKeySystemAccess: jest.fn(() => true),
+      });
+      const mockCreateMediaKeys = jest.spyOn(MediaKeySystemAccessImpl.prototype,
+                                             "createMediaKeys");
+      const { ContentDecryptorState } = jest.requireActual("../../content_decryptor");
+      const ContentDecryptor = jest.requireActual("../../content_decryptor").default;
+
+      const contentDecryptor1 = new ContentDecryptor(videoElt, ksConfig);
+      let receivedStateChange1 = 0;
+      contentDecryptor1.addEventListener("error", rej);
+      contentDecryptor1.addEventListener("stateChange", (state1: any) => {
+        receivedStateChange1++;
+        try {
+          if (receivedStateChange1 === 2) {
+            expect(state1).toEqual(ContentDecryptorState.ReadyForContent);
+            return;
+          } else if (receivedStateChange1 !== 1) {
+            throw new Error("Unexpected stateChange event.");
+          }
+          expect(state1).toEqual(ContentDecryptorState.WaitingForAttachment);
+          expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
+          contentDecryptor1.attach();
+        } catch (err) { rej(err); }
+
+        setTimeout(() => {
+          contentDecryptor1.dispose();
+          const contentDecryptor2 = new ContentDecryptor(videoElt, ksConfig);
+          let receivedStateChange2 = 0;
+          contentDecryptor2.addEventListener("error", rej);
+          contentDecryptor2.addEventListener("stateChange", (state2: any) => {
+            receivedStateChange2++;
+            try {
+              if (receivedStateChange2 === 2) {
+                expect(state2).toEqual(ContentDecryptorState.ReadyForContent);
+                return;
+              } else if (receivedStateChange2 !== 1) {
+                throw new Error("Unexpected stateChange event.");
+              }
+              expect(state2).toEqual(ContentDecryptorState.WaitingForAttachment);
+              expect(mockCreateMediaKeys).toHaveBeenCalledTimes(2);
+              contentDecryptor2.attach();
+              setTimeout(() => {
+                try {
+                  contentDecryptor2.dispose();
+                  expect(mockCreateMediaKeys).toHaveBeenCalledTimes(2);
+                  res();
+                } catch (err) { rej(err); }
+              });
+            } catch (err) { rej(err); }
+          });
+        }, 10);
+      });
+    });
+  });
+
   /* eslint-disable max-len */
   it("should not create any session if no encrypted event was received", (done) => {
   /* eslint-enable max-len */

package/src/core/decrypt/__tests__/__global__/utils.ts

@@ -286,6 +286,8 @@ export function mockCompat(exportedFunctions = {}) {
       setMediaKeys: mockSetMediaKeys,
       getInitData: mockGetInitData,
       generateKeyRequest: mockGenerateKeyRequest,
+      shouldRenewMediaKeySystemAccess: jest.fn(() => false),
+      canReuseMediaKeys: jest.fn(() => true),
       ...exportedFunctions }));
 
   return { mockEvents,

package/src/core/decrypt/find_key_system.ts

@@ -17,7 +17,7 @@
 import {
   ICustomMediaKeySystemAccess,
   requestMediaKeySystemAccess,
-  shouldRenewMediaKeys,
+  shouldRenewMediaKeySystemAccess,
 } from "../../compat";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
@@ -74,7 +74,7 @@ function checkCachedMediaKeySystemAccess(
   keySystemAccess: MediaKeySystemAccess|ICustomMediaKeySystemAccess;
 } {
   const mksConfiguration = currentKeySystemAccess.getConfiguration();
-  if (shouldRenewMediaKeys() || mksConfiguration == null) {
+  if (shouldRenewMediaKeySystemAccess() || mksConfiguration == null) {
     return null;
   }
 
@@ -187,7 +187,7 @@ function buildKeySystemConfigurations(
   // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
 
   const videoCapabilities: IMediaCapability[] =
-    flatMap(audioRobustnesses, (robustness) =>
+    flatMap(videoRobustnesses, (robustness) =>
       ["video/mp4;codecs=\"avc1.4d401e\"",
        "video/mp4;codecs=\"avc1.42e01e\"",
        "video/webm;codecs=\"vp8\""].map(contentType => {

package/src/core/decrypt/get_media_keys.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  canReuseMediaKeys,
   ICustomMediaKeys,
   ICustomMediaKeySystemAccess,
 } from "../../compat";
@@ -95,7 +96,10 @@ export default async function getMediaKeysInfos(
   const currentState = MediaKeysInfosStore.getState(mediaElement);
   const persistentSessionsStore = createPersistentSessionsStorage(options);
 
-  if (currentState !== null && evt.type === "reuse-media-key-system-access") {
+  if (canReuseMediaKeys() &&
+      currentState !== null &&
+      evt.type === "reuse-media-key-system-access")
+  {
     const { mediaKeys, loadedSessionsStore } = currentState;
 
     // We might just rely on the currently attached MediaKeys instance.

package/src/core/fetchers/cdn_prioritizer.ts

@@ -0,0 +1,198 @@
+/**
+ * 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 config from "../../config";
+import { ICdnMetadata } from "../../parsers/manifest";
+import { IPlayerError } from "../../public_types";
+import arrayFindIndex from "../../utils/array_find_index";
+import EventEmitter from "../../utils/event_emitter";
+import { CancellationSignal } from "../../utils/task_canceller";
+
+/**
+ * Class signaling the priority between multiple CDN available for any given
+ * resource.
+ *
+ * This class might perform requests and schedule timeouts by itself to keep its
+ * internal list of CDN priority up-to-date.
+ * When it is not needed anymore, you should call the `dispose` method to clear
+ * all resources.
+ *
+ * @class CdnPrioritizer
+ */
+export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents> {
+  /**
+   * Structure keeping a list of CDN currently downgraded.
+   * Downgraded CDN immediately have a lower priority than any non-downgraded
+   * CDN for a specific amount of time.
+   */
+  private _downgradedCdnList : {
+    /**
+     * Metadata of downgraded CDN, sorted by the time at which they have
+     * been downgraded.
+     */
+    metadata : ICdnMetadata[];
+    /**
+     * Timeout ID (to give to `clearTimeout`) of elements in the `metadata`
+     * array, for the element at the same index in the `metadata` array.
+     *
+     * This structure has been writted as an object of two arrays of the same
+     * length, instead of an array of objects, to simplify the usage of the
+     * `metadata` array which is used considerably more than the `timeouts`
+     * array.
+     */
+    timeouts : number[];
+  };
+
+  /**
+   * @param {Object} destroySignal
+   */
+  constructor(destroySignal : CancellationSignal) {
+    super();
+    this._downgradedCdnList = { metadata: [], timeouts: [] };
+    destroySignal.register(() => {
+      for (const timeout of this._downgradedCdnList.timeouts) {
+        clearTimeout(timeout);
+      }
+      this._downgradedCdnList = { metadata: [], timeouts: [] };
+    });
+  }
+
+  /**
+   * From the list of __ALL__ CDNs available to a resource, return them in the
+   * order in which requests should be performed.
+   *
+   * Note: It is VERY important to include all CDN that are able to reach the
+   * wanted resource, even those which will in the end not be used anyway.
+   * If some CDN are not communicated, the `CdnPrioritizer` might wrongly
+   * consider that the current resource don't have any of the CDN prioritized
+   * internally and return other CDN which should have been forbidden if it knew
+   * about the other, non-used, ones.
+   *
+   * @param {Array.<string>} everyCdnForResource - Array of ALL available CDN
+   * able to reach the wanted resource - even those which might not be used in
+   * the end.
+   * @returns {Array.<Object>} - Array of CDN that can be tried to reach the
+   * resource, sorted by order of CDN preference, according to the
+   * `CdnPrioritizer`'s own list of priorities.
+   */
+  public getCdnPreferenceForResource(
+    everyCdnForResource : ICdnMetadata[]
+  ) : ICdnMetadata[] {
+    if (everyCdnForResource.length <= 1) {
+      // The huge majority of contents have only one CDN available.
+      // Here, prioritizing make no sense.
+      return everyCdnForResource;
+    }
+
+    return this._innerGetCdnPreferenceForResource(everyCdnForResource);
+  }
+
+  /**
+   * Limit usage of the CDN for a configured amount of time.
+   * Call this method if you encountered an issue with that CDN which leads you
+   * to want to prevent its usage currently.
+   *
+   * Note that the CDN can still be the preferred one if no other CDN exist for
+   * a wanted resource.
+   * @param {string} metadata
+   */
+  public downgradeCdn(metadata : ICdnMetadata) : void {
+    const indexOf = indexOfMetadata(this._downgradedCdnList.metadata, metadata);
+    if (indexOf >= 0) {
+      this._removeIndexFromDowngradeList(indexOf);
+    }
+
+    const { DEFAULT_CDN_DOWNGRADE_TIME } = config.getCurrent();
+    const downgradeTime = DEFAULT_CDN_DOWNGRADE_TIME;
+    this._downgradedCdnList.metadata.push(metadata);
+    const timeout = window.setTimeout(() => {
+      const newIndex = indexOfMetadata(this._downgradedCdnList.metadata, metadata);
+      if (newIndex >= 0) {
+        this._removeIndexFromDowngradeList(newIndex);
+      }
+      this.trigger("priorityChange", null);
+    }, downgradeTime);
+    this._downgradedCdnList.timeouts.push(timeout);
+    this.trigger("priorityChange", null);
+  }
+
+  /**
+   * From the list of __ALL__ CDNs available to a resource, return them in the
+   * order in which requests should be performed.
+   *
+   * Note: It is VERY important to include all CDN that are able to reach the
+   * wanted resource, even those which will in the end not be used anyway.
+   * If some CDN are not communicated, the `CdnPrioritizer` might wrongly
+   * consider that the current resource don't have any of the CDN prioritized
+   * internally and return other CDN which should have been forbidden if it knew
+   * about the other, non-used, ones.
+   *
+   * @param {Array.<string>} everyCdnForResource - Array of ALL available CDN
+   * able to reach the wanted resource - even those which might not be used in
+   * the end.
+   * @returns {Array.<string>} - Array of CDN that can be tried to reach the
+   * resource, sorted by order of CDN preference, according to the
+   * `CdnPrioritizer`'s own list of priorities.
+   */
+  private _innerGetCdnPreferenceForResource(
+    everyCdnForResource : ICdnMetadata[]
+  ) : ICdnMetadata[] {
+    const [allowedInOrder, downgradedInOrder] = everyCdnForResource
+      .reduce((acc : [ICdnMetadata[], ICdnMetadata[]], elt : ICdnMetadata) => {
+        if (this._downgradedCdnList.metadata.some(c => c.id === elt.id &&
+                                                       c.baseUrl === elt.baseUrl))
+        {
+          acc[1].push(elt);
+        } else {
+          acc[0].push(elt);
+        }
+        return acc;
+      }, [[], []]);
+    return allowedInOrder.concat(downgradedInOrder);
+  }
+
+  /**
+   * @param {number} index
+   */
+  private _removeIndexFromDowngradeList(index : number) : void {
+    this._downgradedCdnList.metadata.splice(index, 1);
+    const oldTimeout = this._downgradedCdnList.timeouts.splice(index, 1);
+    clearTimeout(oldTimeout[0]);
+  }
+}
+
+export interface ICdnPrioritizerEvents {
+  warnings : IPlayerError[];
+  priorityChange : null;
+}
+
+/**
+ * Find the index of the given CDN metadata in a CDN metadata array.
+ * Returns `-1` if not found.
+ * @param {Array.<Object>} arr
+ * @param {Object} elt
+ * @returns {number}
+ */
+function indexOfMetadata(
+  arr : ICdnMetadata[],
+  elt : ICdnMetadata
+) : number {
+  if (arr.length === 0) {
+    return -1;
+  }
+  return elt.id !== undefined ? arrayFindIndex(arr, m => m.id === elt.id) :
+                                arrayFindIndex(arr, m => m.baseUrl === elt.baseUrl);
+}

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

@@ -33,8 +33,8 @@ import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import {
   IBackoffSettings,
-  tryRequestPromiseWithBackoff,
-} from "../utils/try_urls_with_backoff";
+  scheduleRequestPromise,
+} from "../utils/schedule_request";
 
 
 /** What will be sent once parsed. */
@@ -228,9 +228,7 @@ export default class ManifestFetcher {
         const { resolveManifestUrl } = pipelines;
         assert(resolveManifestUrl !== undefined);
         const callResolver = () => resolveManifestUrl(resolverUrl, canceller.signal);
-        return tryRequestPromiseWithBackoff(callResolver,
-                                            backoffSettings,
-                                            canceller.signal);
+        return scheduleRequestPromise(callResolver, backoffSettings, canceller.signal);
       }
 
       /**
@@ -252,9 +250,7 @@ export default class ManifestFetcher {
         const callLoader = () => loadManifest(manifestUrl,
                                               { timeout: requestTimeout },
                                               canceller.signal);
-        return tryRequestPromiseWithBackoff(callLoader,
-                                            backoffSettings,
-                                            canceller.signal);
+        return scheduleRequestPromise(callLoader, backoffSettings, canceller.signal);
       }
     });
   }
@@ -349,9 +345,9 @@ export default class ManifestFetcher {
         performRequest : () => Promise<T>
       ) : Promise<T> {
         try {
-          const data = await tryRequestPromiseWithBackoff(performRequest,
-                                                          backoffSettings,
-                                                          canceller.signal);
+          const data = await scheduleRequestPromise(performRequest,
+                                                    backoffSettings,
+                                                    canceller.signal);
           return data;
         } catch (err) {
           throw errorSelector(err);

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

@@ -24,6 +24,7 @@ import Manifest, {
   Period,
   Representation,
 } from "../../../manifest";
+import { ICdnMetadata } from "../../../parsers/manifest";
 import { IPlayerError } from "../../../public_types";
 import {
   IChunkCompleteInformation,
@@ -49,8 +50,9 @@ import {
   IRequestProgressCallbackPayload,
 } from "../../adaptive";
 import { IBufferType } from "../../segment_buffers";
+import CdnPrioritizer from "../cdn_prioritizer";
 import errorSelector from "../utils/error_selector";
-import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
+import { scheduleRequestWithCdns } from "../utils/schedule_request";
 
 
 /** Allows to generate a unique identifies for each request. */
@@ -71,6 +73,7 @@ const generateRequestID = idGenerator();
 export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
   bufferType : IBufferType,
   pipeline : ISegmentPipeline<TLoadedFormat, TSegmentDataType>,
+  cdnPrioritizer : CdnPrioritizer | null,
   lifecycleCallbacks : ISegmentFetcherLifecycleCallbacks,
   options : ISegmentFetcherOptions
 ) : ISegmentFetcher<TSegmentDataType> {
@@ -102,8 +105,6 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
     fetcherCallbacks : ISegmentFetcherCallbacks<TSegmentDataType>,
     cancellationSignal : CancellationSignal
   ) : Promise<void> {
-    const { segment } = content;
-
     // used by logs
     const segmentIdString = getLoggableSegmentId(content);
     const requestId = generateRequestID();
@@ -193,10 +194,11 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
     });
 
     try {
-      const res = await tryURLsWithBackoff(segment.mediaURLs ?? [null],
-                                           callLoaderWithUrl,
-                                           objectAssign({ onRetry }, options),
-                                           cancellationSignal);
+      const res = await scheduleRequestWithCdns(content.representation.cdnMetadata,
+                                                cdnPrioritizer,
+                                                callLoaderWithUrl,
+                                                objectAssign({ onRetry }, options),
+                                                cancellationSignal);
 
       if (res.resultType === "segment-loaded") {
         const loadedData = res.resultData.responseData;
@@ -236,13 +238,13 @@ export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(
 
     /**
      * Call a segment loader for the given URL with the right arguments.
-     * @param {string|null} url
+     * @param {Object|null} cdnMetadata
      * @returns {Promise}
      */
     function callLoaderWithUrl(
-      url : string | null
+      cdnMetadata : ICdnMetadata | null
     ) : ReturnType<ISegmentLoader<TLoadedFormat>> {
-      return loadSegment(url,
+      return loadSegment(cdnMetadata,
                          content,
                          requestOptions,
                          cancellationSignal,

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

@@ -19,7 +19,9 @@ import {
   ISegmentPipeline,
   ITransportPipelines,
 } from "../../../transports";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { IBufferType } from "../../segment_buffers";
+import CdnPrioritizer from "../cdn_prioritizer";
 import applyPrioritizerToSegmentFetcher, {
   IPrioritizedSegmentFetcher,
 } from "./prioritized_segment_fetcher";
@@ -81,13 +83,18 @@ export default class SegmentFetcherCreator {
    */
   private readonly _backoffOptions : ISegmentFetcherCreatorBackoffOptions;
 
+  private readonly _cdnPrioritizer : CdnPrioritizer;
+
   /**
    * @param {Object} transport
    */
   constructor(
     transport : ITransportPipelines,
-    options : ISegmentFetcherCreatorBackoffOptions
+    options : ISegmentFetcherCreatorBackoffOptions,
+    cancelSignal : CancellationSignal
   ) {
+    const cdnPrioritizer = new CdnPrioritizer(cancelSignal);
+
     const { MIN_CANCELABLE_PRIORITY,
             MAX_HIGH_PRIORITY_LEVEL } = config.getCurrent();
     this._transport = transport;
@@ -95,6 +102,7 @@ export default class SegmentFetcherCreator {
       prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,
                        low: MIN_CANCELABLE_PRIORITY },
     });
+    this._cdnPrioritizer = cdnPrioritizer;
     this._backoffOptions = options;
   }
 
@@ -116,6 +124,7 @@ export default class SegmentFetcherCreator {
     const segmentFetcher = createSegmentFetcher<unknown, unknown>(
       bufferType,
       pipelines as ISegmentPipeline<unknown, unknown>,
+      this._cdnPrioritizer,
       callbacks,
       backoffOptions
     );