shaka-player 3.1.2 → 3.1.6

package/docs/tutorials/fairplay.md

@@ -31,7 +31,7 @@ player.configure('drm.initDataTransform', (initData, initDataType) => {
 
   // 'initData' is a buffer containing an 'skd://' URL as a UTF-8 string.
   const skdUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
-  const contentId = getMyContentId(sdkUri);
+  const contentId = getMyContentId(skdUri);
   const cert = player.drmInfo().serverCertificate;
   return shaka.util.FairPlayUtils.initDataTransform(initData, contentId, cert);
 });

package/docs/tutorials/faq.md

@@ -260,6 +260,20 @@ the {@link shaka.extern.ManifestConfiguration|`.manifest.disableVideo`} or
 configurations to signal that your content does not have a video or audio 
 stream.
 
+<hr>
+
+**Q:** How can I make Shaka Player work with Vue?
+
+**A:** Currently, Shaka Player does not support being made into a Vue reactive
+object. When Vue wraps an object in a reactive Proxy, it
+{@link https://v3.vuejs.org/guide/reactivity.html#proxied-objects|also wraps
+nested objects}. This results in Vue converting some of our internal values into
+Proxy objects, which causes failures at load-time.
+If you want to use Shaka Player in Vue, avoid making it into a reactive object;
+so don't declare it using a ref(), and if you put your player instance into a
+data() object, you can prefix the property name with "$" or "_" to make Vue not
+proxy them.
+
 [386]: https://github.com/google/shaka-player/issues/386#issuecomment-227898001
 [489]: https://github.com/google/shaka-player/issues/489#issuecomment-240466224
 [743]: https://github.com/google/shaka-player/issues/743

package/externs/ima.js

@@ -43,6 +43,8 @@ google.ima.AdsLoader = class {
 
   /** @override */
   dispatchEvent() {}
+
+  destroy() {}
 };
 
 
@@ -79,6 +81,8 @@ google.ima.AdsManager = class {
 
   stop() {}
 
+  destroy() {}
+
   /**
    * @param {number} volume
    */

package/externs/shaka/ads.js

@@ -46,6 +46,8 @@ shaka.extern.IAdManager = class extends EventTarget {
    */
   setLocale(locale) {}
 
+  release() {}
+
   onAssetUnload() {}
 
   /**

package/externs/shaka/text.js

@@ -349,6 +349,16 @@ shaka.extern.Cue = class {
      */
     this.nestedCues;
 
+    /**
+     * If true, this represents a container element that is "above" the main
+     * cues. For example, the <body> and <div> tags that contain the <p> tags
+     * in a TTML file. This controls the flow of the final cues; any nested cues
+     * within an "isContainer" cue will be laid out as separate lines.
+     * @type {boolean}
+     * @exportDoc
+     */
+    this.isContainer;
+
     /**
      * Whether or not the cue only acts as a line break between two nested cues.
      * Should only appear in nested cues.

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');
 
@@ -140,6 +141,7 @@ module.exports = (config) => {
         included: false,
       },
       {pattern: 'test/test/assets/*', included: false},
+      {pattern: 'test/test/assets/3675/*', included: false},
       {pattern: 'dist/shaka-player.ui.js', included: false},
       {pattern: 'dist/locales.js', included: false},
       {pattern: 'demo/locales/en.json', included: false},
@@ -335,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.
@@ -517,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);
@@ -603,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

@@ -16,6 +16,7 @@ goog.require('shaka.log');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.FakeEventTarget');
+goog.require('shaka.util.IReleasable');
 
 
 /**
@@ -359,6 +360,7 @@ goog.require('shaka.util.FakeEventTarget');
 /**
  * A class responsible for ad-related interactions.
  * @implements {shaka.extern.IAdManager}
+ * @implements {shaka.util.IReleasable}
  * @export
  */
 shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
@@ -403,6 +405,10 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
           shaka.util.Error.Code.CS_IMA_SDK_MISSING);
     }
 
