shaka-player 3.2.2 → 3.3.2

package/lib/offline/stored_content_utils.js

@@ -47,6 +47,7 @@ shaka.offline.StoredContentUtils = class {
       expiration: Infinity,
       tracks: tracks,
       appMetadata: metadata,
+      isIncomplete: false,
     };
 
     return content;
@@ -87,6 +88,7 @@ shaka.offline.StoredContentUtils = class {
       expiration: manifestDB.expiration,
       tracks: tracks,
       appMetadata: metadata,
+      isIncomplete: (manifestDB.isIncomplete || false),
     };
 
     return content;

package/lib/player.js

@@ -22,6 +22,7 @@ goog.require('shaka.media.PlayRateController');
 goog.require('shaka.media.Playhead');
 goog.require('shaka.media.PlayheadObserverManager');
 goog.require('shaka.media.PreferenceBasedCriteria');
+goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.RegionObserver');
 goog.require('shaka.media.RegionTimeline');
 goog.require('shaka.media.SegmentIndex');
@@ -36,6 +37,7 @@ goog.require('shaka.text.UITextDisplayer');
 goog.require('shaka.text.WebVttGenerator');
 goog.require('shaka.util.AbortableOperation');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.CmcdManager');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
@@ -106,6 +108,32 @@ goog.requireType('shaka.routing.Payload');
  */
 
 
+/**
+ * @event shaka.Player.DownloadFailed
+ * @description Fired when a download has failed, for any reason.
+ *   'downloadfailed'
+ * @property {!shaka.extern.Request} request
+ * @property {?shaka.util.Error} error
+ * @param {number} httpResponseCode
+ * @param {boolean} aborted
+ * @exportDoc
+ */
+
+
+/**
+ * @event shaka.Player.DownloadHeadersReceived
+ * @description Fired when the networking engine has received the headers for
+ *    a download, but before the body has been downloaded.
+ *    If the HTTP plugin being used does not track this information, this event
+ *    will default to being fired when the body is received, instead.
+ * @property {!Object.<string, string>} headers
+ * @property {!shaka.extern.Request} request
+ * @property {!shaka.net.NetworkingEngine.RequestType} type
+ *   'downloadheadersreceived'
+ * @exportDoc
+ */
+
+
 /**
  * @event shaka.Player.DrmSessionUpdateEvent
  * @description Fired when the CDM has accepted the license response.
@@ -147,6 +175,21 @@ goog.requireType('shaka.routing.Payload');
  * @exportDoc
  */
 
+/**
+ * @event shaka.Player.MediaQualityChangedEvent
+ * @description Fired when the media quality changes at the playhead.
+ * That may be caused by an adaptation change or a DASH period transition.
+ * Separate events are emitted for audio and video contentTypes.
+ * This is supported for only DASH streams at this time.
+ * @property {string} type
+ *   'mediaqualitychanged'
+ * @property {shaka.extern.MediaQualityInfo} mediaQuality
+ *   Information about media quality at the playhead position.
+ * @property {number} position
+ *   The playhead position.
+ * @exportDoc
+ */
+
 
 /**
  * @event shaka.Player.BufferingEvent
@@ -441,6 +484,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {shaka.media.RegionTimeline} */
     this.regionTimeline_ = null;
 
+    /** @private {shaka.util.CmcdManager} */
+    this.cmcdManager_ = null;
+
+    /** @private {shaka.media.QualityObserver} */
+    this.qualityObserver_ = null;
+
     /** @private {shaka.media.StreamingEngine} */
     this.streamingEngine_ = null;
 
@@ -507,6 +556,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {!Array.<function():(!Promise|undefined)>} */
     this.cleanupOnUnload_ = [];
 
+    /**
+     * This playback start position will be used when
+     * <code>updateStartTime()</code> has been called to provide an updated
+     * start position during the media loading process.
+     *
+     * @private {?number}
+     */
+    this.updatedStartTime_ = null;
+
     if (dependencyInjector) {
       dependencyInjector(this);
     }
@@ -723,11 +781,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.config_ = null;
     this.stats_ = null;
     this.videoContainer_ = null;
+    this.cmcdManager_ = null;
 
     if (this.networkingEngine_) {
       await this.networkingEngine_.destroy();
       this.networkingEngine_ = null;
     }
