shaka-player 4.2.9 → 4.2.10

package/lib/net/http_fetch_plugin.js

@@ -120,65 +120,77 @@ shaka.net.HttpFetchPlugin = class {
       // not the body yet.
       headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
           response.headers));
-      // Getting the reader in this way allows us to observe the process of
-      // downloading the body, instead of just waiting for an opaque promise to
-      // resolve.
-      // We first clone the response because calling getReader locks the body
-      // stream; if we didn't clone it here, we would be unable to get the
-      // response's arrayBuffer later.
-      const reader = response.clone().body.getReader();
-
-      const contentLengthRaw = response.headers.get('Content-Length');
-      const contentLength =
-          contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
-
-      const start = (controller) => {
-        const push = async () => {
-          let readObj;
-          try {
-            readObj = await reader.read();
-          } catch (e) {
-            // If we abort the request, we'll get an error here.  Just ignore it
-            // since real errors will be reported when we read the buffer below.
-            shaka.log.v1('error reading from stream', e.message);
-            return;
-          }
-
-          if (!readObj.done) {
-            loaded += readObj.value.byteLength;
-            if (streamDataCallback) {
-              await streamDataCallback(readObj.value);
+
+      // In new versions of Chromium, HEAD requests now have a response body
+      // that is null.
+      // So just don't try to download the body at all, if it's a HEAD request,
+      // to avoid null reference errors.
+      // See: https://crbug.com/1297060
+      if (init.method != 'HEAD') {
+        goog.asserts.assert(response.body,
+            'non-HEAD responses should have a body');
+
+        // Getting the reader in this way allows us to observe the process of
+        // downloading the body, instead of just waiting for an opaque promise
+        // to resolve.
+        // We first clone the response because calling getReader locks the body
+        // stream; if we didn't clone it here, we would be unable to get the
+        // response's arrayBuffer later.
+        const reader = response.clone().body.getReader();
+
+        const contentLengthRaw = response.headers.get('Content-Length');
+        const contentLength =
+            contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
+
+        const start = (controller) => {
+          const push = async () => {
+            let readObj;
+            try {
+              readObj = await reader.read();
+            } catch (e) {
+              // If we abort the request, we'll get an error here.  Just ignore
+              // it since real errors will be reported when we read the buffer
+              // below.
+              shaka.log.v1('error reading from stream', e.message);
+              return;
+            }
+
+            if (!readObj.done) {
+              loaded += readObj.value.byteLength;
+              if (streamDataCallback) {
+                await streamDataCallback(readObj.value);
+              }
+            }
+
+            const currentTime = Date.now();
+            // If the time between last time and this time we got progress event
+            // is long enough, or if a whole segment is downloaded, call
+            // progressUpdated().
+            if (currentTime - lastTime > 100 || readObj.done) {
+              progressUpdated(currentTime - lastTime, loaded - lastLoaded,
+                  contentLength - loaded);
+              lastLoaded = loaded;
+              lastTime = currentTime;
+            }
+
+            if (readObj.done) {
+              goog.asserts.assert(!readObj.value,
+                  'readObj should be unset when "done" is true.');
+              controller.close();
+            } else {
+              controller.enqueue(readObj.value);
+              push();
             }
-          }
-
-          const currentTime = Date.now();
-          // If the time between last time and this time we got progress event
-          // is long enough, or if a whole segment is downloaded, call
-          // progressUpdated().
-          if (currentTime - lastTime > 100 || readObj.done) {
-            progressUpdated(currentTime - lastTime, loaded - lastLoaded,
-                contentLength - loaded);
-            lastLoaded = loaded;
-            lastTime = currentTime;
-          }
-
-          if (readObj.done) {
-            goog.asserts.assert(!readObj.value,
-                'readObj should be unset when "done" is true.');
-            controller.close();
-          } else {
-            controller.enqueue(readObj.value);
-            push();
-          }
+          };
+          push();
         };
-        push();
-      };
-      // Create a ReadableStream to use the reader. We don't need to use the
-      // actual stream for anything, though, as we are using the response's
-      // arrayBuffer method to get the body, so we don't store the
-      // ReadableStream.
-      new ReadableStream({start}); // eslint-disable-line no-new
-      arrayBuffer = await response.arrayBuffer();
+        // Create a ReadableStream to use the reader. We don't need to use the
+        // actual stream for anything, though, as we are using the response's
+        // arrayBuffer method to get the body, so we don't store the
+        // ReadableStream.
+        new ReadableStream({start}); // eslint-disable-line no-new
+        arrayBuffer = await response.arrayBuffer();
+      }
     } catch (error) {
       if (abortStatus.canceled) {
         throw new shaka.util.Error(
@@ -243,6 +255,16 @@ shaka.net.HttpFetchPlugin = class {
     } else {
       return false;
     }
+    // Old fetch implementations hasn't body and ReadableStream implementation
+    // See: https://github.com/shaka-project/shaka-player/issues/5088
+    if (window.Response) {
+      const response = new Response('');
+      if (!response.body) {
+        return false;
+      }
+    } else {
+      return false;
+    }
     return !!(window.fetch && window.AbortController);
   }
 };

package/lib/net/networking_engine.js

@@ -312,6 +312,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
       if (!responseAndGotProgress.gotProgress &&
           this.onProgressUpdated_ &&
           !response.fromCache &&
+          request.method != 'HEAD' &&
           type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
         this.onProgressUpdated_(response.timeMs, response.data.byteLength);
       }

package/lib/player.js

@@ -806,7 +806,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     this.abrManagerFactory_ = null;
-    this.abrManager_ = null;
     this.config_ = null;
     this.stats_ = null;
     this.videoContainer_ = null;
@@ -817,6 +816,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.networkingEngine_ = null;
     }
 
+    if (this.abrManager_) {
+      this.abrManager_.release();
+      this.abrManager_ = null;
+    }
+
     // FakeEventTarget implements IReleasable
     super.release();
   }