+    if (this.csAdManager_) {
+      this.csAdManager_.release();
+    }
+
     this.csAdManager_ = new shaka.ads.ClientSideAdManager(
         adContainer, video, this.locale_,
         (e) => {
@@ -430,6 +436,23 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
   }
 
 
+  /**
+   * @override
+   * @export
+   */
+  release() {
+    if (this.csAdManager_) {
+      this.csAdManager_.release();
+      this.csAdManager_ = null;
+    }
+    if (this.ssAdManager_) {
+      this.ssAdManager_.release();
+      this.ssAdManager_ = null;
+    }
+    super.release();
+  }
+
+
   /**
   * @override
   * @export
@@ -438,21 +461,13 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
     if (this.csAdManager_) {
       this.csAdManager_.stop();
     }
+    if (this.ssAdManager_) {
+      this.ssAdManager_.stop();
+    }
 
     this.dispatchEvent(
         new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED));
 
-    // TODO:
-    // For SS DAI streams, if a different asset gets unloaded as
-    // part of the process
-    // of loading a DAI asset, stream manager state gets reset and we
-    // don't get any ad events.
-    // We need to figure out if it makes sense to stop the SS
-    // manager on unload, and, if it does, find
-    // a way to do it safely.
-    // if (this.ssAdManager_) {
-    //   this.ssAdManager_.stop();
-    // }
     this.stats_ = new shaka.ads.AdsStats();
   }
 
@@ -491,6 +506,10 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
           shaka.util.Error.Code.SS_IMA_SDK_MISSING);
     }
 
+    if (this.ssAdManager_) {
+      this.ssAdManager_.release();
+    }
+
     this.ssAdManager_ = new shaka.ads.ServerSideAdManager(
         adContainer, video, this.locale_,
         (e) => {

package/lib/ads/client_side_ad_manager.js

@@ -13,10 +13,12 @@ goog.provide('shaka.ads.ClientSideAdManager');
 
 goog.require('goog.asserts');
 goog.require('shaka.ads.ClientSideAd');
+goog.require('shaka.util.IReleasable');
 
 
 /**
  * A class responsible for client-side ad interactions.
+ * @implements {shaka.util.IReleasable}
  */
 shaka.ads.ClientSideAdManager = class {
   /**
@@ -32,6 +34,9 @@ shaka.ads.ClientSideAdManager = class {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
+    /** @private {ResizeObserver} */
+    this.resizeObserver_ = null;
+
     /** @private {number} */
     this.requestAdsStartTime_ = NaN;
 
@@ -106,6 +111,21 @@ shaka.ads.ClientSideAdManager = class {
     }
   }
 
+  /** @override */
+  release() {
+    this.stop();
+    if (this.resizeObserver_) {
+      this.resizeObserver_.disconnect();
+    }
+    if (this.eventManager_) {
+      this.eventManager_.release();
+    }
+    if (this.imaAdsManager_) {
+      this.imaAdsManager_.destroy();
+    }
+    this.adsLoader_.destroy();
+  }
+
   /**
    * @param {!google.ima.AdErrorEvent} e
    * @private
@@ -118,7 +138,7 @@ shaka.ads.ClientSideAdManager = class {
     // Remove ad breaks from the timeline
     this.onEvent_(
         new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-            {'cuepoints': []}));
+            (new Map()).set('cuepoints', [])));
   }
 
 
@@ -131,17 +151,14 @@ shaka.ads.ClientSideAdManager = class {
 
     const now = Date.now() / 1000;
     const loadTime = now - this.requestAdsStartTime_;
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
-            {'loadTime': loadTime}));
+    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
+        (new Map()).set('loadTime', loadTime)));
 
     this.imaAdsManager_ = e.getAdsManager(this.video_);
 
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.IMA_AD_MANAGER_LOADED,
-        {
-          'imaAdManager': this.imaAdsManager_,
-        }));
+        (new Map()).set('imaAdManager', this.imaAdsManager_)));
 
     const cuePointStarts = this.imaAdsManager_.getCuePoints();
     if (cuePointStarts.length) {
@@ -152,9 +169,9 @@ shaka.ads.ClientSideAdManager = class {
         cuePoints.push(shakaCuePoint);
       }
 
-      this.onEvent_(
-          new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-              {'cuepoints': cuePoints}));
+      this.onEvent_(new shaka.util.FakeEvent(
+          shaka.ads.AdManager.CUEPOINTS_CHANGED,
+          (new Map()).set('cuepoints', cuePoints)));
     }
 
     this.addImaEventListeners_();
@@ -176,6 +193,16 @@ shaka.ads.ClientSideAdManager = class {
             this.video_.offsetHeight, viewMode);
       });
 
+      if ('ResizeObserver' in window) {
+        this.resizeObserver_ = new ResizeObserver(() => {
+          const viewMode = document.fullscreenElement ?
+              google.ima.ViewMode.FULLSCREEN : google.ima.ViewMode.NORMAL;
+          this.imaAdsManager_.resize(this.video_.offsetWidth,
+              this.video_.offsetHeight, viewMode);
+        });
+        this.resizeObserver_.observe(this.video_);
+      }
+
       // Single video and overlay ads will start at this time
       // TODO (ismena): Need a better inderstanding of what this does.
       // The docs say it's called to 'start playing the ads,' but I haven't
@@ -194,6 +221,15 @@ shaka.ads.ClientSideAdManager = class {
    * @private
    */
   addImaEventListeners_() {
+    /**
+     * @param {!Event} e
+     * @param {string} type
+     */
+    const convertEventAndSend = (e, type) => {
+      const data = (new Map()).set('originalEvent', e);
+      this.onEvent_(new shaka.util.FakeEvent(type, data));
+    };
+
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdErrorEvent.Type.AD_ERROR, (error) => {
           this.onAdError_(/** @type {!google.ima.AdErrorEvent} */ (error));
@@ -211,30 +247,22 @@ shaka.ads.ClientSideAdManager = class {
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.FIRST_QUARTILE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_FIRST_QUARTILE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_FIRST_QUARTILE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.MIDPOINT, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MIDPOINT,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_MIDPOINT);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.THIRD_QUARTILE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_THIRD_QUARTILE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_THIRD_QUARTILE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.COMPLETE, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_COMPLETE,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_COMPLETE);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
@@ -249,140 +277,102 @@ shaka.ads.ClientSideAdManager = class {
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.SKIPPED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_SKIPPED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_SKIPPED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.VOLUME_CHANGED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_VOLUME_CHANGED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_VOLUME_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.VOLUME_MUTED, (e) => {
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_MUTED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_MUTED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.PAUSED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
           this.ad_.setPaused(true);
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_PAUSED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_PAUSED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.RESUMED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
           this.ad_.setPaused(false);
-          this.onEvent_(
-              new shaka.util.FakeEvent(shaka.ads.AdManager.AD_RESUMED,
-                  {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_RESUMED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.SKIPPABLE_STATE_CHANGED, (e) => {
           goog.asserts.assert(this.ad_ != null, 'Ad should not be null!');
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_SKIP_STATE_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_SKIP_STATE_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.CLICK, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_CLICKED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_CLICKED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_PROGRESS, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_PROGRESS,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_PROGRESS);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_BUFFERING, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_BUFFERING,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_BUFFERING);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.IMPRESSION, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_IMPRESSION,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_IMPRESSION);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.DURATION_CHANGE, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_DURATION_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_DURATION_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.USER_CLOSE, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_CLOSED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_CLOSED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LOADED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_LOADED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_LOADED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.ALL_ADS_COMPLETED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.ALL_ADS_COMPLETED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.ALL_ADS_COMPLETED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LINEAR_CHANGED, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_LINEAR_CHANGED,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_LINEAR_CHANGED);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_METADATA, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_METADATA,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_METADATA);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.LOG, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_RECOVERABLE_ERROR,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_RECOVERABLE_ERROR);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.AD_BREAK_READY, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_BREAK_READY,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_BREAK_READY);
         });
 
     this.eventManager_.listen(this.imaAdsManager_,
         google.ima.AdEvent.Type.INTERACTION, (e) => {
-          this.onEvent_(new shaka.util.FakeEvent(
-              shaka.ads.AdManager.AD_INTERACTION,
-              {'originalEvent': e}));
+          convertEventAndSend(e, shaka.ads.AdManager.AD_INTERACTION);
         });
   }
 