+
+    // FakeEventTarget implements IReleasable
+    super.release();
   }
 
   /**
@@ -1020,6 +1082,19 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return this.wrapWalkerListenersWithPromise_(events);
   }
 
+  /**
+   * Provides a way to update the stream start position during the media loading
+   * process. Can for example be called from the <code>manifestparsed</code>
+   * event handler to update the start position based on information in the
+   * manifest.
+   *
+   * @param {number} startTime
+   * @export
+   */
+  updateStartTime(startTime) {
+    this.updatedStartTime_ = startTime;
+  }
+
   /**
    * Tell the player to load the content at <code>assetUri</code> and start
    * playback at <code>startTime</code>. Before calling <code>load</code>,
@@ -1040,6 +1115,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @export
    */
   load(assetUri, startTime, mimeType) {
+    this.updatedStartTime_ = null;
+
     // Do not allow the player to be used after |destroy| is called.
     if (this.loadMode_ == shaka.Player.LoadMode.DESTROYED) {
       return Promise.reject(this.createAbortLoadError_());
@@ -1093,6 +1170,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // before we allow calls to |updateStateHistory|.
     this.stats_ = new shaka.util.Stats();
 
+    // Create the CMCD manager so client data can be attached to all requests
+    this.cmcdManager_ = this.createCmcd_();
+
     // Load's request is a little different, so we can't use our normal
     // listeners-to-promise method. It is the only request where we may skip the
     // request, so we need to set the on skip callback to reject with a specific
@@ -1594,6 +1674,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(
         this.networkingEngine_,
         'Need networking engine to parse manifest.');
+    goog.asserts.assert(
+        this.cmcdManager_,
+        'Need CMCD manager to populate manifest request data.');
     goog.asserts.assert(
         this.config_,
         'Need player config to parse manifest.');
@@ -1611,15 +1694,38 @@ 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);
       }
     });
 
+    this.qualityObserver_ = null;
+    if (this.config_.streaming.observeQualityChanges) {
+      this.qualityObserver_ = new shaka.media.QualityObserver(
+          () => this.getBufferedInfo());
+
+      this.qualityObserver_.addEventListener('qualitychange', (event) => {
+        /** @type {shaka.extern.MediaQualityInfo} */
+        const mediaQualityInfo = event['quality'];
+        /** @type {number} */
+        const position = event['position'];
+        this.onMediaQualityChange_(mediaQualityInfo, position);
+      });
+    }
+
     const playerInterface = {
       networkingEngine: networkingEngine,
+      modifyManifestRequest: (request, manifestInfo) => {
+        this.cmcdManager_.applyManifestData(request, manifestInfo);
+      },
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       filter: (manifest) => this.filterManifest_(manifest),
       makeTextStreamsForClosedCaptions: (manifest) => {
         return this.makeTextStreamsForClosedCaptions_(manifest);
@@ -1780,6 +1886,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // something we are now depending on.
     has.startTime = wants.startTime;
 
+    // If updateStartTime() has been called since load() was invoked use the
+    // requested startTime
+    if (this.updatedStartTime_ != null) {
+      has.startTime = this.updatedStartTime_;
+      this.updatedStartTime_ = null;
+    }
+
     // Store a reference to values in |has| after asserting so that closure will
     // know that they will still be non-null between calls to await.
     const mediaElement = has.mediaElement;
@@ -2177,9 +2290,13 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           this.video_.textTracks, 'change', () => this.onTracksChanged_());
     }
 
+    const extension = shaka.media.ManifestParser.getExtension(has.uri);
+    const mimeType =
+      shaka.Player.SRC_EQUAL_EXTENSIONS_TO_MIME_TYPES_[extension];
+
     // By setting |src| we are done "loading" with src=. We don't need to set
     // the current time because |playhead| will do that for us.
-    has.mediaElement.src = has.uri;
+    has.mediaElement.src = this.cmcdManager_.appendSrcData(has.uri, mimeType);
 
     // Tizen 3 / WebOS won't load anything unless you call load() explicitly,
     // no matter the value of the preload attribute.  This is harmful on some
@@ -2509,8 +2626,30 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.abrManager_.segmentDownloaded(deltaTimeMs, bytesDownloaded);
       }
     };
+    /** @type {shaka.net.NetworkingEngine.OnHeadersReceived} */
+    const onHeadersReceived_ = (headers, request, requestType) => {
+      // Release a 'downloadheadersreceived' event.
+      const name = shaka.Player.EventName.DownloadHeadersReceived;
+      const data = new Map()
+          .set('headers', headers)
+          .set('request', request)
+          .set('requestType', requestType);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
+    /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
+    const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
+      // Release a 'downloadfailed' event.
+      const name = shaka.Player.EventName.DownloadFailed;
+      const data = new Map()
+          .set('request', request)
+          .set('error', error)
+          .set('httpResponseCode', httpResponseCode)
+          .set('aborted', aborted);
+      this.dispatchEvent(this.makeEvent_(name, data));
+    };
 
