shaka-player 4.6.4 → 4.7.0

package/test/offline/offline_integration.js

@@ -1,168 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/** @return {boolean} */
-const supportsStorage = () => shaka.offline.Storage.support();
-
-// TODO: Merge with storage_integration.js.  No obvious difference in purpose.
-filterDescribe('Offline', supportsStorage, () => {
-  /** @type {!shaka.Player} */
-  let player;
-  /** @type {!shaka.offline.Storage} */
-  let storage;
-  /** @type {!HTMLVideoElement} */
-  let video;
-  /** @type {!shaka.util.EventManager} */
-  let eventManager;
-  /** @type {shaka.test.Waiter} */
-  let waiter;
-
-  beforeAll(() => {
-    video = shaka.test.UiUtils.createVideoElement();
-    document.body.appendChild(video);
-  });
-
-  afterAll(() => {
-    document.body.removeChild(video);
-  });
-
-  beforeEach(async () => {
-    player = new shaka.Player();
-    await player.attach(video);
-    player.addEventListener('error', fail);
-
-    // Disable stall detection, which can interfere with playback tests.
-    player.configure('streaming.stallEnabled', false);
-
-    eventManager = new shaka.util.EventManager();
-    waiter = new shaka.test.Waiter(eventManager);
-    waiter.setPlayer(player);
-
-    // Make sure we are starting with a blank slate.
-    await shaka.offline.Storage.deleteAll();
-    storage = new shaka.offline.Storage(player);
-  });
-
-  afterEach(async () => {
-    eventManager.release();
-
-    if (storage) {
-      await storage.destroy();
-    }
-
-    // Make sure we don't leave anything in storage after the test.
-    await shaka.offline.Storage.deleteAll();
-
-    if (player) {
-      await player.destroy();
-    }
-  });
-
-  it('stores, plays, and deletes clear content', async () => {
-    const content = await storage.store('test:sintel').promise;
-    expect(content).toBeTruthy();
-
-    const contentUri = content.offlineUri;
-    goog.asserts.assert(
-        contentUri != null, 'Stored content should have an offline uri.');
-
-    await player.load(contentUri);
-
-    await video.play();
-    await playTo(/* end= */ 3, /* timeout= */ 20);
-    await player.unload();
-    await storage.remove(contentUri);
-  });
-
-  // TODO: Add a PlayReady version once Edge supports offline.
-  drmIt(
-      'stores, plays, and deletes protected content with a persistent license',
-      async () => {
-        const support = await shaka.Player.probeSupport();
-        const widevineSupport = support.drm['com.widevine.alpha'];
-
-        if (!widevineSupport || !widevineSupport.persistentState) {
-          pending('Widevine persistent licenses are not supported');
-          return;
-        }
-
-        shaka.test.TestScheme.setupPlayer(player, 'sintel-enc');
-
-        storage.configure('offline.usePersistentLicense', true);
-        const content = await storage.store('test:sintel-enc').promise;
-
-        // Work around http://crbug.com/887535 in which load cannot happen right
-        // after close.  Experimentally, we seem to need a ~1s delay, so we're
-        // using a 3s delay to ensure it doesn't flake.  Without this, we get
-        // error 6005 (FAILED_TO_CREATE_SESSION) with system code 70.
-        // TODO: Remove when Chrome is fixed
-        await shaka.test.Util.delay(3);
-
-        const contentUri = content.offlineUri;
-        goog.asserts.assert(
-            contentUri, 'Stored content should have an offline uri.');
-
-        await player.load(contentUri);
-
-        await video.play();
-        await playTo(/* end= */ 3, /* timeout= */ 20);
-        await player.unload();
-        await storage.remove(contentUri);
-      });
-
-  drmIt(
-      'stores, plays, and deletes protected content with a temporary license',
-      async () => {
-        const support = await shaka.Player.probeSupport();
-        const widevineSupport = support.drm['com.widevine.alpha'];
-        const playreadySupport = support.drm['com.microsoft.playready'];
-
-        if (!(widevineSupport || playreadySupport)) {
-          pending('Widevine and PlayReady are not supported');
-          return;
-        }
-
-        if (shaka.util.Platform.isXboxOne()) {
-          // Axinom won't issue a license for an Xbox One.  The error message
-          // from the license server says "Your DRM client's security level is
-          // 150, but the entitlement message requires 2000 or higher."
-          // TODO: Stop using Axinom's license server.  Use
-          // https://testweb.playready.microsoft.com/Server/ServiceQueryStringSyntax
-          pending('Xbox One not supported by Axinom license server');
-          return;
-        }
-
-        // Because we do not need a persistent license, we also do not need init
-        // data in the manifest.  Using this covers issue #1159, where we used
-        // to throw an error inappropriately.
-        shaka.test.TestScheme.setupPlayer(player, 'multidrm_no_init_data');
-
-        storage.configure('offline.usePersistentLicense', false);
-        const content =
-            await storage.store('test:multidrm_no_init_data').promise;
-
-        const contentUri = content.offlineUri;
-        goog.asserts.assert(
-            contentUri, 'Stored content should have an offline uri.');
-
-        await player.load(contentUri);
-
-        await video.play();
-        await playTo(/* end= */ 3, /* timeout= */ 20);
-        await player.unload();
-        await storage.remove(contentUri);
-      });
-
-  /**
-   * @param {number} endSeconds
-   * @param {number} timeoutSeconds
-   * @return {!Promise}
-   */
-  async function playTo(endSeconds, timeoutSeconds) {
-    await waiter.waitUntilPlayheadReachesOrFailOnTimeout(
-        video, endSeconds, timeoutSeconds);
-  }
-});

