shaka-player 3.2.2 → 3.3.2

package/lib/media/region_observer.js

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

package/lib/media/region_timeline.js

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

package/lib/media/segment_index.js

@@ -347,7 +347,8 @@ shaka.media.SegmentIndex = class {
             lastReference.appendWindowStart,
             lastReference.appendWindowEnd,
             lastReference.partialReferences,
-            lastReference.tilesLayout);
+            lastReference.tilesLayout,
+            lastReference.tileDuration);
   }
 
 
@@ -427,6 +428,12 @@ shaka.media.SegmentIndex = class {
     return new shaka.media.SegmentIterator(this, index, partialSegmentIndex);
   }
 
+  /**
+   * @return {boolean}
+   */
+  isEmpty() {
+    return this.references.length == 0;
+  }
 
   /**
    * Create a SegmentIndex for a single segment of the given start time and

package/lib/media/segment_reference.js

@@ -23,11 +23,13 @@ shaka.media.InitSegmentReference = class {
    *   of the resource containing the segment.
    * @param {number} startByte The offset from the start of the resource to the
    *   start of the segment.
-   * @param {?number} endByte The offset from the start of the resource to the
-   *   end of the segment, inclusive.  A value of null indicates that the
+   * @param {?number} endByte The offset from the start of the resource
+   *   to the end of the segment, inclusive.  A value of null indicates that the
    *   segment extends to the end of the resource.
+   * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
+   *   the quality of the media associated with this init segment.
    */
-  constructor(uris, startByte, endByte) {
+  constructor(uris, startByte, endByte, mediaQuality = null) {
     /** @type {function():!Array.<string>} */
     this.getUris = uris;
 
@@ -36,6 +38,9 @@ shaka.media.InitSegmentReference = class {
 
     /** @const {?number} */
     this.endByte = endByte;
+
+    /** @const {shaka.extern.MediaQualityInfo|null} */
+    this.mediaQuality = mediaQuality;
   }
 
   /**
@@ -73,6 +78,16 @@ shaka.media.InitSegmentReference = class {
     }
   }
 
+  /**
+   * Returns media quality information for the segments associated with
+   * this init segment.
+   *
+   * @return {?shaka.extern.MediaQualityInfo}
+   */
+  getMediaQuality() {
+    return this.mediaQuality;
+  }
+
   /**
    * Check if two initSegmentReference have all the same values.
    * @param {?shaka.media.InitSegmentReference} reference1
@@ -140,11 +155,15 @@ shaka.media.SegmentReference = class {
    *   The value is a grid-item-dimension consisting of two positive decimal
    *   integers in the format: column-x-row ('4x3'). It describes the
    *   arrangement of Images in a Grid. The minimum valid LAYOUT is '1x1'.
+   * @param {?number=} tileDuration
+   *  The explicit duration of an individual tile within the tiles grid.
+   *  If not provided, the duration should be automatically calculated based on
+   *  the duration of the reference.
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
-      partialReferences = [], tilesLayout = '') {
+      partialReferences = [], tilesLayout = '', tileDuration = null) {
     // A preload hinted Partial Segment has the same startTime and endTime.
     goog.asserts.assert(startTime <= endTime,
         'startTime must be less than or equal to endTime');
@@ -191,6 +210,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?string} */
     this.tilesLayout = tilesLayout;
+
+    /** @type {?number} */
+    this.tileDuration = tileDuration;
   }
 
   /**
@@ -275,6 +297,17 @@ shaka.media.SegmentReference = class {
   getTilesLayout() {
     return this.tilesLayout;
   }
+
+  /**
+   * Returns the segment's explicit tile duration.
+   * Only defined in image segments.
+   *
+   * @return {?number}
+   * @export
+   */
+  getTileDuration() {
+    return this.tileDuration;
+  }
 };
 
 

package/lib/media/streaming_engine.js

@@ -431,6 +431,11 @@ shaka.media.StreamingEngine = class {
       this.playerInterface_.mediaSourceEngine.reinitText(fullMimeType);
     }
 
+    // Releases the segmentIndex of the old stream.
+    if (mediaState.stream.closeSegmentIndex) {
+      mediaState.stream.closeSegmentIndex();
+    }
+
     mediaState.stream = stream;
     mediaState.segmentIterator = null;
 