-    return new shaka.net.NetworkingEngine(onProgressUpdated_);
+    return new shaka.net.NetworkingEngine(
+        onProgressUpdated_, onHeadersReceived_, onDownloadFailed_);
   }
 
   /**
@@ -2547,26 +2686,38 @@ 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_);
     manager.manage(regionObserver);
-
+    if (this.qualityObserver_) {
+      manager.manage(this.qualityObserver_);
+    }
     return manager;
   }
 
@@ -2682,6 +2833,26 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         mediaElement, closedCaptionsParser, textDisplayer, onMetadata);
   }
 
+  /**
+   * Create a new CMCD manager.
+   *
+   * @private
+   */
+  createCmcd_() {
+    /** @type {shaka.util.CmcdManager.PlayerInterface} */
+    const playerInterface = {
+      getBandwidthEstimate: () => this.abrManager_ ?
+        this.abrManager_.getBandwidthEstimate() : NaN,
+      getBufferedInfo: () => this.getBufferedInfo(),
+      getCurrentTime: () => this.video_ ? this.video_.currentTime : 0,
+      getVariantTracks: () => this.getVariantTracks(),
+      getPlaybackRate: () => this.getPlaybackRate(),
+      isLive: () => this.isLive(),
+    };
+
+    return new shaka.util.CmcdManager(playerInterface, this.config_.cmcd);
+  }
+
   /**
    * Creates a new instance of StreamingEngine.  This can be replaced by tests
    * to create fake instances instead.
@@ -2691,19 +2862,28 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
   createStreamingEngine() {
     goog.asserts.assert(
         this.playhead_ && this.abrManager_ && this.mediaSourceEngine_ &&
-        this.manifest_,
+        this.cmcdManager_ && this.manifest_,
         'Must not be destroyed');
 
     /** @type {shaka.media.StreamingEngine.PlayerInterface} */
     const playerInterface = {
       getPresentationTime: () => this.playhead_.getTime(),
       getBandwidthEstimate: () => this.abrManager_.getBandwidthEstimate(),
+      modifySegmentRequest: (request, segmentInfo) => {
+        this.cmcdManager_.applySegmentData(request, segmentInfo);
+      },
       mediaSourceEngine: this.mediaSourceEngine_,
       netEngine: this.networkingEngine_,
       onError: (error) => this.onError_(error),
       onEvent: (event) => this.dispatchEvent(event),
       onManifestUpdate: () => this.onManifestUpdate_(),
       onSegmentAppended: () => this.onSegmentAppended_(),
+      onInitSegmentAppended: (position, initSegment) => {
+        const mediaQuality = initSegment.getMediaQuality();
+        if (mediaQuality && this.qualityObserver_) {
+          this.qualityObserver_.addMediaQualityChange(mediaQuality, position);
+        }
+      },
     };
 
     return new shaka.media.StreamingEngine(this.manifest_, playerInterface);
@@ -3454,7 +3634,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       const height = fullImageHeight / rows;
       const totalImages = columns * rows;
       const segmentDuration = reference.trueEndTime - reference.startTime;
-      const thumbnailDuration = segmentDuration / totalImages;
+      const thumbnailDuration =
+          reference.getTileDuration() || (segmentDuration / totalImages);
       let thumbnailTime = reference.startTime;
       let positionX = 0;
       let positionY = 0;