@@ -1232,6 +1236,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    */
   shouldUseSrcEquals_(payload) {
     const Platform = shaka.util.Platform;
+    const MimeUtils = shaka.util.MimeUtils;
 
     // If we are using a platform that does not support media source, we will
     // fall back to src= to handle all playback.
@@ -1286,7 +1291,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       // version there.
 
       // Native HLS can be preferred on any platform via this flag:
-      if (this.config_.streaming.preferNativeHls) {
+      if (MimeUtils.isHlsType(mimeType) &&
+          this.config_.streaming.preferNativeHls) {
         return true;
       }
 
@@ -4086,6 +4092,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               firstVariantWithLabel.language, '', 0, label);
 
       this.chooseVariantAndSwitch_();
+    } else if (this.video_ && this.video_.audioTracks) {
+      const audioTracks = Array.from(this.video_.audioTracks);
+
+      let trackMatch = null;
+
+      for (const audioTrack of audioTracks) {
+        if (audioTrack.label == label) {
+          trackMatch = audioTrack;
+        }
+      }
+      if (trackMatch) {
+        this.switchHtml5Track_(trackMatch);
+      }
     }
   }
 
@@ -6607,7 +6626,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.2.9-uncompiled';
+shaka.Player.version = 'v4.2.10-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -115,6 +115,19 @@ shaka.polyfill.MediaCapabilities = class {
         if (shaka.util.Platform.isChromecast()) {
           isSupported =
               shaka.polyfill.MediaCapabilities.canCastDisplayType_(videoConfig);
+        } else if (shaka.util.Platform.isTizen()) {
+          let extendedType = videoConfig.contentType;
+          if (videoConfig.width && videoConfig.height) {
+            extendedType += `; width=${videoConfig.width}`;
+            extendedType += `; height=${videoConfig.height}`;
+          }
+          if (videoConfig.framerate) {
+            extendedType += `; framerate=${videoConfig.framerate}`;
+          }
+          if (videoConfig.bitrate) {
+            extendedType += `; bitrate=${videoConfig.bitrate}`;
+          }
+          isSupported = MediaSource.isTypeSupported(extendedType);
         } else {
           isSupported = MediaSource.isTypeSupported(videoConfig.contentType);
         }