@@ -396,12 +386,12 @@ shaka.ads.ClientSideAdManager = class {
 
     const imaAd = e.getAd();
     this.ad_ = new shaka.ads.ClientSideAd(imaAd, this.imaAdsManager_);
-    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
-        {
-          'ad': this.ad_,
-          'sdkAdObject': imaAd,
-          'originalEvent': e,
-        }));
+    const data = new Map()
+        .set('ad', this.ad_)
+        .set('sdkAdObject', imaAd)
+        .set('originalEvent', e);
+    this.onEvent_(new shaka.util.FakeEvent(
+        shaka.ads.AdManager.AD_STARTED, data));
     this.adContainer_.setAttribute('ad-active', 'true');
     this.video_.pause();
   }
@@ -412,7 +402,7 @@ shaka.ads.ClientSideAdManager = class {
    */
   onAdComplete_(e) {
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STOPPED,
-        {'originalEvent': e}));
+        (new Map()).set('originalEvent', e)));
     this.adContainer_.removeAttribute('ad-active');
     this.video_.play();
   }

package/lib/ads/server_side_ad_manager.js

@@ -14,10 +14,12 @@ goog.provide('shaka.ads.ServerSideAdManager');
 goog.require('goog.asserts');
 goog.require('shaka.ads.ServerSideAd');
 goog.require('shaka.log');