package/test/offline/offline_manifest_parser_unit.js

@@ -1,231 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/** @return {boolean} */
-const offlineManifestParserSupport = () => shaka.offline.StorageMuxer.support();
-filterDescribe('OfflineManifestParser', offlineManifestParserSupport, () => {
-  const Util = shaka.test.Util;
-  // The offline manifest parser does not need the player interface, so
-  // this is a work around to avoid creating one.
-  const playerInterface =
-  /** @type {shaka.extern.ManifestParser.PlayerInterface} */({
-      makeTextStreamsForClosedCaptions: (manifest) => {},
-    });
-
-  // A session id that will be found in the manifest created by |makeManifest|.
-  const sessionId = 'session-id';
-
-  /** @type {!shaka.offline.OfflineManifestParser} */
-  let parser;
-
-  beforeEach(async () => {
-    // Make sure we start with a clean slate.
-    await clearStorage();
-    parser = new shaka.offline.OfflineManifestParser();
-  });
-
-  afterEach(async () => {
-    parser.stop();
-    // Make sure that we don't waste storage by leaving stuff in storage.
-    await clearStorage();
-  });
-
-  it('returns manifest from storage', async () => {
-    const inputManifest = makeManifest();
-
-    /** @type {!shaka.offline.OfflineUri} */
-    let uri;
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-      const keys = await handle.cell.addManifests([inputManifest]);
-
-      uri = shaka.offline.OfflineUri.manifest(
-          handle.path.mechanism, handle.path.cell, keys[0]);
-    } finally {
-      await muxer.destroy();
-    }
-
-    const outputManifest = await parser.start(uri.toString(), playerInterface);
-    expect(outputManifest).toBeTruthy();
-  });
-
-  it('updates expiration', async () => {
-    const newExpiration = 1000;
-
-    const inputManifest = makeManifest();
-    // Make sure that the expiration is different from the new expiration
-    // so that when we check that they are the same later, it actually
-    // means that it changed.
-    expect(inputManifest.expiration).not.toBe(newExpiration);
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-      const keys = await handle.cell.addManifests([inputManifest]);
-
-      /** @type {!shaka.offline.OfflineUri} */
-      const uri = shaka.offline.OfflineUri.manifest(
-          handle.path.mechanism, handle.path.cell, keys[0]);
-
-      await parser.start(uri.toString(), playerInterface);
-      await parser.onExpirationUpdated(sessionId, newExpiration);
-
-      const found = await handle.cell.getManifests(keys);
-      expect(found[0].expiration).toBe(newExpiration);
-    } finally {
-      await muxer.destroy();
-    }
-  });
-
-  it('fails if manifest was not found', async () => {
-    const inputManifest = makeManifest();
-
-    /** @type {!shaka.offline.OfflineUri} */
-    let uri;
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-      const keys = await handle.cell.addManifests([inputManifest]);
-
-      uri = shaka.offline.OfflineUri.manifest(
-          handle.path.mechanism, handle.path.cell, keys[0]);
-
-      // Remove the manifest so that the uri will point to nothing.
-      const noop = () => {};
-      await handle.cell.removeManifests(keys, noop);
-    } finally {
-      await muxer.destroy();
-    }
-
-    const expected = Util.jasmineError(new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.STORAGE,
-        shaka.util.Error.Code.KEY_NOT_FOUND,
-        jasmine.any(String)));
-    await expectAsync(parser.start(uri.toString(), playerInterface))
-        .toBeRejectedWith(expected);
-  });
-
-  it('fails for invalid URI', async () => {
-    const uri = 'this-is-an-invalid-uri';
-
-    const expected = Util.jasmineError(new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.NETWORK,
-        shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
-        uri));
-    await expectAsync(parser.start(uri, playerInterface))
-        .toBeRejectedWith(expected);
-  });
-
-  it('ignores update expiration when data is deleted', async () => {
-    const newExpiration = 1000;
-
-    const inputManifest = makeManifest();
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-      const keys = await handle.cell.addManifests([inputManifest]);
-
-      const uri = shaka.offline.OfflineUri.manifest(
-          handle.path.mechanism, handle.path.cell, keys[0]);
-
-      await parser.start(uri.toString(), playerInterface);
-
-      // Remove the manifest after we have parsed it so that the
-      // update won't find it. Oh, we are sneaky.
-      const noop = () => {};
-      await handle.cell.removeManifests(keys, noop);
-      await parser.onExpirationUpdated(sessionId, newExpiration);
-    } finally {
-      await muxer.destroy();
-    }
-  });
-
-  it('ignores update expiration with unknown session', async () => {
-    const wrongSession = 'this-session-wont-be-found';
-    const newExpiration = 1000;
-
-    const inputManifest = makeManifest();
-    const oldExpiration = inputManifest.expiration;
-
-    // Make sure that the expirations are not the same.
-    expect(oldExpiration).not.toBe(newExpiration);
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-      const keys = await handle.cell.addManifests([inputManifest]);
-
-      const uri = shaka.offline.OfflineUri.manifest(
-          handle.path.mechanism, handle.path.cell, keys[0]);
-
-      await parser.start(uri.toString(), playerInterface);
-      await parser.onExpirationUpdated(wrongSession, newExpiration);
-
-      // Make sure that the expiration was not updated.
-      const found = await handle.cell.getManifests(keys);
-      expect(found[0].expiration).toBe(oldExpiration);
-    } finally {
-      await muxer.destroy();
-    }
-  });
-
-  /**
-   * @return {!shaka.extern.ManifestDB}
-   */
-  function makeManifest() {
-    const mb = 1024 * 1024;
-    const seconds = 1.0;
-
-    /** @type {shaka.extern.ManifestDB} */
-    const manifest = {
-      creationTime: Date.now(),
-      originalManifestUri: '',
-      duration: 600 * seconds,
-      size: 100 * mb,
-      expiration: Infinity,
-      streams: [],
-      sessionIds: [sessionId],
-      drmInfo: null,
-      appMetadata: {},
-      sequenceMode: false,
-    };
-
-    return manifest;
-  }
-
-  /**
-   * @return {!Promise}
-   */
-  async function clearStorage() {
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-    try {
-      await muxer.erase();
-    } finally {
-      await muxer.destroy();
-    }
-  }
-});