package/lib/text/mp4_vtt_parser.js

@@ -97,6 +97,10 @@ shaka.text.Mp4VttParser = class {
    * @export
    */
   parseMedia(data, time) {
+    if (!data.length) {
+      return [];
+    }
+
     if (!this.timescale_) {
       // Missing timescale for VTT content. We should have seen the init
       // segment.

package/lib/text/text_engine.js

@@ -139,6 +139,7 @@ shaka.text.TextEngine = class {
     // into TextEngine and TextDisplayer.
     if (mimeType == shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE ||
         mimeType == shaka.util.MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE) {
+      this.parser_ = null;
       return;
     }
 

package/lib/util/manifest_parser_utils.js

@@ -185,8 +185,7 @@ shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^mp4a/,
   /^[ae]c-3$/,
   /^ac-4$/,
-  /^dts[cx]$/, // DTS Surround Sound
-  /^[du]dts$/, // DTS Surround Sound
+  /^dts[cex]$/, // DTS Digital Surround (dtsc), DTS Express (dtse), DTS:X (dtsx)
 ];
 
 

package/lib/util/mime_utils.js

@@ -196,6 +196,17 @@ shaka.util.MimeUtils = class {
     return value;
   }
 
+  /**
+   * Checks if the given MIME type is HLS MIME type.
+   *
+   * @param {string} mimeType
+   * @return {boolean}
+   */
+  static isHlsType(mimeType) {
+    return mimeType === 'application/x-mpegurl' ||
+        mimeType === 'application/vnd.apple.mpegurl';
+  }
+
   /**
    * Get the base and profile of a codec string. Where [0] will be the codec
    * base and [1] will be the profile.

package/lib/util/periods.js

@@ -671,11 +671,11 @@ shaka.util.PeriodCombiner = class {
     // Also checks if the segmentIndex is still valid after the async
     // operations, to make sure we stop if the active stream has changed.
     if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
-      for (let i = 0; i < streams.length; i++) {
+      for (let i = firstNewPeriodIndex; i < streams.length; i++) {
         const match = streams[i];
-        if (match.segmentIndex && i >= firstNewPeriodIndex) {
-          goog.asserts.assert(match.segmentIndex,
-              'stream should have a segmentIndex.');
+        goog.asserts.assert(match.segmentIndex,
+            'stream should have a segmentIndex.');
+        if (match.segmentIndex) {
           outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
         }
       }
@@ -728,7 +728,7 @@ shaka.util.PeriodCombiner = class {
       // in advance.  concat() will add them to the output's MetaSegmentIndex.
     }
 
-    if (!outputStream.matchedStreams) {
+    if (!outputStream.matchedStreams || !outputStream.matchedStreams.length) {
       // This is not a stream we can build output from, but it may become part
       // of another output based on another period's stream.
       return null;

package/lib/util/stream_utils.js

@@ -828,7 +828,7 @@ shaka.util.StreamUtils = class {
       const video = variant.video;
       if (audio && currentVariant && currentVariant.audio) {
         if (!StreamUtils.areStreamsCompatible_(audio, currentVariant.audio)) {
-          shaka.log.debug('Droping variant - not compatible with active audio',
+          shaka.log.debug('Dropping variant - not compatible with active audio',
               'active audio',
               StreamUtils.getStreamSummaryString_(currentVariant.audio),
               'variant.audio',
@@ -839,7 +839,7 @@ shaka.util.StreamUtils = class {
 
       if (video && currentVariant && currentVariant.video) {
         if (!StreamUtils.areStreamsCompatible_(video, currentVariant.video)) {
-          shaka.log.debug('Droping variant - not compatible with active video',
+          shaka.log.debug('Dropping variant - not compatible with active video',
               'active video',
               StreamUtils.getStreamSummaryString_(currentVariant.video),
               'variant.video',

package/maintained-branches.md

@@ -2,10 +2,9 @@
 
 We are currently maintaining the following branches of Shaka Player:
 
- - v4.1 (latest)
- - v4.0 (previous)
- - v3.3 (LTS until April 30, 2023)
- - v3.2 (in use by the Cast Application Framework)
+ - v4.3 (latest, also in use by the Cast Application Framework)
+ - v4.2 (previous)
+ - No active LTS branches at this time
 
 Other branches are no longer receiving bug fixes, and we recommend you upgrade
 to a maintained branch.  For details on upgrading, please see our

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.2.9",
+  "version": "4.2.10",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/test/media/content_workarounds_unit.js

@@ -0,0 +1,43 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+describe('ContentWorkarounds', () => {
+  const encryptionBoxes = {
+    'encv': ['hev1', 'hvc1', 'avc1', 'avc3'],
+    'enca': ['ac-3', 'ec-3', 'mp4a'],
+  };
+  for (const encryptionBox of Object.keys(encryptionBoxes)) {
+    for (const box of encryptionBoxes[encryptionBox]) {
+      it(`adds ${encryptionBox} box for ${box}`, () => {
+        const boxType = [];
+        for (const char of box) {
+          boxType.push(char.charCodeAt(0));
+        }
+        const unencrypted = new Uint8Array([
+          0x00, 0x00, 0x00, 0x20, // size
+          0x73, 0x74, 0x73, 0x64, // stsd
+          0x01,                   // version
+          0x12, 0x34, 0x56,       // flags
+          0x00, 0x00, 0x00, 0x01, // count
+          0x00, 0x00, 0x00, 0x10, // size
+          ...boxType,             // box type
+          0x01,                   // version
+          0x12, 0x34, 0x56,       // flags
+          0x00, 0x11, 0x22, 0x33, // payload
+        ]);
+
+        const faked =
+            shaka.media.ContentWorkarounds.fakeEncryption(unencrypted);
+        const spy = jasmine.createSpy('boxCallback');
+        new shaka.util.Mp4Parser()
+            .fullBox('stsd', shaka.util.Mp4Parser.sampleDescription)
+            .box(encryptionBox, /** @type {!Function} */ (spy))
+            .parse(faked);
+        expect(spy).toHaveBeenCalled();
+      });
+    }
+  }
+});