@@ -3477,6 +3658,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         positionY = Math.floor(thumbnailPosition / columns) * height;
       }
       return {
+        imageHeight: fullImageHeight,
+        imageWidth: fullImageWidth,
         height: height,
         positionX: positionX,
         positionY: positionY,
@@ -3878,20 +4061,24 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const LanguageUtils = shaka.util.LanguageUtils;
     const inputlanguage = LanguageUtils.normalize(language);
     const chaptersTracks = this.getChaptersTracks_();
-    const chaptersTrack = chaptersTracks
-        .find((t) => LanguageUtils.normalize(t.language) == inputlanguage);
-    if (!chaptersTrack || !chaptersTrack.cues) {
+    const chaptersTracksWithLanguage = chaptersTracks
+        .filter((t) => LanguageUtils.normalize(t.language) == inputlanguage);
+    if (!chaptersTracksWithLanguage || !chaptersTracksWithLanguage.length) {
       return [];
     }
     const chapters = [];
-    for (const cue of chaptersTrack.cues) {
-      /** @type {shaka.extern.Chapter} */
-      const chapter = {
-        title: cue.text,
-        startTime: cue.startTime,
-        endTime: cue.endTime,
-      };
-      chapters.push(chapter);
+    for (const chaptersTrack of chaptersTracksWithLanguage) {
+      if (chaptersTrack && chaptersTrack.cues) {
+        for (const cue of chaptersTrack.cues) {
+          /** @type {shaka.extern.Chapter} */
+          const chapter = {
+            title: cue.text,
+            startTime: cue.startTime,
+            endTime: cue.endTime,
+          };
+          chapters.push(chapter);
+        }
+      }
     }
     return chapters;
   }
@@ -4267,7 +4454,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       }
       const trackElement =
         /** @type {!HTMLTrackElement} */(document.createElement('track'));
-      trackElement.src = uri;
+      trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
       trackElement.label = label || '';
       trackElement.kind = kind;
       trackElement.srclang = language;
@@ -4605,7 +4792,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
     const trackElement =
       /** @type {!HTMLTrackElement} */(document.createElement('track'));
-    trackElement.src = uri;
+    trackElement.src = this.cmcdManager_.appendTextTrackData(uri);
     trackElement.label = label;
     trackElement.kind = kind;
     trackElement.srclang = language;
@@ -4634,6 +4821,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
     request.method = 'GET';
 
+    this.cmcdManager_.applyTextData(request);
+
     const response = await netEngine.request(type, request).promise;
 
     return response.data;
@@ -5031,6 +5220,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (loaded) {
       this.playRateController_.setBuffering(isBuffering);
+      if (this.cmcdManager_) {
+        this.cmcdManager_.setBuffering(isBuffering);
+      }
       this.updateStateHistory_();
     }
 
@@ -5505,6 +5697,38 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.dispatchEvent(this.makeEvent_(eventName, data));
   }
 