package/test/offline/offline_scheme_unit.js

@@ -1,154 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/** @return {boolean} */
-const offlineSchemeSupport = () => shaka.offline.StorageMuxer.support();
-filterDescribe('OfflineScheme', offlineSchemeSupport, () => {
-  // An arbitrary request type.
-  const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
-
-  // A dummy progress callback.
-  const progressUpdated = (elapsedMs, bytes, bytesRemaining) => {};
-
-  const Util = shaka.test.Util;
-
-  beforeEach(async () => {
-    // Make sure we start with a clean slate.
-    await clearStorage();
-  });
-
-  afterEach(async () => {
-    // Make sure that we don't waste storage by leaving stuff in storage.
-    await clearStorage();
-  });
-
-  it('returns special content-type header for manifests', async () => {
-    const expectedContentType = 'application/x-offline-manifest';
-    const request = createRequest();
-    /** @type {!shaka.offline.OfflineUri} */
-    const uri = shaka.offline.OfflineUri.manifest(
-        'mechanism', 'cell', 1024);
-
-    const response = await shaka.offline.OfflineScheme.plugin(
-        uri.toString(), request, requestType, progressUpdated).promise;
-
-    expect(response).toBeTruthy();
-    expect(response.uri).toBe(uri.toString());
-    expect(response.headers['content-type']).toBe(expectedContentType);
-  });
-
-  it('returns segment data from storage', async () => {
-    const request = createRequest();
-    const segment = createSegment();
-
-    /** @type {!shaka.offline.OfflineUri} */
-    let uri;
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-      const keys = await handle.cell.addSegments([segment]);
-      uri = shaka.offline.OfflineUri.segment(
-          handle.path.mechanism, handle.path.cell, keys[0]);
-    } finally {
-      await muxer.destroy();
-    }
-
-    const response = await shaka.offline.OfflineScheme.plugin(
-        uri.toString(), request, requestType, progressUpdated).promise;
-
-    expect(response).toBeTruthy();
-    expect(response.data.byteLength).toBe(segment.data.byteLength);
-  });
-
-  it('fails if segment not found', async () => {
-    const request = createRequest();
-
-    /** @type {!shaka.offline.OfflineUri} */
-    let uri;
-
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.init();
-      const handle = await muxer.getActive();
-
-      // Create a bad uri by using the mechanism and cell of the active cell
-      // but use a key that is not in use.
-      const badKey = 1000000;
-      uri = shaka.offline.OfflineUri.segment(
-          handle.path.mechanism, handle.path.cell, badKey);
-    } finally {
-      await muxer.destroy();
-    }
-
-    const expected = Util.jasmineError(new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.STORAGE,
-        shaka.util.Error.Code.KEY_NOT_FOUND,
-        jasmine.any(String)));
-    await expectAsync(
-        shaka.offline.OfflineScheme.plugin(
-            uri.toString(), request, requestType, progressUpdated).promise)
-        .toBeRejectedWith(expected);
-  });
-
-  it('fails for invalid URI', async () => {
-    const request = createRequest();
-    const uri = 'this-in-an-invalid-uri';
-
-    const expected = Util.jasmineError(new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.NETWORK,
-        shaka.util.Error.Code.MALFORMED_OFFLINE_URI,
-        uri));
-    await expectAsync(
-        shaka.offline.OfflineScheme.plugin(
-            uri, request, requestType, progressUpdated).promise)
-        .toBeRejectedWith(expected);
-  });
-
-  /**
-   * @return {shaka.extern.Request}
-   */
-  function createRequest() {
-    const retry = shaka.net.NetworkingEngine.defaultRetryParameters();
-    const request = shaka.net.NetworkingEngine.makeRequest([], retry);
-
-    return request;
-  }
-
-  /**
-   * @return {shaka.extern.SegmentDataDB}
-   */
-  function createSegment() {
-    const dataLength = 12;
-
-    const segment = {
-      data: new ArrayBuffer(dataLength),
-    };
-
-    return segment;
-  }
-
-  /**
-   * @return {!Promise}
-   */
-  async function clearStorage() {
-    /** @type {!shaka.offline.StorageMuxer} */
-    const muxer = new shaka.offline.StorageMuxer();
-
-    try {
-      await muxer.erase();
-    } finally {
-      await muxer.destroy;
-    }
-  }
-});

