shaka-player 4.7.13 → 4.8.0

package/lib/dash/dash_parser.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.dash.DashParser');
 
 goog.require('goog.asserts');
+goog.require('shaka.Deprecate');
 goog.require('shaka.abr.Ewma');
 goog.require('shaka.dash.ContentProtection');
 goog.require('shaka.dash.MpdUtils');
@@ -31,6 +32,7 @@ goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.PeriodCombiner');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.util.Timer');
+goog.require('shaka.util.TXml');
 goog.require('shaka.util.XmlUtils');
 
 
@@ -129,9 +131,14 @@ shaka.dash.DashParser = class {
   configure(config) {
     goog.asserts.assert(config.dash != null,
         'DashManifestConfiguration should not be null!');
-
+    const needFireUpdate = this.playerInterface_ &&
+      config.dash.updatePeriod != this.config_.dash.updatePeriod &&
+      config.dash.updatePeriod >= 0;
     this.config_ = config;
-
+    if (needFireUpdate && this.manifest_ &&
+      this.manifest_.presentationTimeline.isLive()) {
+      this.updateNow_();
+    }
     if (this.contentSteeringManager_) {
       this.contentSteeringManager_.configure(this.config_);
     }
@@ -140,6 +147,8 @@ shaka.dash.DashParser = class {
       this.periodCombiner_.setAllowMultiTypeVariants(
           this.config_.dash.multiTypeVariantsAllowed &&
           shaka.media.Capabilities.isChangeTypeSupported());
+      this.periodCombiner_.setUseStreamOnce(
+          this.config_.dash.useStreamOnceInPeriodFlattening);
     }
   }
 
@@ -327,15 +336,38 @@ shaka.dash.DashParser = class {
    * @private
    */
   async parseManifest_(data, finalManifestUri) {
-    const Error = shaka.util.Error;
-    const MpdUtils = shaka.dash.MpdUtils;
-
-    const mpd = shaka.util.XmlUtils.parseXml(data, 'MPD');
+    let manifestData = data;
+    const manifestPreprocessor = this.config_.dash.manifestPreprocessor;
+    if (manifestPreprocessor) {
+      shaka.Deprecate.deprecateFeature(5,
+          'manifest.dash.manifestPreprocessor configuration',
+          'Please Use manifest.dash.manifestPreprocessorTXml instead.');
+      const mpdElement =
+          shaka.util.XmlUtils.parseXml(manifestData, 'MPD');
+      if (!mpdElement) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.DASH_INVALID_XML,
+            finalManifestUri);
+      }
+      manifestPreprocessor(mpdElement);
+      manifestData = shaka.util.XmlUtils.toArrayBuffer(mpdElement);
+    }
+    const mpd = shaka.util.TXml.parseXml(manifestData, 'MPD');
     if (!mpd) {
-      throw new Error(
-          Error.Severity.CRITICAL, Error.Category.MANIFEST,
-          Error.Code.DASH_INVALID_XML, finalManifestUri);
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.DASH_INVALID_XML,
+          finalManifestUri);
     }