+goog.require('shaka.util.IReleasable');
 
 
 /**
  * A class responsible for server-side ad interactions.
+ * @implements {shaka.util.IReleasable}
  */
 shaka.ads.ServerSideAdManager = class {
   /**
@@ -75,9 +77,7 @@ shaka.ads.ServerSideAdManager = class {
 
     this.onEvent_(new shaka.util.FakeEvent(
         shaka.ads.AdManager.IMA_STREAM_MANAGER_LOADED,
-        {
-          'imaStreamManager': this.streamManager_,
-        }));
+        (new Map()).set('imaStreamManager', this.streamManager_)));
 
     // Events
     this.eventManager_.listen(this.streamManager_,
@@ -201,11 +201,27 @@ shaka.ads.ServerSideAdManager = class {
    * Resets the stream manager and removes any continuous polling.
    */
   stop() {
-    this.streamManager_.reset();
+    // TODO:
+    // For SS DAI streams, if a different asset gets unloaded as
+    // part of the process
+    // of loading a DAI asset, stream manager state gets reset and we
+    // don't get any ad events.
+    // We need to figure out if it makes sense to stop the SS
+    // manager on unload, and, if it does, find
+    // a way to do it safely.
+    // this.streamManager_.reset();
     this.backupUrl_ = '';
     this.snapForwardTime_ = null;
   }
 
+  /** @override */
+  release() {
+    this.stop();
+    if (this.eventManager_) {
+      this.eventManager_.release();
+    }
+  }
+
   /**
    * @param {string} type
    * @param {Uint8Array|string} data
@@ -280,7 +296,7 @@ shaka.ads.ServerSideAdManager = class {
     }
 
     this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.AD_STARTED,
-        {'ad': this.ad_}));
+        (new Map()).set('ad', this.ad_)));
     this.adContainer_.setAttribute('ad-active', 'true');
   }
 
@@ -306,9 +322,8 @@ shaka.ads.ServerSideAdManager = class {
   onLoaded_(e) {
     const now = Date.now() / 1000;
     const loadTime = now - this.streamRequestStartTime_;
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
-            {'loadTime': loadTime}));
+    this.onEvent_(new shaka.util.FakeEvent(shaka.ads.AdManager.ADS_LOADED,
+        (new Map()).set('loadTime', loadTime)));
 
     const streamData = e.getStreamData();
     const url = streamData.url;
@@ -368,8 +383,8 @@ shaka.ads.ServerSideAdManager = class {
       cuePoints.push(shakaCuePoint);
     }
 
-    this.onEvent_(
-        new shaka.util.FakeEvent(shaka.ads.AdManager.CUEPOINTS_CHANGED,
-            {'cuepoints': cuePoints}));
+    this.onEvent_(new shaka.util.FakeEvent(
+        shaka.ads.AdManager.CUEPOINTS_CHANGED,
+        (new Map()).set('cuepoints', cuePoints)));
   }
 };