package/test/offline/offline_uri_unit.js

@@ -1,59 +0,0 @@
-/*! @license
- * Shaka Player
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-describe('OfflineUri', () => {
-  const OfflineUri = shaka.offline.OfflineUri;
-
-  it('creates uri from manifest id', () => {
-    /** @type {number} */
-    const id = 123;
-    /** @type {string} */
-    const uri = OfflineUri.manifest('mech', 'cell', id).toString();
-
-    expect(uri).toBe('offline:manifest/mech/cell/123');
-  });
-
-  it('creates uri from segment id', () => {
-    /** @type {number} */
-    const id = 123;
-    /** @type {string} */
-    const uri = OfflineUri.segment('mech', 'cell', id).toString();
-
-    expect(uri).toBe('offline:segment/mech/cell/123');
-  });
-
-  it('creates null from invalid uri', () => {
-    /** @type {string} */
-    const uri = 'invalid-uri';
-    const parsed = OfflineUri.parse(uri);
-
-    expect(parsed).toBeNull();
-  });
-
-  it('parse manifest uri', () => {
-    /** @type {string} */
-    const uri = 'offline:manifest/mech/cell/123';
-    const parsed = OfflineUri.parse(uri);
-
-    expect(parsed).toBeTruthy();
-    expect(parsed.isManifest()).toBeTruthy();
-    expect(parsed.mechanism()).toBe('mech');
-    expect(parsed.cell()).toBe('cell');
-    expect(parsed.key()).toBe(123);
-  });
-
-  it('parse segment uri', () => {
-    /** @type {string} */
-    const uri = 'offline:segment/mech/cell/123';
-    const parsed = OfflineUri.parse(uri);
-
-    expect(parsed).toBeTruthy();
-    expect(parsed.isSegment()).toBeTruthy();
-    expect(parsed.mechanism()).toBe('mech');
-    expect(parsed.cell()).toBe('cell');
-    expect(parsed.key()).toBe(123);
-  });
-});