+    const manifestPreprocessorTXml =
+        this.config_.dash.manifestPreprocessorTXml;
+    if (manifestPreprocessorTXml) {
+      manifestPreprocessorTXml(mpd);
+    }
+
     const disableXlinkProcessing = this.config_.dash.disableXlinkProcessing;
     if (disableXlinkProcessing) {
       return this.processManifest_(mpd, finalManifestUri);
@@ -343,7 +375,7 @@ shaka.dash.DashParser = class {
 
     // Process the mpd to account for xlink connections.
     const failGracefully = this.config_.dash.xlinkFailGracefully;
-    const xlinkOperation = MpdUtils.processXlinks(
+    const xlinkOperation = shaka.dash.MpdUtils.processXlinks(
         mpd, this.config_.retryParameters, failGracefully, finalManifestUri,
         this.playerInterface_.networkingEngine);
     this.operationManager_.manage(xlinkOperation);
@@ -355,19 +387,17 @@ shaka.dash.DashParser = class {
   /**
    * Takes a formatted MPD and converts it into a manifest.
    *
-   * @param {!Element} mpd
+   * @param {!shaka.extern.xml.Node} mpd
    * @param {string} finalManifestUri The final manifest URI, which may
    *   differ from this.manifestUri_ if there has been a redirect.
    * @return {!Promise}
    * @private
    */
   async processManifest_(mpd, finalManifestUri) {
-    const XmlUtils = shaka.util.XmlUtils;
+    const TXml = shaka.util.TXml;
 
-    const manifestPreprocessor = this.config_.dash.manifestPreprocessor;
-    if (manifestPreprocessor) {
-      manifestPreprocessor(mpd);
-    }
+    goog.asserts.assert(this.config_,
+        'Must call configure() before processManifest_()!');
 
     if (this.contentSteeringManager_) {
       this.contentSteeringManager_.clearPreviousLocations();
@@ -381,10 +411,10 @@ shaka.dash.DashParser = class {
     const locations = [];
     /** @type {!Map.<string, string>} */
     const locationsMapping = new Map();
-    const locationsObjs = XmlUtils.findChildren(mpd, 'Location');
+    const locationsObjs = TXml.findChildren(mpd, 'Location');
     for (const locationsObj of locationsObjs) {
-      const serviceLocation = locationsObj.getAttribute('serviceLocation');
-      const uri = XmlUtils.getContents(locationsObj);
+      const serviceLocation = locationsObj.attributes['serviceLocation'];
+      const uri = TXml.getContents(locationsObj);
       if (!uri) {
         continue;
       }
@@ -414,10 +444,10 @@ shaka.dash.DashParser = class {
 
     let contentSteeringPromise = Promise.resolve();
 
-    const contentSteering = XmlUtils.findChild(mpd, 'ContentSteering');
+    const contentSteering = TXml.findChild(mpd, 'ContentSteering');
     if (contentSteering && this.playerInterface_) {
       const defaultPathwayId =
-          contentSteering.getAttribute('defaultServiceLocation');
+          contentSteering.attributes['defaultServiceLocation'];
       if (!this.contentSteeringManager_) {
         this.contentSteeringManager_ =
             new shaka.util.ContentSteeringManager(this.playerInterface_);
@@ -426,11 +456,11 @@ shaka.dash.DashParser = class {
             shaka.media.ManifestParser.DASH);
         this.contentSteeringManager_.setBaseUris(manifestBaseUris);
         this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
-        const uri = XmlUtils.getContents(contentSteering);
+        const uri = TXml.getContents(contentSteering);
         if (uri) {
           const queryBeforeStart =
-            XmlUtils.parseAttr(contentSteering, 'queryBeforeStart',
-                XmlUtils.parseBoolean, /* defaultValue= */ false);
+            TXml.parseAttr(contentSteering, 'queryBeforeStart',
+                TXml.parseBoolean, /* defaultValue= */ false);
           if (queryBeforeStart) {
             contentSteeringPromise =
                 this.contentSteeringManager_.requestInfo(uri);
@@ -449,13 +479,13 @@ shaka.dash.DashParser = class {
       }
     }
 
-    const uriObjs = XmlUtils.findChildren(mpd, 'BaseURL');
+    const uriObjs = TXml.findChildren(mpd, 'BaseURL');
     let calculatedBaseUris;
     let someLocationValid = false;
     if (this.contentSteeringManager_) {
       for (const uriObj of uriObjs) {
-        const serviceLocation = uriObj.getAttribute('serviceLocation');
-        const uri = XmlUtils.getContents(uriObj);
+        const serviceLocation = uriObj.attributes['serviceLocation'];
+        const uri = TXml.getContents(uriObj);
         if (serviceLocation && uri) {
           this.contentSteeringManager_.addLocation(
               'BaseURL', serviceLocation, uri);
@@ -464,7 +494,7 @@ shaka.dash.DashParser = class {
       }
     }
     if (!someLocationValid || !this.contentSteeringManager_) {
-      const uris = uriObjs.map(XmlUtils.getContents);
+      const uris = uriObjs.map(TXml.getContents);
       calculatedBaseUris = shaka.util.ManifestParserUtils.resolveUris(
           manifestBaseUris, uris);
     }
@@ -481,41 +511,41 @@ shaka.dash.DashParser = class {
 
     let availabilityTimeOffset = 0;
     if (uriObjs && uriObjs.length) {
-      availabilityTimeOffset = XmlUtils.parseAttr(
-          uriObjs[0], 'availabilityTimeOffset', XmlUtils.parseFloat) || 0;
+      availabilityTimeOffset = TXml.parseAttr(uriObjs[0],
+          'availabilityTimeOffset', TXml.parseFloat) || 0;
     }
 
     const ignoreMinBufferTime = this.config_.dash.ignoreMinBufferTime;
     let minBufferTime = 0;
     if (!ignoreMinBufferTime) {
       minBufferTime =
-          XmlUtils.parseAttr(mpd, 'minBufferTime', XmlUtils.parseDuration) || 0;
+          TXml.parseAttr(mpd, 'minBufferTime', TXml.parseDuration) || 0;
     }
 
-    this.updatePeriod_ = /** @type {number} */ (XmlUtils.parseAttr(
-        mpd, 'minimumUpdatePeriod', XmlUtils.parseDuration, -1));
+    this.updatePeriod_ = /** @type {number} */ (TXml.parseAttr(
+        mpd, 'minimumUpdatePeriod', TXml.parseDuration, -1));
 
-    const presentationStartTime = XmlUtils.parseAttr(
-        mpd, 'availabilityStartTime', XmlUtils.parseDate);
-    let segmentAvailabilityDuration = XmlUtils.parseAttr(
-        mpd, 'timeShiftBufferDepth', XmlUtils.parseDuration);
+    const presentationStartTime = TXml.parseAttr(
+        mpd, 'availabilityStartTime', TXml.parseDate);
+    let segmentAvailabilityDuration = TXml.parseAttr(
+        mpd, 'timeShiftBufferDepth', TXml.parseDuration);
 
     const ignoreSuggestedPresentationDelay =
       this.config_.dash.ignoreSuggestedPresentationDelay;
     let suggestedPresentationDelay = null;
     if (!ignoreSuggestedPresentationDelay) {
-      suggestedPresentationDelay = XmlUtils.parseAttr(
-          mpd, 'suggestedPresentationDelay', XmlUtils.parseDuration);
+      suggestedPresentationDelay = TXml.parseAttr(
+          mpd, 'suggestedPresentationDelay', TXml.parseDuration);
     }
 
     const ignoreMaxSegmentDuration =
         this.config_.dash.ignoreMaxSegmentDuration;
     let maxSegmentDuration = null;
     if (!ignoreMaxSegmentDuration) {
-      maxSegmentDuration = XmlUtils.parseAttr(
-          mpd, 'maxSegmentDuration', XmlUtils.parseDuration);
+      maxSegmentDuration = TXml.parseAttr(
+          mpd, 'maxSegmentDuration', TXml.parseDuration);
     }
-    const mpdType = mpd.getAttribute('type') || 'static';
+    const mpdType = mpd.attributes['type'] || 'static';
 
     /** @type {!shaka.media.PresentationTimeline} */
     let presentationTimeline;
@@ -575,7 +605,7 @@ shaka.dash.DashParser = class {
     presentationTimeline.setSegmentAvailabilityDuration(
         segmentAvailabilityDuration);
 
-    const profiles = mpd.getAttribute('profiles') || '';
+    const profiles = mpd.attributes['profiles'] || '';
 
     /** @type {shaka.dash.DashParser.Context} */
     const context = {
@@ -666,8 +696,8 @@ shaka.dash.DashParser = class {
       // We only need to do clock sync when we're using presentation start
       // time. This condition also excludes VOD streams.
       if (presentationTimeline.usingPresentationStartTime()) {
-        const XmlUtils = shaka.util.XmlUtils;
-        const timingElements = XmlUtils.findChildren(mpd, 'UTCTiming');
+        const TXml = shaka.util.TXml;
+        const timingElements = TXml.findChildren(mpd, 'UTCTiming');
         const offset = await this.parseUtcTiming_(getBaseUris, timingElements);
         // Detect calls to stop().
         if (!this.playerInterface_) {
@@ -706,33 +736,33 @@ shaka.dash.DashParser = class {
    * Reads maxLatency and maxPlaybackRate properties from service
    * description element.
    *
-   * @param {!Element} mpd
+   * @param {!shaka.extern.xml.Node} mpd
    * @return {?shaka.extern.ServiceDescription}
    * @private
    */
   parseServiceDescription_(mpd) {
-    const XmlUtils = shaka.util.XmlUtils;
-    const elem = XmlUtils.findChild(mpd, 'ServiceDescription');
+    const TXml = shaka.util.TXml;
+    const elem = TXml.findChild(mpd, 'ServiceDescription');
 
     if (!elem ) {
       return null;
     }
 
-    const latencyNode = XmlUtils.findChild(elem, 'Latency');
-    const playbackRateNode = XmlUtils.findChild(elem, 'PlaybackRate');
+    const latencyNode = TXml.findChild(elem, 'Latency');
+    const playbackRateNode = TXml.findChild(elem, 'PlaybackRate');
 
-    if ((latencyNode && latencyNode.getAttribute('max')) || playbackRateNode) {
-      const maxLatency = latencyNode && latencyNode.getAttribute('max') ?
-        parseInt(latencyNode.getAttribute('max'), 10) / 1000 :
+    if ((latencyNode && latencyNode.attributes['max']) || playbackRateNode) {
+      const maxLatency = latencyNode && latencyNode.attributes['max'] ?
+        parseInt(latencyNode.attributes['max'], 10) / 1000 :
         null;
       const maxPlaybackRate = playbackRateNode ?
-        parseFloat(playbackRateNode.getAttribute('max')) :
+        parseFloat(playbackRateNode.attributes['max']) :
         null;
-      const minLatency = latencyNode && latencyNode.getAttribute('min') ?
-        parseInt(latencyNode.getAttribute('min'), 10) / 1000 :
+      const minLatency = latencyNode && latencyNode.attributes['min'] ?
+        parseInt(latencyNode.attributes['min'], 10) / 1000 :
         null;
       const minPlaybackRate = playbackRateNode ?
-        parseFloat(playbackRateNode.getAttribute('min')) :
+        parseFloat(playbackRateNode.attributes['min']) :
         null;
 
       return {
@@ -753,7 +783,7 @@ shaka.dash.DashParser = class {
    *
    * @param {shaka.dash.DashParser.Context} context
    * @param {function():!Array.<string>} getBaseUris
-   * @param {!Element} mpd
+   * @param {!shaka.extern.xml.Node} mpd
    * @return {{
    *   periods: !Array.<shaka.extern.Period>,
    *   duration: ?number,
@@ -762,21 +792,21 @@ shaka.dash.DashParser = class {
    * @private
    */
   parsePeriods_(context, getBaseUris, mpd) {
-    const XmlUtils = shaka.util.XmlUtils;
-    const presentationDuration = XmlUtils.parseAttr(
-        mpd, 'mediaPresentationDuration', XmlUtils.parseDuration);
+    const TXml = shaka.util.TXml;
+    const presentationDuration = TXml.parseAttr(
+        mpd, 'mediaPresentationDuration', TXml.parseDuration);
 
     const periods = [];
     let prevEnd = 0;
-    const periodNodes = XmlUtils.findChildren(mpd, 'Period');
+    const periodNodes = TXml.findChildren(mpd, 'Period');
     for (let i = 0; i < periodNodes.length; i++) {
       const elem = periodNodes[i];
       const next = periodNodes[i + 1];
       const start = /** @type {number} */ (
-        XmlUtils.parseAttr(elem, 'start', XmlUtils.parseDuration, prevEnd));
-      const periodId = elem.id;
+        TXml.parseAttr(elem, 'start', TXml.parseDuration, prevEnd));
+      const periodId = elem.attributes['id'];
       const givenDuration =
-          XmlUtils.parseAttr(elem, 'duration', XmlUtils.parseDuration);
+          TXml.parseAttr(elem, 'duration', TXml.parseDuration);
 
       let periodDuration = null;
       if (next) {
@@ -784,7 +814,7 @@ shaka.dash.DashParser = class {
         // of the following Period is the duration of the media content
         // represented by this Period."
         const nextStart =
-            XmlUtils.parseAttr(next, 'start', XmlUtils.parseDuration);
+            TXml.parseAttr(next, 'start', TXml.parseDuration);
         if (nextStart != null) {
           periodDuration = nextStart - start;
         }
@@ -912,7 +942,7 @@ shaka.dash.DashParser = class {
    */
   parsePeriod_(context, getBaseUris, periodInfo) {
     const Functional = shaka.util.Functional;
-    const XmlUtils = shaka.util.XmlUtils;
+    const TXml = shaka.util.TXml;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     context.period = this.createFrame_(periodInfo.node, null, getBaseUris);
@@ -928,7 +958,7 @@ shaka.dash.DashParser = class {
     }
 
     const eventStreamNodes =
-        XmlUtils.findChildren(periodInfo.node, 'EventStream');
+        TXml.findChildren(periodInfo.node, 'EventStream');
     const availabilityStart =
         context.presentationTimeline.getSegmentAvailabilityStart();
 
@@ -938,7 +968,7 @@ shaka.dash.DashParser = class {
     }
 
     const adaptationSetNodes =
-        XmlUtils.findChildren(periodInfo.node, 'AdaptationSet');
+        TXml.findChildren(periodInfo.node, 'AdaptationSet');
     const adaptationSets = adaptationSetNodes
         .map((node) => this.parseAdaptationSet_(context, node))
         .filter(Functional.isNotNull);
@@ -1047,12 +1077,12 @@ shaka.dash.DashParser = class {
    * Parses an AdaptationSet XML element.
    *
    * @param {shaka.dash.DashParser.Context} context
-   * @param {!Element} elem The AdaptationSet element.
+   * @param {!shaka.extern.xml.Node} elem The AdaptationSet element.
    * @return {?shaka.dash.DashParser.AdaptationInfo}
    * @private
    */
   parseAdaptationSet_(context, elem) {
-    const XmlUtils = shaka.util.XmlUtils;
+    const TXml = shaka.util.TXml;
     const Functional = shaka.util.Functional;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const ContentType = ManifestParserUtils.ContentType;
@@ -1061,9 +1091,9 @@ shaka.dash.DashParser = class {
     context.adaptationSet = this.createFrame_(elem, context.period, null);
 
     let main = false;
-    const roleElements = XmlUtils.findChildren(elem, 'Role');
+    const roleElements = TXml.findChildren(elem, 'Role');
     const roleValues = roleElements.map((role) => {
-      return role.getAttribute('value');
+      return role.attributes['value'];
     }).filter(Functional.isNotNull);
 
     // Default kind for text streams is 'subtitle' if unspecified in the
@@ -1075,12 +1105,12 @@ shaka.dash.DashParser = class {
     }
 
     for (const roleElement of roleElements) {
-      const scheme = roleElement.getAttribute('schemeIdUri');
+      const scheme = roleElement.attributes['schemeIdUri'];
       if (scheme == null || scheme == 'urn:mpeg:dash:role:2011') {
         // These only apply for the given scheme, but allow them to be specified
         // if there is no scheme specified.
         // See: DASH section 5.8.5.5
-        const value = roleElement.getAttribute('value');
+        const value = roleElement.attributes['value'];
         switch (value) {
           case 'main':
             main = true;
@@ -1125,18 +1155,18 @@ shaka.dash.DashParser = class {
     };
 
     const essentialProperties =
-        XmlUtils.findChildren(elem, 'EssentialProperty');
+        TXml.findChildren(elem, 'EssentialProperty');
     // ID of real AdaptationSet if this is a trick mode set:
     let trickModeFor = null;
     let isFastSwitching = false;
     let unrecognizedEssentialProperty = false;
     for (const prop of essentialProperties) {
-      const schemeId = prop.getAttribute('schemeIdUri');
+      const schemeId = prop.attributes['schemeIdUri'];
       if (schemeId == 'http://dashif.org/guidelines/trickmode') {
-        trickModeFor = prop.getAttribute('value');
+        trickModeFor = prop.attributes['value'];
       } else if (schemeId == transferCharacteristicsScheme) {
         videoRange = getVideoRangeFromTransferCharacteristicCICP(
-            parseInt(prop.getAttribute('value'), 10),
+            parseInt(prop.attributes['value'], 10),
         );
       } else if (schemeId == colourPrimariesScheme ||
                  schemeId == matrixCoefficientsScheme) {
@@ -1148,25 +1178,29 @@ shaka.dash.DashParser = class {
       }
     }
 
+    let lastSegmentNumber = null;
+
     const supplementalProperties =
-        XmlUtils.findChildren(elem, 'SupplementalProperty');
+        TXml.findChildren(elem, 'SupplementalProperty');
     for (const prop of supplementalProperties) {
-      const schemeId = prop.getAttribute('schemeIdUri');
-      if (schemeId == transferCharacteristicsScheme) {
+      const schemeId = prop.attributes['schemeIdUri'];
+      if (schemeId == 'http://dashif.org/guidelines/last-segment-number') {
+        lastSegmentNumber = parseInt(prop.attributes['value'], 10) - 1;
+      } else if (schemeId == transferCharacteristicsScheme) {
         videoRange = getVideoRangeFromTransferCharacteristicCICP(
-            parseInt(prop.getAttribute('value'), 10),
+            parseInt(prop.attributes['value'], 10),
         );
       }
     }
 
-    const accessibilities = XmlUtils.findChildren(elem, 'Accessibility');
+    const accessibilities = TXml.findChildren(elem, 'Accessibility');
     const LanguageUtils = shaka.util.LanguageUtils;
     const closedCaptions = new Map();
     /** @type {?shaka.media.ManifestParser.AccessibilityPurpose} */
     let accessibilityPurpose;
     for (const prop of accessibilities) {
-      const schemeId = prop.getAttribute('schemeIdUri');
-      const value = prop.getAttribute('value');
+      const schemeId = prop.attributes['schemeIdUri'];
+      const value = prop.attributes['value'];
       if (schemeId == 'urn:scte:dash:cc:cea-608:2015' ) {
         let channelId = 1;
         if (value != null) {
@@ -1270,7 +1304,7 @@ shaka.dash.DashParser = class {
     }
 
     const contentProtectionElems =
-        XmlUtils.findChildren(elem, 'ContentProtection');
+        TXml.findChildren(elem, 'ContentProtection');
     const contentProtection = ContentProtection.parseFromAdaptationSet(
         contentProtectionElems,
         this.config_.dash.ignoreDrmInfo,
@@ -1280,24 +1314,26 @@ shaka.dash.DashParser = class {
         context.adaptationSet.language || 'und');
 
     // This attribute is currently non-standard, but it is supported by Kaltura.
-    let label = elem.getAttribute('label');
+    let label = elem.attributes['label'];
 
     // See DASH IOP 4.3 here https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf (page 35)
-    const labelElements = XmlUtils.findChildren(elem, 'Label');
+    const labelElements = TXml.findChildren(elem, 'Label');
     if (labelElements && labelElements.length) {
       // NOTE: Right now only one label field is supported.
       const firstLabelElement = labelElements[0];
-      if (firstLabelElement.textContent) {
-        label = firstLabelElement.textContent;
+      const textContent = shaka.util.TXml.getTextContents(firstLabelElement);
+      if (textContent) {
+        label = textContent;
       }
     }
 
     // Parse Representations into Streams.
-    const representations = XmlUtils.findChildren(elem, 'Representation');
+    const representations = TXml.findChildren(elem, 'Representation');
     const streams = representations.map((representation) => {
       const parsedRepresentation = this.parseRepresentation_(context,
           contentProtection, kind, language, label, main, roleValues,
-          closedCaptions, representation, accessibilityPurpose);
+          closedCaptions, representation, accessibilityPurpose,
+          lastSegmentNumber);
       if (parsedRepresentation) {
         parsedRepresentation.hdr = parsedRepresentation.hdr || videoRange;
         parsedRepresentation.fastSwitching = isFastSwitching;
@@ -1353,7 +1389,7 @@ shaka.dash.DashParser = class {
     }
 
     const repIds = representations
-        .map((node) => { return node.getAttribute('id'); })
+        .map((node) => { return node.attributes['id']; })
         .filter(shaka.util.Functional.isNotNull);
 
     return {
@@ -1379,17 +1415,19 @@ shaka.dash.DashParser = class {
    * @param {boolean} isPrimary
    * @param {!Array.<string>} roles
    * @param {Map.<string, string>} closedCaptions
-   * @param {!Element} node
+   * @param {!shaka.extern.xml.Node} node
    * @param {?shaka.media.ManifestParser.AccessibilityPurpose}
    *   accessibilityPurpose
+   * @param {?number} lastSegmentNumber
    *
    * @return {?shaka.extern.Stream} The Stream, or null when there is a
    *   non-critical parsing error.
    * @private
    */
   parseRepresentation_(context, contentProtection, kind, language, label,
-      isPrimary, roles, closedCaptions, node, accessibilityPurpose) {
-    const XmlUtils = shaka.util.XmlUtils;
+      isPrimary, roles, closedCaptions, node, accessibilityPurpose,
+      lastSegmentNumber) {
+    const TXml = shaka.util.TXml;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     context.representation =
@@ -1411,7 +1449,7 @@ shaka.dash.DashParser = class {
     // To avoid NaN at the variant level on broken content, fall back to zero.
     // https://github.com/shaka-project/shaka-player/issues/938#issuecomment-317278180
     context.bandwidth =
-        XmlUtils.parseAttr(node, 'bandwidth', XmlUtils.parsePositiveInt) || 0;
+        TXml.parseAttr(node, 'bandwidth', TXml.parsePositiveInt) || 0;
 
     /** @type {?shaka.dash.DashParser.StreamInfo} */
     let streamInfo;
@@ -1422,8 +1460,8 @@ shaka.dash.DashParser = class {
     const isImage = contentType == ContentType.IMAGE;
 
     try {
-      /** @type {shaka.extern.aes128Key|undefined} */
-      let aes128Key = undefined;
+      /** @type {shaka.extern.aesKey|undefined} */
+      let aesKey = undefined;
       if (contentProtection.aes128Info) {
         const getBaseUris = context.representation.getBaseUris;
         const uris = shaka.util.ManifestParserUtils.resolveUris(
@@ -1432,15 +1470,16 @@ shaka.dash.DashParser = class {
         const request = shaka.net.NetworkingEngine.makeRequest(
             uris, this.config_.retryParameters);
 
-        aes128Key = {
-          method: 'AES-128',
+        aesKey = {
+          bitsKey: 128,
+          blockCipherMode: 'CBC',
           iv: contentProtection.aes128Info.iv,
           firstMediaSequenceNumber: 0,
         };
 
         // Don't download the key object until the segment is parsed, to
         // avoid a startup delay for long manifests with lots of keys.
-        aes128Key.fetchKey = async () => {
+        aesKey.fetchKey = async () => {
           const keyResponse =
               await this.makeNetworkRequest_(request, requestType);
 
@@ -1456,9 +1495,9 @@ shaka.dash.DashParser = class {
           const algorithm = {
             name: 'AES-CBC',
           };
-          aes128Key.cryptoKey = await window.crypto.subtle.importKey(
+          aesKey.cryptoKey = await window.crypto.subtle.importKey(
               'raw', keyResponse.data, algorithm, true, ['decrypt']);
-          aes128Key.fetchKey = undefined; // No longer needed.
+          aesKey.fetchKey = undefined; // No longer needed.
         };
       }
       const requestSegment = (uris, startByte, endByte, isInit) => {
@@ -1466,17 +1505,17 @@ shaka.dash.DashParser = class {
       };
       if (context.representation.segmentBase) {
         streamInfo = shaka.dash.SegmentBase.createStreamInfo(
-            context, requestSegment, aes128Key);
+            context, requestSegment, aesKey);
       } else if (context.representation.segmentList) {
         streamInfo = shaka.dash.SegmentList.createStreamInfo(
-            context, this.streamMap_, aes128Key);
+            context, this.streamMap_, aesKey);
       } else if (context.representation.segmentTemplate) {
         const hasManifest = !!this.manifest_;
 
         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
             context, requestSegment, this.streamMap_, hasManifest,
             this.config_.dash.initialSegmentLimit, this.periodDurations_,
-            aes128Key);
+            aesKey, lastSegmentNumber);
       } else {
         goog.asserts.assert(isText,
             'Must have Segment* with non-text streams.');
@@ -1508,7 +1547,7 @@ shaka.dash.DashParser = class {
     }
 
     const contentProtectionElems =
-        XmlUtils.findChildren(node, 'ContentProtection');
+        TXml.findChildren(node, 'ContentProtection');
     const keyId = shaka.dash.ContentProtection.parseFromRepresentation(
         contentProtectionElems, contentProtection,
         this.config_.dash.ignoreDrmInfo,
@@ -1518,12 +1557,12 @@ shaka.dash.DashParser = class {
     // Detect the presence of E-AC3 JOC audio content, using DD+JOC signaling.
     // See: ETSI TS 103 420 V1.2.1 (2018-10)
     const supplementalPropertyElems =
-        XmlUtils.findChildren(node, 'SupplementalProperty');
+        TXml.findChildren(node, 'SupplementalProperty');
     const hasJoc = supplementalPropertyElems.some((element) => {
       const expectedUri = 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018';
       const expectedValue = 'JOC';
-      return element.getAttribute('schemeIdUri') == expectedUri &&
-          element.getAttribute('value') == expectedValue;
+      return element.attributes['schemeIdUri'] == expectedUri &&
+          element.attributes['value'] == expectedValue;
     });
     let spatialAudio = false;
     if (hasJoc) {
@@ -1541,16 +1580,16 @@ shaka.dash.DashParser = class {
     let tilesLayout;
     if (isImage) {
       const essentialPropertyElems =
-          XmlUtils.findChildren(node, 'EssentialProperty');
+          TXml.findChildren(node, 'EssentialProperty');
       const thumbnailTileElem = essentialPropertyElems.find((element) => {
         const expectedUris = [
           'http://dashif.org/thumbnail_tile',
           'http://dashif.org/guidelines/thumbnail_tile',
         ];
-        return expectedUris.includes(element.getAttribute('schemeIdUri'));
+        return expectedUris.includes(element.attributes['schemeIdUri']);
       });
       if (thumbnailTileElem) {
-        tilesLayout = thumbnailTileElem.getAttribute('value');
+        tilesLayout = thumbnailTileElem.attributes['value'];
       }
       // Filter image adaptation sets that has no tilesLayout.
       if (!tilesLayout) {
@@ -1682,6 +1721,15 @@ shaka.dash.DashParser = class {
     this.setUpdateTimer_(updateDelay);
   }
 
+  /**
+   * Update now the manifest
+   *
+   * @private
+   */
+  updateNow_() {
+    this.updateTimer_.tickNow();
+  }
+
   /**
    * Sets the update timer.  Does nothing if the manifest does not specify an
    * update period.
@@ -1698,9 +1746,13 @@ shaka.dash.DashParser = class {
     if (this.updatePeriod_ < 0) {
       return;
     }
+    let updateTime = this.updatePeriod_;
+    if (this.config_.dash.updatePeriod >= 0) {
+      updateTime = this.config_.dash.updatePeriod;
+    }
 
     const finalDelay = Math.max(
-        this.updatePeriod_ - offset,
+        updateTime - offset,
         this.averageUpdateDuration_.getEstimate());
 
     // We do not run the timer as repeating because part of update is async and
@@ -1711,7 +1763,7 @@ shaka.dash.DashParser = class {
   /**
    * Creates a new inheritance frame for the given element.
    *
-   * @param {!Element} elem
+   * @param {!shaka.extern.xml.Node} elem
    * @param {?shaka.dash.DashParser.InheritanceFrame} parent
    * @param {?function():!Array.<string>} getBaseUris
    * @return {shaka.dash.DashParser.InheritanceFrame}
@@ -1721,7 +1773,7 @@ shaka.dash.DashParser = class {
     goog.asserts.assert(parent || getBaseUris,
         'Must provide either parent or getBaseUris');
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
-    const XmlUtils = shaka.util.XmlUtils;
+    const TXml = shaka.util.TXml;
     parent = parent || /** @type {shaka.dash.DashParser.InheritanceFrame} */ ({
       contentType: '',
       mimeType: '',
@@ -1736,17 +1788,17 @@ shaka.dash.DashParser = class {
     });
     getBaseUris = getBaseUris || parent.getBaseUris;
 
-    const parseNumber = XmlUtils.parseNonNegativeInt;
-    const evalDivision = XmlUtils.evalDivision;
+    const parseNumber = TXml.parseNonNegativeInt;
+    const evalDivision = TXml.evalDivision;
 
-    const id = elem.getAttribute('id');
-    const uriObjs = XmlUtils.findChildren(elem, 'BaseURL');
+    const id = elem.attributes['id'];
+    const uriObjs = TXml.findChildren(elem, 'BaseURL');
     let calculatedBaseUris;
     let someLocationValid = false;
     if (this.contentSteeringManager_) {
       for (const uriObj of uriObjs) {
-        const serviceLocation = uriObj.getAttribute('serviceLocation');
-        const uri = XmlUtils.getContents(uriObj);
+        const serviceLocation = uriObj.attributes['serviceLocation'];
+        const uri = TXml.getContents(uriObj);
         if (serviceLocation && uri) {
           this.contentSteeringManager_.addLocation(
               id, serviceLocation, uri);
@@ -1755,7 +1807,7 @@ shaka.dash.DashParser = class {
       }
     }
     if (!someLocationValid || !this.contentSteeringManager_) {
-      calculatedBaseUris = uriObjs.map(XmlUtils.getContents);
+      calculatedBaseUris = uriObjs.map(TXml.getContents);
     }
 
     const getFrameUris = () => {
@@ -1771,55 +1823,55 @@ shaka.dash.DashParser = class {
       return [];
     };
 
-    let contentType = elem.getAttribute('contentType') || parent.contentType;
-    const mimeType = elem.getAttribute('mimeType') || parent.mimeType;
-    const codecs = elem.getAttribute('codecs') || parent.codecs;
+    let contentType = elem.attributes['contentType'] || parent.contentType;
+    const mimeType = elem.attributes['mimeType'] || parent.mimeType;
+    const codecs = elem.attributes['codecs'] || parent.codecs;
     const frameRate =
-        XmlUtils.parseAttr(elem, 'frameRate', evalDivision) || parent.frameRate;
+        TXml.parseAttr(elem, 'frameRate', evalDivision) || parent.frameRate;
     const pixelAspectRatio =
-        elem.getAttribute('sar') || parent.pixelAspectRatio;
+        elem.attributes['sar'] || parent.pixelAspectRatio;
     const emsgSchemeIdUris = this.emsgSchemeIdUris_(
-        XmlUtils.findChildren(elem, 'InbandEventStream'),
+        TXml.findChildren(elem, 'InbandEventStream'),
         parent.emsgSchemeIdUris);
     const audioChannelConfigs =
-        XmlUtils.findChildren(elem, 'AudioChannelConfiguration');
+        TXml.findChildren(elem, 'AudioChannelConfiguration');
     const numChannels =
         this.parseAudioChannels_(audioChannelConfigs) || parent.numChannels;
     const audioSamplingRate =
-        XmlUtils.parseAttr(elem, 'audioSamplingRate', parseNumber) ||
+        TXml.parseAttr(elem, 'audioSamplingRate', parseNumber) ||
         parent.audioSamplingRate;
 
     if (!contentType) {
       contentType = shaka.dash.DashParser.guessContentType_(mimeType, codecs);
     }
 
-    const segmentBase = XmlUtils.findChild(elem, 'SegmentBase');
-    const segmentTemplate = XmlUtils.findChild(elem, 'SegmentTemplate');
+    const segmentBase = TXml.findChild(elem, 'SegmentBase');
+    const segmentTemplate = TXml.findChild(elem, 'SegmentTemplate');
 
     // The availabilityTimeOffset is the sum of all @availabilityTimeOffset
     // values that apply to the adaptation set, via BaseURL, SegmentBase,
     // or SegmentTemplate elements.
     const segmentBaseAto = segmentBase ?
-        (XmlUtils.parseAttr(segmentBase, 'availabilityTimeOffset',
-            XmlUtils.parseFloat) || 0) : 0;
+        (TXml.parseAttr(segmentBase, 'availabilityTimeOffset',
+            TXml.parseFloat) || 0) : 0;
     const segmentTemplateAto = segmentTemplate ?
-        (XmlUtils.parseAttr(segmentTemplate, 'availabilityTimeOffset',
-            XmlUtils.parseFloat) || 0) : 0;
+        (TXml.parseAttr(segmentTemplate, 'availabilityTimeOffset',
+            TXml.parseFloat) || 0) : 0;
     const baseUriAto = uriObjs && uriObjs.length ?
-        (XmlUtils.parseAttr(uriObjs[0], 'availabilityTimeOffset',
-            XmlUtils.parseFloat) || 0) : 0;
+        (TXml.parseAttr(uriObjs[0], 'availabilityTimeOffset',
+            TXml.parseFloat) || 0) : 0;
 
     const availabilityTimeOffset = parent.availabilityTimeOffset + baseUriAto +
         segmentBaseAto + segmentTemplateAto;
 
     let segmentSequenceCadence = null;
     const segmentSequenceProperties =
-        XmlUtils.findChild(elem, 'SegmentSequenceProperties');
+        TXml.findChild(elem, 'SegmentSequenceProperties');
     if (segmentSequenceProperties) {
-      const sap = XmlUtils.findChild(segmentSequenceProperties, 'SAP');
+      const sap = TXml.findChild(segmentSequenceProperties, 'SAP');
       if (sap) {
-        segmentSequenceCadence = XmlUtils.parseAttr(sap, 'cadence',
-            XmlUtils.parseInt);
+        segmentSequenceCadence = TXml.parseAttr(sap, 'cadence',
+            TXml.parseInt);
       }
     }
 
@@ -1828,10 +1880,10 @@ shaka.dash.DashParser = class {
           () => ManifestParserUtils.resolveUris(getBaseUris(), getFrameUris()),
       segmentBase: segmentBase || parent.segmentBase,
       segmentList:
-          XmlUtils.findChild(elem, 'SegmentList') || parent.segmentList,
+          TXml.findChild(elem, 'SegmentList') || parent.segmentList,
       segmentTemplate: segmentTemplate || parent.segmentTemplate,
-      width: XmlUtils.parseAttr(elem, 'width', parseNumber) || parent.width,
-      height: XmlUtils.parseAttr(elem, 'height', parseNumber) || parent.height,
+      width: TXml.parseAttr(elem, 'width', parseNumber) || parent.width,
+      height: TXml.parseAttr(elem, 'height', parseNumber) || parent.height,
       contentType: contentType,
       mimeType: mimeType,
       codecs: codecs,
@@ -1839,7 +1891,7 @@ shaka.dash.DashParser = class {
       pixelAspectRatio: pixelAspectRatio,
       emsgSchemeIdUris: emsgSchemeIdUris,
       id: id,
-      language: elem.getAttribute('lang'),
+      language: elem.attributes['lang'],
       numChannels: numChannels,
       audioSamplingRate: audioSamplingRate,
       availabilityTimeOffset: availabilityTimeOffset,
@@ -1853,7 +1905,8 @@ shaka.dash.DashParser = class {
    * of the ones parsed from inBandEventStreams and the ones provided in
    * emsgSchemeIdUris.
    *
-   * @param {!Array.<!Element>} inBandEventStreams Array of InbandEventStream
+   * @param {!Array.<!shaka.extern.xml.Node>} inBandEventStreams
+   *     Array of InbandEventStream
    *     elements to parse and add to the returned array.
    * @param {!Array.<string>} emsgSchemeIdUris Array of parsed
    *     InbandEventStream schemeIdUri attributes to add to the returned array.
@@ -1864,7 +1917,7 @@ shaka.dash.DashParser = class {
   emsgSchemeIdUris_(inBandEventStreams, emsgSchemeIdUris) {
     const schemeIdUris = emsgSchemeIdUris.slice();
     for (const event of inBandEventStreams) {
-      const schemeIdUri = event.getAttribute('schemeIdUri');
+      const schemeIdUri = event.attributes['schemeIdUri'];
       if (!schemeIdUris.includes(schemeIdUri)) {
         schemeIdUris.push(schemeIdUri);
       }
@@ -1873,19 +1926,19 @@ shaka.dash.DashParser = class {
   }
 
   /**
-   * @param {!Array.<!Element>} audioChannelConfigs An array of
+   * @param {!Array.<!shaka.extern.xml.Node>} audioChannelConfigs An array of
    *   AudioChannelConfiguration elements.
    * @return {?number} The number of audio channels, or null if unknown.
    * @private
    */
   parseAudioChannels_(audioChannelConfigs) {
     for (const elem of audioChannelConfigs) {
-      const scheme = elem.getAttribute('schemeIdUri');
+      const scheme = elem.attributes['schemeIdUri'];
       if (!scheme) {
         continue;
       }
 
-      const value = elem.getAttribute('value');
+      const value = elem.attributes['value'];
       if (!value) {
         continue;
       }
@@ -2056,15 +2109,15 @@ shaka.dash.DashParser = class {
    * Parses an array of UTCTiming elements.
    *
    * @param {function():!Array.<string>} getBaseUris
-   * @param {!Array.<!Element>} elems
+   * @param {!Array.<!shaka.extern.xml.Node>} elems
    * @return {!Promise.<number>}
    * @private
    */
   async parseUtcTiming_(getBaseUris, elems) {
     const schemesAndValues = elems.map((elem) => {
       return {
-        scheme: elem.getAttribute('schemeIdUri'),
-        value: elem.getAttribute('value'),
+        scheme: elem.attributes['schemeIdUri'],
+        value: elem.attributes['value'],
       };
     });
 
@@ -2128,23 +2181,23 @@ shaka.dash.DashParser = class {
    *
    * @param {number} periodStart
    * @param {?number} periodDuration
-   * @param {!Element} elem
+   * @param {!shaka.extern.xml.Node} elem
    * @param {number} availabilityStart
    * @private
    */
   parseEventStream_(periodStart, periodDuration, elem, availabilityStart) {
-    const XmlUtils = shaka.util.XmlUtils;
-    const parseNumber = XmlUtils.parseNonNegativeInt;
+    const TXml = shaka.util.TXml;
+    const parseNumber = shaka.util.TXml.parseNonNegativeInt;
 
-    const schemeIdUri = elem.getAttribute('schemeIdUri') || '';
-    const value = elem.getAttribute('value') || '';
-    const timescale = XmlUtils.parseAttr(elem, 'timescale', parseNumber) || 1;
+    const schemeIdUri = elem.attributes['schemeIdUri'] || '';
+    const value = elem.attributes['value'] || '';
+    const timescale = TXml.parseAttr(elem, 'timescale', parseNumber) || 1;
 
-    for (const eventNode of XmlUtils.findChildren(elem, 'Event')) {
+    for (const eventNode of TXml.findChildren(elem, 'Event')) {
       const presentationTime =
-          XmlUtils.parseAttr(eventNode, 'presentationTime', parseNumber) || 0;
+          TXml.parseAttr(eventNode, 'presentationTime', parseNumber) || 0;
       const duration =
-          XmlUtils.parseAttr(eventNode, 'duration', parseNumber) || 0;
+          TXml.parseAttr(eventNode, 'duration', parseNumber) || 0;
 
       let startTime = presentationTime / timescale + periodStart;
       let endTime = startTime + (duration / timescale);
@@ -2166,8 +2219,9 @@ shaka.dash.DashParser = class {
         value: value,
         startTime: startTime,
         endTime: endTime,
-        id: eventNode.getAttribute('id') || '',
-        eventElement: eventNode,
+        id: eventNode.attributes['id'] || '',
+        eventElement: TXml.txmlNodeToDomElement(eventNode),
+        eventNode: eventNode,
       };
 
       this.playerInterface_.onTimelineRegionAdded(region);
@@ -2255,9 +2309,9 @@ shaka.dash.DashParser.RequestSegmentCallback;
 
 /**
  * @typedef {{
- *   segmentBase: Element,
- *   segmentList: Element,
- *   segmentTemplate: Element,
+ *   segmentBase: ?shaka.extern.xml.Node,
+ *   segmentList: ?shaka.extern.xml.Node,
+ *   segmentTemplate: ?shaka.extern.xml.Node,
  *   getBaseUris: function():!Array.<string>,
  *   width: (number|undefined),
  *   height: (number|undefined),
@@ -2279,11 +2333,11 @@ shaka.dash.DashParser.RequestSegmentCallback;
  * A collection of elements and properties which are inherited across levels
  * of a DASH manifest.
  *
- * @property {Element} segmentBase
+ * @property {?shaka.extern.xml.Node} segmentBase
  *   The XML node for SegmentBase.
- * @property {Element} segmentList
+ * @property {?shaka.extern.xml.Node} segmentList
  *   The XML node for SegmentList.
- * @property {Element} segmentTemplate
+ * @property {?shaka.extern.xml.Node} segmentTemplate
  *   The XML node for SegmentTemplate.
  * @property {function():!Array.<string>} getBaseUris
  *   Function than returns an array of absolute base URIs for the frame.
@@ -2368,7 +2422,7 @@ shaka.dash.DashParser.Context;
  * @typedef {{
  *   start: number,
  *   duration: ?number,
- *   node: !Element,
+ *   node: !shaka.extern.xml.Node,
  *   isLastPeriod: boolean
  * }}
  *
@@ -2380,7 +2434,7 @@ shaka.dash.DashParser.Context;
  * @property {?number} duration
  *   The duration of the period; or null if the duration is not given.  This
  *   will be non-null for all periods except the last.
- * @property {!Element} node
+ * @property {!shaka.extern.xml.Node} node
  *   The XML Node for the Period.
  * @property {boolean} isLastPeriod
  *   Whether this Period is the last one in the manifest.