+  /**
+   * When notified of a media quality change we need to emit a
+   * MediaQualityChange event to the app.
+   *
+   * @param {shaka.extern.MediaQualityInfo} mediaQuality
+   * @param {number} position
+   *
+   * @private
+   */
+  onMediaQualityChange_(mediaQuality, position) {
+    // Always make a copy to avoid exposing our internal data to the app.
+    const clone = {
+      bandwidth: mediaQuality.bandwidth,
+      audioSamplingRate: mediaQuality.audioSamplingRate,
+      codecs: mediaQuality.codecs,
+      contentType: mediaQuality.contentType,
+      frameRate: mediaQuality.frameRate,
+      height: mediaQuality.height,
+      mimeType: mediaQuality.mimeType,
+      channelsCount: mediaQuality.channelsCount,
+      pixelAspectRatio: mediaQuality.pixelAspectRatio,
+      width: mediaQuality.width,
+    };
+
+    const data = new Map()
+        .set('mediaQuality', clone)
+        .set('position', position);
+
+    this.dispatchEvent(this.makeEvent_(
+        shaka.Player.EventName.MediaQualityChanged, data));
+  }
+
   /**
    * Turn the media element's error object into a Shaka Player error object.
    *
@@ -6268,6 +6492,8 @@ shaka.Player.EventName = {
   AbrStatusChanged: 'abrstatuschanged',
   Adaptation: 'adaptation',
   Buffering: 'buffering',
+  DownloadFailed: 'downloadfailed',
+  DownloadHeadersReceived: 'downloadheadersreceived',
   DrmSessionUpdate: 'drmsessionupdate',
   Emsg: 'emsg',
   Error: 'error',
@@ -6276,6 +6502,7 @@ shaka.Player.EventName = {
   Loaded: 'loaded',
   Loading: 'loading',
   ManifestParsed: 'manifestparsed',
+  MediaQualityChanged: 'mediaqualitychanged',
   Metadata: 'metadata',
   OnStateChange: 'onstatechange',
   OnStateIdle: 'onstateidle',
@@ -6331,7 +6558,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v3.2.2-uncompiled';
+shaka.Player.version = 'v3.3.2-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/media_capabilities.js

@@ -24,8 +24,6 @@ shaka.polyfill.MediaCapabilities = class {
    * @export
    */
   static install() {
-    shaka.log.debug('MediaCapabilities: install');
-
     // Since MediaCapabilities is not fully supported on Chromecast yet, we
     // should always install polyfill for Chromecast.
     // TODO: re-evaluate MediaCapabilities in the future versions of Chromecast.
@@ -40,21 +38,28 @@ shaka.polyfill.MediaCapabilities = class {
     // TODO: re-evaluate MediaCapabilities in the future versions of PS5
     // Browsers.
     if (!shaka.util.Platform.isChromecast() &&
-      !shaka.util.Platform.isApple() &&
-      !shaka.util.Platform.isPS5() &&
-      navigator.mediaCapabilities) {
-      shaka.log.debug(
+        !shaka.util.Platform.isApple() &&
+        !shaka.util.Platform.isPS5() &&
+        navigator.mediaCapabilities) {
+      shaka.log.info(
           'MediaCapabilities: Native mediaCapabilities support found.');
-    } else {
-      if (!navigator.mediaCapabilities) {
-        navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
-      }
-      navigator.mediaCapabilities.decodingInfo =
-          shaka.polyfill.MediaCapabilities.decodingInfo_;
+      return;
+    }
+
+    shaka.log.info('MediaCapabilities: install');
+
+    if (!navigator.mediaCapabilities) {
+      navigator.mediaCapabilities = /** @type {!MediaCapabilities} */ ({});
     }
-    // Workaround because in Apple browsers there is no way to overwrite
-    // MediaCapabilities.
-    window.shakaMediaCapabilities = navigator.mediaCapabilities;
+
+    // Keep the patched MediaCapabilities object from being garbage-collected in
+    // Safari.
+    // See https://github.com/google/shaka-player/issues/3696#issuecomment-1009472718
+    shaka.polyfill.MediaCapabilities.originalMcap =
+        navigator.mediaCapabilities;
+
+    navigator.mediaCapabilities.decodingInfo =
+        shaka.polyfill.MediaCapabilities.decodingInfo_;
   }
 
   /**
@@ -182,6 +187,16 @@ shaka.polyfill.MediaCapabilities = class {
   }
 };
 
+/**
+ * A copy of the MediaCapabilities instance, to prevent Safari from
+ * garbage-collecting the polyfilled method on it.  We make it public and export
+ * it to ensure that it is not stripped out by the compiler.
+ *
+ * @type {MediaCapabilities}
+ * @export
+ */
+shaka.polyfill.MediaCapabilities.originalMcap = null;
+
 // Install at a lower priority than MediaSource polyfill, so that we have
 // MediaSource available first.
 shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);

package/lib/polyfill/random_uuid.js

@@ -0,0 +1,52 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+goog.provide('shaka.polyfill.RandomUUID');
+
+goog.require('shaka.log');
+goog.require('shaka.polyfill');
+
+/**
+ * @summary A polyfill to provide window.crypto.randomUUID in all browsers.
+ * @export
+ */
+shaka.polyfill.RandomUUID = class {
+  /**
+   * Install the polyfill if needed.
+   * @export
+   */
+  static install() {
+    shaka.log.debug('randomUUID.install');
+
+    if (!window.crypto) {
+      // See: https://caniuse.com/cryptography
+      shaka.log.debug(
+          'window.crypto must be available to install randomUUID polyfill.');
+      return;
+    }
+
+    if ('randomUUID' in window.crypto) {
+      shaka.log.debug(
+          'RandomUUID: Native window.crypto.randomUUID() support found.');
+      return;
+    }
+
+    window.crypto.randomUUID = shaka.polyfill.RandomUUID.randomUUID_;
+  }
+
+  /**
+   * @return {string}
+   * @private
+   */
+  static randomUUID_() {
+    const url = URL.createObjectURL(new Blob());
+    const uuid = url.toString();
+    URL.revokeObjectURL(url);
+    return uuid.substr(uuid.lastIndexOf('/') + 1);
+  }
+};
+
+
+shaka.polyfill.register(shaka.polyfill.RandomUUID.install);

package/lib/text/cue.js

@@ -144,6 +144,18 @@ shaka.text.Cue = class {
      */
     this.border = '';
 
+    /**
+     * @override
+     * @exportInterface
+     */
+    this.textStrokeColor = '';
+
+    /**
+     * @override
+     * @exportInterface
+     */
+    this.textStrokeWidth = '';
+
     /**
      * @override
      * @exportInterface
@@ -210,6 +222,12 @@ shaka.text.Cue = class {
      */
     this.nestedCues = [];
 
+    /**
+     * @override
+     * @exportInterface
+     */
+    this.isContainer = false;
+
     /**
      * @override
      * @exportInterface