shaka-player 3.0.11 → 3.0.15

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

@@ -35,6 +35,17 @@ headers in the response.  Additionally, with some manifests, we will send a
 This can also happen with mixed-content restrictions.  If the site is using
 `https:`, then your manifest and segments must also.
 
+*Sending `Range` header at the start of HLS playback can be disabled using this config:*
+```
+player.configure({
+    manifest: {
+        hls: {
+            useFullSegmentsForStartTime: true,
+        },
+    },
+})
+```
+
 <hr>
 
 **Q:** I am getting `REQUESTED_KEY_SYSTEM_CONFIG_UNAVAILABLE` or error code
@@ -238,6 +249,20 @@ the [`.manifest.disableVideo`][ManifestConfiguration] or
 [`.manifest.disableAudio`][ManifestConfiguration] 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/aria.js

@@ -0,0 +1,18 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Externs for ARIA properties which are missing from the Closure
+ * compiler.
+ *
+ * @externs
+ */
+
+/** @type {string} */
+Element.prototype.ariaLabel;
+
+/** @type {string} */
+Element.prototype.ariaPressed;

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/karma.conf.js

@@ -136,6 +136,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},

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,22 @@ 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;
+    }
+  }
+
+
   /**
   * @override
   * @export
@@ -438,21 +460,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 +505,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)));
   }
 };

package/lib/cast/cast_proxy.js

@@ -526,7 +526,8 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Wrong error type!');
       const eventType = shaka.Player.EventName.Error;
-      const event = new shaka.util.FakeEvent(eventType, {'detail': error});
+      const data = (new Map()).set('detail', error);
+      const event = new shaka.util.FakeEvent(eventType, data);
       this.localPlayer_.dispatchEvent(event);
     });
   }
@@ -599,7 +600,7 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
 
     // Convert this real Event into a FakeEvent for dispatch from our
     // FakeEventListener.
-    const fakeEvent = new shaka.util.FakeEvent(event.type, event);
+    const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
     this.videoEventTarget_.dispatchEvent(fakeEvent);
   }
 

package/lib/cast/cast_receiver.js

@@ -407,8 +407,12 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
         goog.asserts.assert(error instanceof shaka.util.Error,
             'Wrong error type!');
         const eventType = shaka.Player.EventName.Error;
-        const event = new shaka.util.FakeEvent(eventType, {'detail': error});
-        this.player_.dispatchEvent(event);
+        const data = (new Map()).set('detail', error);
+        const event = new shaka.util.FakeEvent(eventType, data);
+        // Only dispatch the event if the player still exists.
+        if (this.player_) {
+          this.player_.dispatchEvent(event);
+        }
         return;
       }
     } else {

package/lib/cast/cast_sender.js

@@ -647,7 +647,7 @@ shaka.cast.CastSender = class {
       case 'event': {
         const targetName = message['targetName'];
         const event = message['event'];
-        const fakeEvent = new shaka.util.FakeEvent(event['type'], event);
+        const fakeEvent = shaka.util.FakeEvent.fromRealEvent(event);
         this.onRemoteEvent_(targetName, fakeEvent);
         break;
       }
@@ -725,7 +725,7 @@ shaka.cast.CastSender = class {
 
       // Dispatch it through the Player proxy
       const fakeEvent = new shaka.util.FakeEvent(
-          'error', {'detail': shakaError});
+          'error', (new Map()).set('detail', shakaError));
       this.onRemoteEvent_('player', fakeEvent);
 
       // Force this session to disconnect and transfer playback to the local