Source: lib/net/http_xhr_plugin.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.net.HttpXHRPlugin');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.net.HttpPluginUtils');
  11. goog.require('shaka.net.NetworkingEngine');
  12. goog.require('shaka.util.AbortableOperation');
  13. goog.require('shaka.util.Error');
  16. /**
  17.  * @summary A networking plugin to handle http and https URIs via XHR.
  18.  * @export
  19.  */
  20. shaka.net.HttpXHRPlugin = class {
  21.   /**
  22.    * @param {string} uri
  23.    * @param {shaka.extern.Request} request
  24.    * @param {shaka.net.NetworkingEngine.RequestType} requestType
  25.    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
  26.    *   progress event happened.
  27.    * @param {shaka.extern.HeadersReceived} headersReceived Called when the
  28.    *   headers for the download are received, but before the body is.
  29.    * @param {shaka.extern.SchemePluginConfig} config
  30.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  31.    * @export
  32.    */
  33.   static parse(uri, request, requestType, progressUpdated, headersReceived,
  34.       config) {
  35.     const xhr = new shaka.net.HttpXHRPlugin.Xhr_();
  37.     // Last time stamp when we got a progress event.
  38.     let lastTime = Date.now();
  39.     // Last number of bytes loaded, from progress event.
  40.     let lastLoaded = 0;
  42.     const promise = new Promise(((resolve, reject) => {
  43.       xhr.open(request.method, uri, true);
  44.       xhr.responseType = 'arraybuffer';
  45.       xhr.timeout = request.retryParameters.timeout;
  46.       xhr.withCredentials = request.allowCrossSiteCredentials;
  48.       xhr.onabort = () => {
  49.         reject(new shaka.util.Error(
  50.             shaka.util.Error.Severity.RECOVERABLE,
  51.             shaka.util.Error.Category.NETWORK,
  52.             shaka.util.Error.Code.OPERATION_ABORTED,
  53.             uri, requestType));
  54.       };
  55.       let calledHeadersReceived = false;
  56.       xhr.onreadystatechange = (event) => {
  57.         // See if the readyState is 2 ("HEADERS_RECEIVED").
  58.         if (xhr.readyState == 2 && !calledHeadersReceived) {
  59.           const headers = shaka.net.HttpXHRPlugin.headersToGenericObject_(xhr);
  60.           headersReceived(headers);
  61.           // Don't send out this event twice.
  62.           calledHeadersReceived = true;
  63.         }
  64.       };
  65.       xhr.onload = (event) => {
  66.         const headers = shaka.net.HttpXHRPlugin.headersToGenericObject_(xhr);
  67.         // eslint-disable-next-line shaka-rules/buffersource-no-instanceof
  68.         goog.asserts.assert(xhr.response instanceof ArrayBuffer,
  69.             'XHR should have a response by now!');
  70.         const xhrResponse = xhr.response;
  72.         try {
  73.           const currentTime = Date.now();
  74.           progressUpdated(currentTime - lastTime, event.loaded - lastLoaded,
  75.               /* numBytesRemaining= */ 0);
  76.           const response = shaka.net.HttpPluginUtils.makeResponse(headers,
  77.               xhrResponse, xhr.status, uri, xhr.responseURL, requestType);
  78.           resolve(response);
  79.         } catch (error) {
  80.           goog.asserts.assert(error instanceof shaka.util.Error,
  81.               'Wrong error type!');
  82.           reject(error);
  83.         }
  84.       };
  85.       xhr.onerror = (event) => {
  86.         reject(new shaka.util.Error(
  87.             shaka.util.Error.Severity.RECOVERABLE,
  88.             shaka.util.Error.Category.NETWORK,
  89.             shaka.util.Error.Code.HTTP_ERROR,
  90.             uri, event, requestType));
  91.       };
  92.       xhr.ontimeout = (event) => {
  93.         reject(new shaka.util.Error(
  94.             shaka.util.Error.Severity.RECOVERABLE,
  95.             shaka.util.Error.Category.NETWORK,
  96.             shaka.util.Error.Code.TIMEOUT,
  97.             uri, requestType));
  98.       };
  99.       xhr.onprogress = (event) => {
  100.         const currentTime = Date.now();
  101.         // If the time between last time and this time we got progress event
  102.         // is long enough, or if a whole segment is downloaded, call
  103.         // progressUpdated().
  104.         const minBytes = config.minBytesForProgressEvents || 0;
  105.         const chunkSize = event.loaded - lastLoaded;
  106.         if ((currentTime - lastTime > 100 && chunkSize >= minBytes) ||
  107.             (event.lengthComputable && event.loaded == event.total)) {
  108.           const numBytesRemaining =
  109.               xhr.readyState == 4 ? 0 : event.total - event.loaded;
  110.           progressUpdated(currentTime - lastTime, chunkSize,
  111.               numBytesRemaining);
  112.           lastLoaded = event.loaded;
  113.           lastTime = currentTime;
  114.         }
  115.       };
  117.       for (const key in request.headers) {
  118.         // The Fetch API automatically normalizes outgoing header keys to
  119.         // lowercase. For consistency's sake, do it here too.
  120.         const lowercasedKey = key.toLowerCase();
  121.         xhr.setRequestHeader(lowercasedKey, request.headers[key]);
  122.       }
  123.       xhr.send(request.body);
  124.     }));
  126.     return new shaka.util.AbortableOperation(
  127.         promise,
  128.         () => {
  129.           xhr.abort();
  130.           return Promise.resolve();
  131.         });
  132.   }
  134.   /**
  135.    * @param {!XMLHttpRequest} xhr
  136.    * @return {!Object.<string, string>}
  137.    * @private
  138.    */
  139.   static headersToGenericObject_(xhr) {
  140.     // Since Edge incorrectly return the header with a leading new
  141.     // line character ('\n'), we trim the header here.
  142.     const headerLines = xhr.getAllResponseHeaders().trim().split('\r\n');
  143.     const headers = {};
  144.     for (const header of headerLines) {
  145.       /** @type {!Array.<string>} */
  146.       const parts = header.split(': ');
  147.       headers[parts[0].toLowerCase()] = parts.slice(1).join(': ');
  148.     }
  149.     return headers;
  150.   }
  151. };
  154. /**
  155.  * Overridden in unit tests, but compiled out in production.
  156.  *
  157.  * @const {function(new: XMLHttpRequest)}
  158.  * @private
  159.  */
  160. shaka.net.HttpXHRPlugin.Xhr_ = window.XMLHttpRequest;
  163. shaka.net.NetworkingEngine.registerScheme(
  164.     'http', shaka.net.HttpXHRPlugin.parse,
  165.     shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
  166.     /* progressSupport= */ true);
  167. shaka.net.NetworkingEngine.registerScheme(
  168.     'https', shaka.net.HttpXHRPlugin.parse,
  169.     shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
  170.     /* progressSupport= */ true);
  171. shaka.net.NetworkingEngine.registerScheme(
  172.     'blob', shaka.net.HttpXHRPlugin.parse,
  173.     shaka.net.NetworkingEngine.PluginPriority.FALLBACK,
  174.     /* progressSupport= */ true);