@@ -623,7 +628,7 @@ shaka.media.StreamingEngine = class {
 
         // Don't clear the buffer unless something is buffered.  This extra
         // check prevents extra, useless calls to clear the buffer.
-        if (somethingBuffered) {
+        if (somethingBuffered || mediaState.performingUpdate) {
           this.forceClearBuffer_(mediaState);
           streamCleared = true;
         }
@@ -863,7 +868,7 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
-    // Make sure the segment index exists.
+    // Make sure the segment index exists. If not, create the segment index.
     if (!mediaState.stream.segmentIndex) {
       const thisStream = mediaState.stream;
 
@@ -873,6 +878,12 @@ shaka.media.StreamingEngine = class {
         // We switched streams while in the middle of this async call to
         // createSegmentIndex.  Abandon this update and schedule a new one if
         // there's not already one pending.
+        // Releases the segmentIndex of the old stream.
+        if (thisStream.closeSegmentIndex) {
+          goog.asserts.assert(!mediaState.stream.segmentIndex,
+              'mediastate.stream should not have segmentIndex yet.');
+          thisStream.closeSegmentIndex();
+        }
         if (mediaState.updateTimer == null) {
           this.scheduleUpdate_(mediaState, 0);
         }
@@ -977,7 +988,10 @@ shaka.media.StreamingEngine = class {
         unscaledBufferingGoal * this.bufferingGoalScale_;
 
     // Check if we've buffered to the end of the presentation.
-    if (timeNeeded >= this.manifest_.presentationTimeline.getDuration()) {
+    const timeUntilEnd =
+        this.manifest_.presentationTimeline.getDuration() - timeNeeded;
+    const oneMicrosecond = 1e-6;
+    if (timeUntilEnd < oneMicrosecond) {
       // We shouldn't rebuffer if the playhead is close to the end of the
       // presentation.
       shaka.log.debug(logPrefix, 'buffered to end of presentation');
@@ -1530,6 +1544,8 @@ shaka.media.StreamingEngine = class {
             throw error;
           }
         };
+        this.playerInterface_.onInitSegmentAppended(
+            reference.startTime, reference.initSegmentReference);
         operations.push(append());
       }
     }
@@ -1555,7 +1571,9 @@ shaka.media.StreamingEngine = class {
 
     const hasClosedCaptions = stream.closedCaptions &&
         stream.closedCaptions.size > 0;
-    if (stream.emsgSchemeIdUris != null && stream.emsgSchemeIdUris.length > 0) {
+    if ((stream.emsgSchemeIdUris != null &&
+        stream.emsgSchemeIdUris.length > 0) ||
+        this.config_.dispatchAllEmsgBoxes) {
       new shaka.util.Mp4Parser()
           .fullBox(
               'emsg',
@@ -1641,7 +1659,8 @@ shaka.media.StreamingEngine = class {
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
-    if (emsgSchemeIdUris.includes(schemeId)) {
+    if ((emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) ||
+        this.config_.dispatchAllEmsgBoxes) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {
@@ -1764,6 +1783,19 @@ shaka.media.StreamingEngine = class {
 
     shaka.log.v2('fetching: reference=', reference);
 
+    const stream = mediaState.stream;
+    this.playerInterface_.modifySegmentRequest(
+        request,
+        {
+          type: stream.type,
+          init: reference instanceof shaka.media.InitSegmentReference,
+          duration: reference.endTime - reference.startTime,
+          mimeType: stream.mimeType,
+          codecs: stream.codecs,
+          bandwidth: stream.bandwidth,
+        },
+    );
+
     const op = this.playerInterface_.netEngine.request(requestType, request);
     mediaState.operation = op;
     const response = await op.promise;
@@ -1927,12 +1959,15 @@ shaka.media.StreamingEngine = class {
  * @typedef {{
  *   getPresentationTime: function():number,
  *   getBandwidthEstimate: function():number,
+ *   modifySegmentRequest: function(shaka.extern.Request,
+ *     shaka.util.CmcdManager.SegmentInfo),
  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  *   netEngine: shaka.net.NetworkingEngine,
  *   onError: function(!shaka.util.Error),
  *   onEvent: function(!Event),
  *   onManifestUpdate: function(),
- *   onSegmentAppended: function()
+ *   onSegmentAppended: function(),
+ *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference)
  * }}
  *
  * @property {function():number} getPresentationTime
@@ -1940,6 +1975,9 @@ shaka.media.StreamingEngine = class {
  *   viewer is seeing on screen right now.
  * @property {function():number} getBandwidthEstimate
  *   Get the estimated bandwidth in bits per second.
+ * @property {function(shaka.extern.Request,
+ *   shaka.extern.Cmcd.SegmentInfo)} modifySegmentRequest
+ *   The request modifier
  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  *   The MediaSourceEngine. The caller retains ownership.
  * @property {shaka.net.NetworkingEngine} netEngine
@@ -1954,6 +1992,9 @@ shaka.media.StreamingEngine = class {
  *   Called when an embedded 'emsg' box should trigger a manifest update.
  * @property {function()} onSegmentAppended
  *   Called after a segment is successfully appended to a MediaSource.
+ * @property
+ *  {function(!number, !shaka.media.InitSegmentReference)} onInitSegmentAppended
+ *   Called when an init segment is appended to a MediaSource.
  */
 shaka.media.StreamingEngine.PlayerInterface;
 

package/lib/net/http_fetch_plugin.js

@@ -27,10 +27,12 @@ shaka.net.HttpFetchPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    * @export
    */
-  static parse(uri, request, requestType, progressUpdated) {
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {
     const headers = new shaka.net.HttpFetchPlugin.Headers_();
     shaka.util.MapUtils.asMap(request.headers).forEach((value, key) => {
       headers.append(key, value);
@@ -55,7 +57,7 @@ shaka.net.HttpFetchPlugin = class {
     };
 
     const pendingRequest = shaka.net.HttpFetchPlugin.request_(
-        uri, requestType, init, abortStatus, progressUpdated,
+        uri, requestType, init, abortStatus, progressUpdated, headersReceived,
         request.streamDataCallback);
 
     /** @type {!shaka.util.AbortableOperation} */
@@ -92,12 +94,13 @@ shaka.net.HttpFetchPlugin = class {
    * @param {!RequestInit} init
    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
    * @param {shaka.extern.ProgressUpdated} progressUpdated
+   * @param {shaka.extern.HeadersReceived} headersReceived
    * @param {?function(BufferSource):!Promise} streamDataCallback
    * @return {!Promise<!shaka.extern.Response>}
    * @private
    */
   static async request_(uri, requestType, init, abortStatus, progressUpdated,
-      streamDataCallback) {
+      headersReceived, streamDataCallback) {
     const fetch = shaka.net.HttpFetchPlugin.fetch_;
     const ReadableStream = shaka.net.HttpFetchPlugin.ReadableStream_;
     let response;
@@ -113,6 +116,10 @@ shaka.net.HttpFetchPlugin = class {
       // headers are available. The download itself isn't done until the promise
       // for retrieving the data (arrayBuffer, blob, etc) has resolved.
       response = await fetch(uri, init);
+      // At this point in the process, we have the headers of the response, but
+      // not the body yet.
+      headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
+          response.headers));
       // Getting the reader in this way allows us to observe the process of
       // downloading the body, instead of just waiting for an opaque promise to
       // resolve.
@@ -194,19 +201,28 @@ shaka.net.HttpFetchPlugin = class {
       }
     }
 
-    const headers = {};
-    /** @type {Headers} */
-    const responseHeaders = response.headers;
-    responseHeaders.forEach((value, key) => {
-      // Since Edge incorrectly return the header with a leading new line
-      // character ('\n'), we trim the header here.
-      headers[key.trim()] = value;
-    });
+    const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
+        response.headers);
 
     return shaka.net.HttpPluginUtils.makeResponse(
         headers, arrayBuffer, response.status, uri, response.url, requestType);
   }
 
+  /**
+   * @param {!Headers} headers
+   * @return {!Object.<string, string>}
+   * @private
+   */
+  static headersToGenericObject_(headers) {
+    const headersObj = {};
+    headers.forEach((value, key) => {
+      // Since Edge incorrectly return the header with a leading new line
+      // character ('\n'), we trim the header here.
+      headersObj[key.trim()] = value;
+    });
+    return headersObj;
+  }
+
   /**
    * Determine if the Fetch API is supported in the browser. Note: this is
    * deliberately exposed as a method to allow the client app to use the same
@@ -290,4 +306,8 @@ if (shaka.net.HttpFetchPlugin.isSupported()) {
       'https', shaka.net.HttpFetchPlugin.parse,
       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
       /* progressSupport= */ true);
+  shaka.net.NetworkingEngine.registerScheme(
+      'blob', shaka.net.HttpFetchPlugin.parse,
+      shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
+      /* progressSupport= */ true);
 }

package/lib/net/http_plugin_utils.js

@@ -34,6 +34,7 @@ shaka.net.HttpPluginUtils = class {
         uri: responseURL || uri,
         originalUri: uri,
         data: data,
+        status: status,
         headers: headers,
         fromCache: !!headers['x-shaka-from-cache'],
       };

package/lib/net/http_xhr_plugin.js

@@ -24,10 +24,12 @@ shaka.net.HttpXHRPlugin = class {
    * @param {shaka.net.NetworkingEngine.RequestType} requestType
    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
    *   progress event happened.
+   * @param {shaka.extern.HeadersReceived} headersReceived Called when the
+   *   headers for the download are received, but before the body is.
    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
    * @export
    */
-  static parse(uri, request, requestType, progressUpdated) {
+  static parse(uri, request, requestType, progressUpdated, headersReceived) {
     const xhr = new shaka.net.HttpXHRPlugin.Xhr_();
 
     // Last time stamp when we got a progress event.
@@ -48,23 +50,25 @@ shaka.net.HttpXHRPlugin = class {
             shaka.util.Error.Code.OPERATION_ABORTED,
             uri, requestType));
       };
-      xhr.onload = (event) => {
-        const target = event.target;
-        goog.asserts.assert(target, 'XHR onload has no target!');
-        // Since Edge incorrectly return the header with a leading new
-        // line character ('\n'), we trim the header here.
-        const headerLines = target.getAllResponseHeaders().trim().split('\r\n');
-        const headers = {};
-        for (const header of headerLines) {
-          /** @type {!Array.<string>} */
-          const parts = header.split(': ');
-          headers[parts[0].toLowerCase()] = parts.slice(1).join(': ');
+      let calledHeadersReceived = false;
+      xhr.onreadystatechange = (event) => {
+        // See if the readyState is 2 ("HEADERS_RECEIVED").
+        if (xhr.readyState == 2 && !calledHeadersReceived) {
+          const headers = shaka.net.HttpXHRPlugin.headersToGenericObject_(xhr);
+          headersReceived(headers);
+          // Don't send out this event twice.
+          calledHeadersReceived = true;
         }
+      };
+      xhr.onload = (event) => {
+        const headers = shaka.net.HttpXHRPlugin.headersToGenericObject_(xhr);
+        goog.asserts.assert(xhr.response instanceof ArrayBuffer,
+            'XHR should have a response by now!');
+        const xhrResponse = xhr.response;
 
         try {
           const response = shaka.net.HttpPluginUtils.makeResponse(headers,
-              target.response, target.status, uri, target.responseURL,
-              requestType);
+              xhrResponse, xhr.status, uri, xhr.responseURL, requestType);
           resolve(response);
         } catch (error) {
           goog.asserts.assert(error instanceof shaka.util.Error,
@@ -116,6 +120,24 @@ shaka.net.HttpXHRPlugin = class {
           return Promise.resolve();
         });
   }
+
+  /**
+   * @param {!XMLHttpRequest} xhr
+   * @return {!Object.<string, string>}
+   * @private
+   */
+  static headersToGenericObject_(xhr) {
+    // Since Edge incorrectly return the header with a leading new
+    // line character ('\n'), we trim the header here.
+    const headerLines = xhr.getAllResponseHeaders().trim().split('\r\n');
+    const headers = {};
+    for (const header of headerLines) {
+      /** @type {!Array.<string>} */
+      const parts = header.split(': ');
+      headers[parts[0].toLowerCase()] = parts.slice(1).join(': ');
+    }
+    return headers;
+  }
 };
 
 
@@ -136,4 +158,8 @@ shaka.net.NetworkingEngine.registerScheme(
     'https', shaka.net.HttpXHRPlugin.parse,
     shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
     /* progressSupport= */ true);
+shaka.net.NetworkingEngine.registerScheme(
+    'blob', shaka.net.HttpXHRPlugin.parse,
+    shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
+    /* progressSupport= */ true);