shaka-player 3.1.5 → 3.1.6

package/karma.conf.js

@@ -11,6 +11,7 @@ const Jimp = require('jimp');
 const fs = require('fs');
 const path = require('path');
 const rimraf = require('rimraf');
+const {ssim} = require('ssim.js');
 const util = require('karma/common/util');
 const which = require('which');
 
@@ -336,6 +337,10 @@ module.exports = (config) => {
 
   config.set({reporters: reporters});
 
+  if (reporters.includes('spec') && settings.spec_hide_passed) {
+    config.set({specReporter: {suppressPassed: true}});
+  }
+
   if (settings.random) {
     // If --seed was specified use that value, else generate a seed so that the
     // exact order can be reproduced if it catches an issue.
@@ -518,8 +523,7 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
    *
    * @param {karma.Launcher.Browser} browser
    * @param {!Object.<string, string>} params
-   * @return {!Promise.<number>} The number of pixels changed between the old
-   *   and new screenshots, after cropping and scaling.
+   * @return {!Promise.<number>} A similarity score between 0 and 1.
    */
   async function diffScreenshot(browser, params) {
     const webDriverClient = getWebDriverClient(browser);
@@ -604,22 +608,22 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
     // Compare the new screenshot to the old one and produce a diff image.
     // Initially, the image data will be raw pixels, 4 bytes per pixel.
     // The threshold parameter affects the sensitivity of individual pixel
-    // comparisons.  Setting it too low means small rendering changes in the
-    // browser can cause failures even when a human can't see the difference,
-    // and setting it too high means human-noticeable changes could go
-    // undetected by a test.
-    const diff = Jimp.diff(oldScreenshot, newScreenshot, /* threshold= */ 0.07);
+    // comparisons.  This diff is only used for visual review, not for
+    // automated similarity checks, so the threshold setting is not so critical
+    // as it used to be.
+    const threshold = 0.10;
+    const diff = Jimp.diff(oldScreenshot, newScreenshot, threshold);
 
     // Write the diff to disk.  This is used to review when there are changes.
+    const fullSizeDiff =
+        diff.image.clone().resize(width, height, Jimp.RESIZE_BICUBIC);
     fs.writeFileSync(
-        diffScreenshotPath, await diff.image.getBufferAsync('image/png'));
-
-    // "percent" is, surprisingly, a number between 0 and 1, not between 0 and
-    // 100.  Convert this to a number of pixels changed, which has been found to
-    // be a more effective and less flaky metric.
-    const pixelsChanged =
-        diff.percent * diff.image.bitmap.width * diff.image.bitmap.height;
-    return pixelsChanged;
+        diffScreenshotPath, await fullSizeDiff.getBufferAsync('image/png'));
+
+    // Compare with a structural similarity algorithm.  This produces a
+    // similarity score that we will use to pass or fail the test.
+    const ssimResult = ssim(oldScreenshot.bitmap, newScreenshot.bitmap);
+    return ssimResult.mssim;  // A score between 0 and 1.
   }
 
   /**

package/lib/ads/ad_manager.js

@@ -449,6 +449,7 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
       this.ssAdManager_.release();
       this.ssAdManager_ = null;
     }
+    super.release();
   }
 
 

package/lib/cast/cast_proxy.js

@@ -120,6 +120,9 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
     this.videoProxy_ = null;
     this.playerProxy_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return Promise.all(waitFor);
   }
 

package/lib/cast/cast_receiver.js

@@ -238,6 +238,9 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
     this.shakaBus_ = null;
     this.genericBus_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     await Promise.all(waitFor);
 
     const manager = cast.receiver.CastReceiverManager.getInstance();

package/lib/dash/dash_parser.js

@@ -396,6 +396,24 @@ shaka.dash.DashParser = class {
           this.config_.dash.autoCorrectDrift);
     }
 
+    presentationTimeline.setStatic(mpdType == 'static');
+
+    const isLive = presentationTimeline.isLive();
+
+    // If it's live, we check for an override.
+    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
+      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
+    }
+
+    // If it's null, that means segments are always available.  This is always
+    // the case for VOD, and sometimes the case for live.
+    if (segmentAvailabilityDuration == null) {
+      segmentAvailabilityDuration = Infinity;
+    }
+
+    presentationTimeline.setSegmentAvailabilityDuration(
+        segmentAvailabilityDuration);
+
     const profiles = mpd.getAttribute('profiles') || '';
 
     /** @type {shaka.dash.DashParser.Context} */
@@ -418,7 +436,6 @@ shaka.dash.DashParser = class {
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
-    presentationTimeline.setStatic(mpdType == 'static');
     if (mpdType == 'static' ||
         !periodsAndDuration.durationDerivedFromPeriods) {
       // Ignore duration calculated from Period lengths if this is dynamic.
@@ -437,6 +454,7 @@ shaka.dash.DashParser = class {
         this.lowLatencyMode_ = this.playerInterface_.isLowLatencyMode();
       }
     }
+
     if (this.lowLatencyMode_) {
       presentationTimeline.setAvailabilityTimeOffset(
           this.minTotalAvailabilityTimeOffset_);
@@ -450,22 +468,6 @@ shaka.dash.DashParser = class {
         'https://bit.ly/3clctcj for details.');
     }
 
-    const isLive = presentationTimeline.isLive();
-
-    // If it's live, we check for an override.
-    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
-      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
-    }
-
-    // If it's null, that means segments are always available.  This is always
-    // the case for VOD, and sometimes the case for live.
-    if (segmentAvailabilityDuration == null) {
-      segmentAvailabilityDuration = Infinity;
-    }
-
-    presentationTimeline.setSegmentAvailabilityDuration(
-        segmentAvailabilityDuration);
-
     // Use @maxSegmentDuration to override smaller, derived values.
     presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
     if (goog.DEBUG) {
@@ -700,8 +702,12 @@ shaka.dash.DashParser = class {
 
     const eventStreamNodes =
         XmlUtils.findChildren(periodInfo.node, 'EventStream');
+    const availabilityStart =
+        context.presentationTimeline.getSegmentAvailabilityStart();
+
     for (const node of eventStreamNodes) {
-      this.parseEventStream_(periodInfo.start, periodInfo.duration, node);
+      this.parseEventStream_(
+          periodInfo.start, periodInfo.duration, node, availabilityStart);
     }
 
     const adaptationSetNodes =
@@ -1732,9 +1738,10 @@ shaka.dash.DashParser = class {
    * @param {number} periodStart
    * @param {?number} periodDuration
    * @param {!Element} elem
+   * @param {number} availabilityStart
    * @private
    */
-  parseEventStream_(periodStart, periodDuration, elem) {
+  parseEventStream_(periodStart, periodDuration, elem, availabilityStart) {
     const XmlUtils = shaka.util.XmlUtils;
     const parseNumber = XmlUtils.parseNonNegativeInt;
 
@@ -1757,6 +1764,11 @@ shaka.dash.DashParser = class {
         endTime = Math.min(endTime, periodStart + periodDuration);
       }
 
+      // Don't add unavailable regions to the timeline.
+      if (endTime < availabilityStart) {
+        continue;
+      }
+
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = {
         schemeIdUri: schemeIdUri,

package/lib/hls/manifest_text_parser.js

@@ -277,6 +277,7 @@ shaka.hls.ManifestTextParser = class {
         const attrValue = blockAttrs[2] || blockAttrs[3];
         const attribute = new shaka.hls.Attribute(attrName, attrValue);
         attributes.push(attribute);
+        parser.skipWhitespace();
       }
     }
 

package/lib/media/region_observer.js

@@ -8,16 +8,19 @@ goog.provide('shaka.media.RegionObserver');
 
 goog.require('shaka.media.IPlayheadObserver');
 goog.require('shaka.media.RegionTimeline');
+goog.require('shaka.util.EventManager');
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 
 
 /**
  * The region observer watches a region timeline and playhead, and fires events
- * (onEnter, onExit, and onSkip) as the playhead moves.
+ * ('enter', 'exit', 'skip') as the playhead moves.
  *
  * @implements {shaka.media.IPlayheadObserver}
  * @final
  */
-shaka.media.RegionObserver = class {
+shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
   /**
    * Create a region observer for the given timeline. The observer does not
    * own the timeline, only uses it. This means that the observer should NOT
@@ -26,6 +29,8 @@ shaka.media.RegionObserver = class {
    * @param {!shaka.media.RegionTimeline} timeline
    */
   constructor(timeline) {
+    super();
+
     /** @private {shaka.media.RegionTimeline} */
     this.timeline_ = timeline;
 
@@ -39,13 +44,6 @@ shaka.media.RegionObserver = class {
      */
     this.oldPosition_ = new Map();
 
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onEnter_ = (region, seeking) => {};
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onExit_ = (region, seeking) => {};
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onSkip_ = (region, seeking) => {};
-
     // To make the rules easier to read, alias all the relative positions.
     const RelativePosition = shaka.media.RegionObserver.RelativePosition_;
     const BEFORE_THE_REGION = RelativePosition.BEFORE_THE_REGION;
@@ -62,39 +60,48 @@ shaka.media.RegionObserver = class {
       {
         weWere: null,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: BEFORE_THE_REGION,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: AFTER_THE_REGION,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: IN_THE_REGION,
         weAre: BEFORE_THE_REGION,
-        invoke: (region, seeking) => this.onExit_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('exit', region, seeking),
       },
       {
         weWere: IN_THE_REGION,
         weAre: AFTER_THE_REGION,
-        invoke: (region, seeking) => this.onExit_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('exit', region, seeking),
       },
       {
         weWere: BEFORE_THE_REGION,
         weAre: AFTER_THE_REGION,
-        invoke: (region, seeking) => this.onSkip_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('skip', region, seeking),
       },
       {
         weWere: AFTER_THE_REGION,
         weAre: BEFORE_THE_REGION,
-        invoke: (region, seeking) => this.onSkip_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('skip', region, seeking),
       },
     ];
+
+    /** @private {shaka.util.EventManager} */
+    this.eventManager_ = new shaka.util.EventManager();
+
+    this.eventManager_.listen(this.timeline_, 'regionremove', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
+      this.oldPosition_.delete(region);
+    });
   }
 
   /** @override */
@@ -105,11 +112,10 @@ shaka.media.RegionObserver = class {
     // needed.
     this.oldPosition_.clear();
 
-    // Clear the callbacks so that we don't hold onto any references external
-    // to this class.
-    this.onEnter_ = (region, seeking) => {};
-    this.onExit_ = (region, seeking) => {};
-    this.onSkip_ = (region, seeking) => {};
+    this.eventManager_.release();
+    this.eventManager_ = null;
+
+    super.release();
   }
 
   /** @override */
@@ -134,20 +140,20 @@ shaka.media.RegionObserver = class {
   }
 
   /**
-   * Set all the listeners. This overrides any previous calls to |setListeners|.
+   * Dispatch events of the given type.  All event types in this class have the
+   * same parameters: region and seeking.
    *
-   * @param {shaka.media.RegionObserver.EventListener} onEnter
-   *    The callback for when we move from outside a region to inside a region.
-   * @param {shaka.media.RegionObserver.EventListener} onExit
-   *    The callback for when we move from inside a region to outside a region.
-   * @param {shaka.media.RegionObserver.EventListener} onSkip
-   *    The callback for when we move from before to after a region or from
-   *    after to before a region.
+   * @param {string} eventType
+   * @param {shaka.extern.TimelineRegionInfo} region
+   * @param {boolean} seeking
+   * @private
    */
-  setListeners(onEnter, onExit, onSkip) {
-    this.onEnter_ = onEnter;
-    this.onExit_ = onExit;
-    this.onSkip_ = onSkip;
+  onEvent_(eventType, region, seeking) {
+    const event = new shaka.util.FakeEvent(eventType, new Map([
+      ['region', region],
+      ['seeking', seeking],
+    ]));
+    this.dispatchEvent(event);
   }
 
   /**

package/lib/media/region_timeline.js

@@ -6,26 +6,30 @@
 
 goog.provide('shaka.media.RegionTimeline');
 
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
 
 
 /**
  * The region timeline is a set of unique timeline region info entries. When
- * a new entry is added, the |onAddRegion| callback will be called.
+ * a new entry is added, the 'regionadd' event will be fired.  When an entry is
+ * deleted, the 'regionremove' event will be fired.
  *
  * @implements {shaka.util.IReleasable}
  * @final
  */
-shaka.media.RegionTimeline = class {
+shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
   /**
    * @param {!function():{start: number, end: number}} getSeekRange
    */
   constructor(getSeekRange) {
-    /** @private {function(shaka.extern.TimelineRegionInfo)} */
-    this.onAddRegion_ = (region) => {};
+    super();
+
     /** @private {!Set.<shaka.extern.TimelineRegionInfo>} */
     this.regions_ = new Set();
+
     /** @private {!function():{start: number, end: number}} */
     this.getSeekRange_ = getSeekRange;
 
@@ -44,22 +48,9 @@ shaka.media.RegionTimeline = class {
 
   /** @override */
   release() {
-    // Prevent us from holding onto any external references via the callback.
-    this.onAddRegion_ = (region) => {};
     this.regions_.clear();
     this.filterTimer_.stop();
-  }
-
-  /**
-   * Set the callbacks for events. This will override any previous calls to
-   * |setListeners|.
-   *
-   * @param {function(shaka.extern.TimelineRegionInfo)} onAddRegion
-   *    Set the callback for when we add a new region. This callback will only
-   *    be called when a region is unique (we reject duplicate regions).
-   */
-  setListeners(onAddRegion) {
-    this.onAddRegion_ = onAddRegion;
+    super.release();
   }
 
   /**
@@ -72,7 +63,10 @@ shaka.media.RegionTimeline = class {
     // instead of making the parser track it.
     if (similarRegion == null) {
       this.regions_.add(region);
-      this.onAddRegion_(region);
+      const event = new shaka.util.FakeEvent('regionadd', new Map([
+        ['region', region],
+      ]));
+      this.dispatchEvent(event);
     }
   }
 
@@ -89,6 +83,10 @@ shaka.media.RegionTimeline = class {
       // reson to store or process them.
       if (region.endTime < seekRange.start) {
         this.regions_.delete(region);
+        const event = new shaka.util.FakeEvent('regionremove', new Map([
+          ['region', region],
+        ]));
+        this.dispatchEvent(event);
       }
     }
   }

package/lib/media/streaming_engine.js

@@ -1644,7 +1644,7 @@ shaka.media.StreamingEngine = class {
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
-    if (emsgSchemeIdUris.includes(schemeId)) {
+    if (emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {

package/lib/net/networking_engine.js

@@ -222,6 +222,10 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     this.destroyed_ = true;
     this.requestFilters_.clear();
     this.responseFilters_.clear();
+
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return this.operationManager_.destroy();
   }
 

package/lib/offline/storage.js

@@ -477,23 +477,22 @@ shaka.offline.Storage = class {
    * @private
    */
   async filterManifest_(manifest, drmEngine, config) {
-    const StreamUtils = shaka.util.StreamUtils;
-
     // Filter the manifest based on the restrictions given in the player
     // configuration.
     const maxHwRes = {width: Infinity, height: Infinity};
-    StreamUtils.filterByRestrictions(manifest, config.restrictions, maxHwRes);
+    shaka.util.StreamUtils.filterByRestrictions(
+        manifest, config.restrictions, maxHwRes);
 
     // Filter the manifest based on what we know media source will be able to
     // play later (no point storing something we can't play).
     if (config.useMediaCapabilities) {
-      StreamUtils.filterManifestByMediaCapabilities(
+      await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
           manifest, config.offline.usePersistentLicense);
     } else {
-      StreamUtils.filterManifestByMediaSource(manifest);
+      shaka.util.StreamUtils.filterManifestByMediaSource(manifest);
       // Filter the manifest based on what we know our drm system will support
       // playing later.
-      StreamUtils.filterManifestByDrm(manifest, drmEngine);
+      shaka.util.StreamUtils.filterManifestByDrm(manifest, drmEngine);
     }
 
     // Gather all tracks.
@@ -501,23 +500,23 @@ shaka.offline.Storage = class {
 
     // Choose the codec that has the lowest average bandwidth.
     const preferredAudioChannelCount = config.preferredAudioChannelCount;
-    StreamUtils.chooseCodecsAndFilterManifest(
+    shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
         manifest, preferredAudioChannelCount);
 
     for (const variant of manifest.variants) {
       goog.asserts.assert(
-          StreamUtils.isPlayable(variant),
+          shaka.util.StreamUtils.isPlayable(variant),
           'We should have already filtered by "is playable"');
 
-      allTracks.push(StreamUtils.variantToTrack(variant));
+      allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
     }
 
     for (const text of manifest.textStreams) {
-      allTracks.push(StreamUtils.textStreamToTrack(text));
+      allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
     }
 
     for (const image of manifest.imageStreams) {
-      allTracks.push(StreamUtils.imageStreamToTrack(image));
+      allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
     }
 
     // Let the application choose which tracks to store.

package/lib/player.js

@@ -726,6 +726,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       await this.networkingEngine_.destroy();
       this.networkingEngine_ = null;
     }
+
+    // FakeEventTarget implements IReleasable
+    super.release();
   }
 
   /**
@@ -1627,8 +1630,11 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // initialize it now even through it appears a little out-of-place.
     this.regionTimeline_ =
         new shaka.media.RegionTimeline(() => this.seekRange());
-    this.regionTimeline_.setListeners(/* onRegionAdded= */ (region) => {
+    this.regionTimeline_.addEventListener('regionadd', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
       this.onRegionEvent_(shaka.Player.EventName.TimelineRegionAdded, region);
+
       if (this.adManager_) {
         this.adManager_.onDashTimedMetadata(region);
       }
@@ -2519,21 +2525,31 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Create the region observer. This will allow us to notify the app when we
     // move in and out of timeline regions.
     const regionObserver = new shaka.media.RegionObserver(this.regionTimeline_);
-    const onEnterRegion = (region, seeking) => {
+
+    regionObserver.addEventListener('enter', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
       this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
-    };
-    const onExitRegion = (region, seeking) => {
+    });
+
+    regionObserver.addEventListener('exit', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
       this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
-    };
-    const onSkipRegion = (region, seeking) => {
+    });
+
+    regionObserver.addEventListener('skip', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
+      /** @type {boolean} */
+      const seeking = event['seeking'];
       // If we are seeking, we don't want to surface the enter/exit events since
       // they didn't play through them.
       if (!seeking) {
         this.onRegionEvent_(shaka.Player.EventName.TimelineRegionEnter, region);
         this.onRegionEvent_(shaka.Player.EventName.TimelineRegionExit, region);
       }
-    };
-    regionObserver.setListeners(onEnterRegion, onExitRegion, onSkipRegion);
+    });
 
     // Now that we have all our observers, create a manager for them.
     const manager = new shaka.media.PlayheadObserverManager(this.video_);
@@ -6102,7 +6118,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.1.5-uncompiled';
+shaka.Player.version = 'v3.1.6-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/fake_event_target.js

@@ -9,6 +9,7 @@ goog.provide('shaka.util.FakeEventTarget');
 goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.MultiMap');
 
 
@@ -18,13 +19,14 @@ goog.require('shaka.util.MultiMap');
  * to non-DOM classes.  Only FakeEvents should be dispatched.
  *
  * @implements {EventTarget}
+ * @implements {shaka.util.IReleasable}
  * @exportInterface
  */
 shaka.util.FakeEventTarget = class {
   /** */
   constructor() {
     /**
-     * @private {!shaka.util.MultiMap.<shaka.util.FakeEventTarget.ListenerType>}
+     * @private {shaka.util.MultiMap.<shaka.util.FakeEventTarget.ListenerType>}
      */
     this.listeners_ = new shaka.util.MultiMap();
 
@@ -46,6 +48,9 @@ shaka.util.FakeEventTarget = class {
    * @exportInterface
    */
   addEventListener(type, listener, options) {
+    if (!this.listeners_) {
+      return;
+    }
     this.listeners_.push(type, listener);
   }
 
@@ -73,6 +78,9 @@ shaka.util.FakeEventTarget = class {
    * @exportInterface
    */
   removeEventListener(type, listener, options) {
+    if (!this.listeners_) {
+      return;
+    }
     this.listeners_.remove(type, listener);
   }
 
@@ -90,6 +98,10 @@ shaka.util.FakeEventTarget = class {
     goog.asserts.assert(event instanceof shaka.util.FakeEvent,
         'FakeEventTarget can only dispatch FakeEvents!');
 
+    if (!this.listeners_) {
+      return true;
+    }
+
     let listeners = this.listeners_.get(event.type) || [];
     const universalListeners =
       this.listeners_.get(shaka.util.FakeEventTarget.ALL_EVENTS_);
@@ -129,6 +141,14 @@ shaka.util.FakeEventTarget = class {
 
     return event.defaultPrevented;
   }
+
+  /**
+   * @override
+   * @exportInterface
+   */
+  release() {
+    this.listeners_ = null;
+  }
 };
 
 /**