package/test/media/drm_engine_integration.js

@@ -74,19 +74,6 @@ describe('DrmEngine', () => {
     onEventSpy = jasmine.createSpy('onEvent');
 
     networkingEngine = new shaka.net.NetworkingEngine();
-    networkingEngine.registerRequestFilter((type, request) => {
-      if (type != shaka.net.NetworkingEngine.RequestType.LICENSE) {
-        return;
-      }
-
-      request.headers['X-AxDRM-Message'] = [
-        'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ2ZXJzaW9uIjoxLCJjb21fa2V5X2lk',
-        'IjoiNjllNTQwODgtZTllMC00NTMwLThjMWEtMWViNmRjZDBkMTRlIiwibWVzc2FnZSI6e',
-        'yJ0eXBlIjoiZW50aXRsZW1lbnRfbWVzc2FnZSIsImtleXMiOlt7ImlkIjoiNmU1YTFkMj',
-        'YtMjc1Ny00N2Q3LTgwNDYtZWFhNWQxZDM0YjVhIn1dfX0.yF7PflOPv9qHnu3ZWJNZ12j',
-        'gkqTabmwXbDWk_47tLNE',
-      ].join('');
-    });
 
     const playerInterface = {
       netEngine: networkingEngine,
@@ -99,22 +86,22 @@ describe('DrmEngine', () => {
     drmEngine = new shaka.media.DrmEngine(playerInterface);
     const config = shaka.util.PlayerConfiguration.createDefault().drm;
     config.servers['com.widevine.alpha'] =
-        'https://drm-widevine-licensing.axtest.net/AcquireLicense';
+        'https://cwip-shaka-proxy.appspot.com/specific_key?blodJidXR9eARuql0dNLWg=GX8m9XLIZNIzizrl0RTqnA';
     config.servers['com.microsoft.playready'] =
-        'https://drm-playready-licensing.axtest.net/AcquireLicense';
+        'https://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(kid:6e5a1d26-2757-47d7-8046-eaa5d1d34b5a,contentkey:GX8m9XLIZNIzizrl0RTqnA==,sl:150)';
     drmEngine.configure(config);
 
     manifest = shaka.test.ManifestGenerator.generate((manifest) => {
       manifest.addVariant(0, (variant) => {
         variant.addVideo(1, (stream) => {
           stream.encrypted = true;
-          stream.addDrmInfo('com.widevine.alpha');
           stream.addDrmInfo('com.microsoft.playready');
+          stream.addDrmInfo('com.widevine.alpha');
         });
         variant.addAudio(2, (stream) => {
           stream.encrypted = true;
-          stream.addDrmInfo('com.widevine.alpha');
           stream.addDrmInfo('com.microsoft.playready');
+          stream.addDrmInfo('com.widevine.alpha');
         });
       });
     });

package/test/media/streaming_engine_unit.js

@@ -3297,7 +3297,12 @@ describe('StreamingEngine', () => {
       netEngine.request.and.callFake((requestType, request) => {
         const buffer = new ArrayBuffer(0);
         /** @type {shaka.extern.Response} */
-        const response = {uri: request.uris[0], data: buffer, headers: {}};
+        const response = {
+          uri: request.uris[0],
+          originalUri: request.uris[0],
+          data: buffer,
+          headers: {},
+        };
         return shaka.util.AbortableOperation.completed(response);
       });
 

package/test/net/networking_engine_unit.js

@@ -1226,6 +1226,11 @@ describe('NetworkingEngine', /** @suppress {accessControls} */ () => {
 
   /** @return {shaka.extern.Response} */
   function createResponse() {
-    return {uri: '', data: new ArrayBuffer(5), headers: {}};
+    return {
+      uri: '',
+      originalUri: '',
+      data: new ArrayBuffer(5),
+      headers: {},
+    };
   }
 });  // describe('NetworkingEngine')

package/test/player_integration.js

@@ -401,6 +401,45 @@ describe('Player', () => {
       player.setTextTrackVisibility(true);
       expect(getTracksActive()).toEqual([false, true]);
     });
+
+    // https://github.com/shaka-project/shaka-player/issues/4821
+    it('loads a single text stream', async () => {
+      player.configure({preferredTextLanguage: 'en'});
+      await player.load('test:sintel_no_text_compiled');
+
+      // Add preferred language text track.
+      const locationUri = new goog.Uri(location.href);
+      const partialUri = new goog.Uri('/base/test/test/assets/text-clip.vtt');
+      const absoluteUri = locationUri.resolve(partialUri);
+      await player.addTextTrackAsync(
+          absoluteUri.toString(), 'en', 'subtitles', 'text/vtt');
+
+      // Add alternate language text track.
+      // Two text tracks with same timings but different text
+      // are necessary for test.
+      const partialUri2 =
+      new goog.Uri('/base/test/test/assets/text-clip-alt.vtt');
+      const absoluteUri2 = locationUri.resolve(partialUri2);
+      await player.addTextTrackAsync(
+          absoluteUri2.toString(), 'fr', 'subtitles', 'text/vtt');
+
+      const textTracks = player.getTextTracks();
+      expect(textTracks.length).toBe(2);
+      expect(textTracks[0].language).toBe('en');
+      expect(textTracks[1].language).toBe('fr');
+
+      // Enable text visibilty and immediately change language.
+      // Only one set of cues should be active.
+      // Cues should be of the selected language track.
+      player.setTextTrackVisibility(true);
+      player.selectTextLanguage('fr');
+      video.currentTime = 5;
+      video.play();
+      await waiter.waitForMovementOrFailOnTimeout(video, 10);
+
+      expect(video.textTracks[0].activeCues.length).toBe(1);
+      expect(player.getTextTracks()[1].active).toBe(true);
+    });
   });  // describe('setTextTrackVisibility')
 
   describe('plays', () => {

package/test/player_unit.js

@@ -205,6 +205,7 @@ describe('Player', () => {
       await player.destroy();
 
       expect(abrManager.stop).toHaveBeenCalled();
+      expect(abrManager.release).toHaveBeenCalled();
       expect(networkingEngine.destroy).toHaveBeenCalled();
       expect(drmEngine.destroy).toHaveBeenCalled();
       expect(playhead.release).toHaveBeenCalled();
@@ -243,6 +244,7 @@ describe('Player', () => {
       parser.start.and.returnValue(p);
       parser.stop.and.callFake(() => {
         expect(abrManager.stop).not.toHaveBeenCalled();
+        expect(abrManager.release).not.toHaveBeenCalled();
         expect(networkingEngine.destroy).not.toHaveBeenCalled();
       });
       shaka.media.ManifestParser.registerParserByMime(
@@ -252,6 +254,7 @@ describe('Player', () => {
       await shaka.test.Util.shortDelay();
       await player.destroy();
       expect(abrManager.stop).toHaveBeenCalled();
+      expect(abrManager.release).toHaveBeenCalled();
       expect(networkingEngine.destroy).toHaveBeenCalled();
       expect(parser.stop).toHaveBeenCalled();
       await expectAsync(load).toBeRejected();
@@ -551,6 +554,60 @@ describe('Player', () => {
         expect(streamingEngine.unloadTextStream).not.toHaveBeenCalled();
       });
     });
+
+    describe('when config.streaming.preferNativeHls is set to true', () => {
+      beforeEach(() => {
+        shaka.media.ManifestParser.registerParserByMime(
+            'application/x-mpegurl',
+            () => new shaka.test.FakeManifestParser(manifest));
+      });
+
+      afterEach(() => {
+        shaka.media.ManifestParser.unregisterParserByMime(
+            'application/x-mpegurl');
+        video.canPlayType.calls.reset();
+      });
+
+      it('only applies to HLS streams', async () => {
+        video.canPlayType.and.returnValue('maybe');
+        spyOn(shaka.util.Platform, 'anyMediaElement').and.returnValue(video);
+        spyOn(shaka.util.Platform, 'supportsMediaSource').and.returnValue(true);
+        spyOn(shaka.util.Platform, 'isApple').and.returnValue(false);
+        // Make sure player.load() resolves for src=
+        spyOn(shaka.util.MediaReadyState, 'waitForReadyState').and.callFake(
+            (mediaElement, readyState, eventManager, callback) => {
+              callback();
+            });
+
+        player.configure({
+          streaming: {
+            preferNativeHls: true,
+            useNativeHlsOnSafari: false,
+          },
+        });
+
+        await player.load(fakeManifestUri, undefined, 'application/x-mpegurl');
+
+        expect(player.getLoadMode()).toBe(shaka.Player.LoadMode.SRC_EQUALS);
+      });
+
+      it('does not apply to non-HLS streams', async () => {
+        video.canPlayType.and.returnValue('maybe');
+        spyOn(shaka.util.Platform, 'supportsMediaSource').and.returnValue(true);
+        spyOn(shaka.util.Platform, 'isApple').and.returnValue(false);
+
+        player.configure({
+          streaming: {
+            preferNativeHls: true,
+            useNativeHlsOnSafari: false,
+          },
+        });
+
+        await player.load(fakeManifestUri, 0, fakeMimeType);
+
+        expect(player.getLoadMode()).toBe(shaka.Player.LoadMode.MEDIA_SOURCE);
+      });
+    });
   });  // describe('load/unload')
 
   describe('getConfiguration', () => {

package/test/polyfill/media_capabilities_unit.js

@@ -67,7 +67,6 @@ describe('MediaCapabilities', () => {
         width: 512,
       },
     };
-    shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
 
     mockCanDisplayType = jasmine.createSpy('canDisplayType');
     mockCanDisplayType.and.returnValue(false);