Source: lib/net/http_fetch_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.HttpFetchPlugin');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.net.HttpPluginUtils');
  12. goog.require('shaka.net.NetworkingEngine');
  13. goog.require('shaka.util.AbortableOperation');
  14. goog.require('shaka.util.Error');
  15. goog.require('shaka.util.MapUtils');
  16. goog.require('shaka.util.Timer');
  19. /**
  20.  * @summary A networking plugin to handle http and https URIs via the Fetch API.
  21.  * @export
  22.  */
  23. shaka.net.HttpFetchPlugin = class {
  24.   /**
  25.    * @param {string} uri
  26.    * @param {shaka.extern.Request} request
  27.    * @param {shaka.net.NetworkingEngine.RequestType} requestType
  28.    * @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
  29.    *   progress event happened.
  30.    * @param {shaka.extern.HeadersReceived} headersReceived Called when the
  31.    *   headers for the download are received, but before the body is.
  32.    * @param {shaka.extern.SchemePluginConfig} config
  33.    * @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  34.    * @export
  35.    */
  36.   static parse(uri, request, requestType, progressUpdated, headersReceived,
  37.       config) {
  38.     const headers = new shaka.net.HttpFetchPlugin.Headers_();
  39.     shaka.util.MapUtils.asMap(request.headers).forEach((value, key) => {
  40.       headers.append(key, value);
  41.     });
  43.     const controller = new shaka.net.HttpFetchPlugin.AbortController_();
  45.     /** @type {!RequestInit} */
  46.     const init = {
  47.       // Edge does not treat null as undefined for body; https://bit.ly/2luyE6x
  48.       body: request.body || undefined,
  49.       headers: headers,
  50.       method: request.method,
  51.       signal: controller.signal,
  52.       credentials: request.allowCrossSiteCredentials ? 'include' : undefined,
  53.     };
  55.     /** @type {shaka.net.HttpFetchPlugin.AbortStatus} */
  56.     const abortStatus = {
  57.       canceled: false,
  58.       timedOut: false,
  59.     };
  61.     const minBytes = config.minBytesForProgressEvents || 0;
  63.     const pendingRequest = shaka.net.HttpFetchPlugin.request_(
  64.         uri, request, requestType, init, abortStatus, progressUpdated,
  65.         headersReceived, request.streamDataCallback, minBytes);
  67.     /** @type {!shaka.util.AbortableOperation} */
  68.     const op = new shaka.util.AbortableOperation(pendingRequest, () => {
  69.       abortStatus.canceled = true;
  70.       controller.abort();
  71.       return Promise.resolve();
  72.     });
  74.     // The fetch API does not timeout natively, so do a timeout manually using
  75.     // the AbortController.
  76.     const timeoutMs = request.retryParameters.timeout;
  77.     if (timeoutMs) {
  78.       const timer = new shaka.util.Timer(() => {
  79.         abortStatus.timedOut = true;
  80.         controller.abort();
  81.       });
  83.       timer.tickAfter(timeoutMs / 1000);
  85.       // To avoid calling |abort| on the network request after it finished, we
  86.       // will stop the timer when the requests resolves/rejects.
  87.       op.finally(() => {
  88.         timer.stop();
  89.       });
  90.     }
  92.     return op;
  93.   }
  95.   /**
  96.    * @param {string} uri
  97.    * @param {shaka.extern.Request} request
  98.    * @param {shaka.net.NetworkingEngine.RequestType} requestType
  99.    * @param {!RequestInit} init
  100.    * @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
  101.    * @param {shaka.extern.ProgressUpdated} progressUpdated
  102.    * @param {shaka.extern.HeadersReceived} headersReceived
  103.    * @param {?function(BufferSource):!Promise} streamDataCallback
  104.    * @param {number} minBytes
  105.    * @return {!Promise<!shaka.extern.Response>}
  106.    * @private
  107.    */
  108.   static async request_(uri, request, requestType, init, abortStatus,
  109.       progressUpdated, headersReceived, streamDataCallback, minBytes) {
  110.     const fetch = shaka.net.HttpFetchPlugin.fetch_;
  111.     const ReadableStream = shaka.net.HttpFetchPlugin.ReadableStream_;
  112.     let response;
  113.     let arrayBuffer = new ArrayBuffer(0);
  114.     let loaded = 0;
  115.     let lastLoaded = 0;
  117.     // Last time stamp when we got a progress event.
  118.     let lastTime = Date.now();
  120.     try {
  121.       // The promise returned by fetch resolves as soon as the HTTP response
  122.       // headers are available. The download itself isn't done until the promise
  123.       // for retrieving the data (arrayBuffer, blob, etc) has resolved.
  124.       response = await fetch(uri, init);
  125.       // At this point in the process, we have the headers of the response, but
  126.       // not the body yet.
  127.       headersReceived(shaka.net.HttpFetchPlugin.headersToGenericObject_(
  128.           response.headers));
  130.       // In new versions of Chromium, HEAD requests now have a response body
  131.       // that is null.
  132.       // So just don't try to download the body at all, if it's a HEAD request,
  133.       // to avoid null reference errors.
  134.       // See: https://crbug.com/1297060
  135.       if (init.method != 'HEAD') {
  136.         goog.asserts.assert(response.body,
  137.             'non-HEAD responses should have a body');
  139.         const contentLengthRaw = response.headers.get('Content-Length');
  140.         const contentLength =
  141.             contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
  143.         // Fetch returning a ReadableStream response body is not currently
  144.         // supported by all browsers.
  145.         // Browser compatibility:
  146.         // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
  147.         // If it is not supported, returning the whole segment when
  148.         // it's ready (as xhr)
  149.         if (!response.body) {
  150.           arrayBuffer = await response.arrayBuffer();
  151.           const currentTime = Date.now();
  152.           // If the time between last time and this time we got progress event
  153.           // is long enough, or if a whole segment is downloaded, call
  154.           // progressUpdated().
  155.           progressUpdated(currentTime - lastTime, arrayBuffer.byteLength, 0);
  156.         } else {
  157.           // Getting the reader in this way allows us to observe the process of
  158.           // downloading the body, instead of just waiting for an opaque
  159.           // promise to resolve.
  160.           // We first clone the response because calling getReader lock the body
  161.           // stream; if we didn't clone it here, we would be unable to get the
  162.           // response's arrayBuffer later.
  163.           const reader = response.clone().body.getReader();
  164.           const start = (controller) => {
  165.             const push = async () => {
  166.               let readObj;
  167.               try {
  168.                 readObj = await reader.read();
  169.               } catch (e) {
  170.                 // If we abort the request, we'll get an error here.
  171.                 // Just ignore it
  172.                 // since real errors will be reported when we read
  173.                 // the buffer below.
  174.                 shaka.log.v1('error reading from stream', e.message);
  175.                 return;
  176.               }
  177.               if (!readObj.done) {
  178.                 loaded += readObj.value.byteLength;
  179.                 if (streamDataCallback) {
  180.                   await streamDataCallback(readObj.value);
  181.                 }
  182.               }
  184.               const currentTime = Date.now();
  185.               const chunkSize = loaded - lastLoaded;
  186.               // If the time between last time and this time we got
  187.               // progress event is long enough, or if a whole segment
  188.               // is downloaded, call progressUpdated().
  189.               if ((currentTime - lastTime > 100 && chunkSize >= minBytes) ||
  190.                   readObj.done) {
  191.                 const numBytesRemaining =
  192.                     readObj.done ? 0 : contentLength - loaded;
  193.                 progressUpdated(currentTime - lastTime, chunkSize,
  194.                     numBytesRemaining);
  195.                 lastLoaded = loaded;
  196.                 lastTime = currentTime;
  197.               }
  199.               if (readObj.done) {
  200.                 goog.asserts.assert(!readObj.value,
  201.                     'readObj should be unset when "done" is true.');
  202.                 controller.close();
  203.               } else {
  204.                 controller.enqueue(readObj.value);
  205.                 push();
  206.               }
  207.             };
  208.             push();
  209.           };
  210.           // Create a ReadableStream to use the reader. We don't need to use the
  211.           // actual stream for anything, though, as we are using the response's
  212.           // arrayBuffer method to get the body, so we don't store the
  213.           // ReadableStream.
  214.           new ReadableStream({start}); // eslint-disable-line no-new
  215.           arrayBuffer = await response.arrayBuffer();
  216.         }
  217.       }
  218.     } catch (error) {
  219.       if (abortStatus.canceled) {
  220.         throw new shaka.util.Error(
  221.             shaka.util.Error.Severity.RECOVERABLE,
  222.             shaka.util.Error.Category.NETWORK,
  223.             shaka.util.Error.Code.OPERATION_ABORTED,
  224.             uri, requestType);
  225.       } else if (abortStatus.timedOut) {
  226.         throw new shaka.util.Error(
  227.             shaka.util.Error.Severity.RECOVERABLE,
  228.             shaka.util.Error.Category.NETWORK,
  229.             shaka.util.Error.Code.TIMEOUT,
  230.             uri, requestType);
  231.       } else {
  232.         throw new shaka.util.Error(
  233.             shaka.util.Error.Severity.RECOVERABLE,
  234.             shaka.util.Error.Category.NETWORK,
  235.             shaka.util.Error.Code.HTTP_ERROR,
  236.             uri, error, requestType);
  237.       }
  238.     }
  240.     const headers = shaka.net.HttpFetchPlugin.headersToGenericObject_(
  241.         response.headers);
  243.     return shaka.net.HttpPluginUtils.makeResponse(headers, arrayBuffer,
  244.         response.status, uri, response.url, request, requestType);
  245.   }
  247.   /**
  248.    * @param {!Headers} headers
  249.    * @return {!Object<string, string>}
  250.    * @private
  251.    */
  252.   static headersToGenericObject_(headers) {
  253.     const headersObj = {};
  254.     headers.forEach((value, key) => {
  255.       // Since Edge incorrectly return the header with a leading new line
  256.       // character ('\n'), we trim the header here.
  257.       headersObj[key.trim()] = value;
  258.     });
  259.     return headersObj;
  260.   }
  262.   /**
  263.    * Determine if the Fetch API is supported in the browser. Note: this is
  264.    * deliberately exposed as a method to allow the client app to use the same
  265.    * logic as Shaka when determining support.
  266.    * @return {boolean}
  267.    * @export
  268.    */
  269.   static isSupported() {
  270.     // On Edge, ReadableStream exists, but attempting to construct it results in
  271.     // an error. See https://bit.ly/2zwaFLL
  272.     // So this has to check that ReadableStream is present AND usable.
  273.     if (window.ReadableStream) {
  274.       try {
  275.         new ReadableStream({}); // eslint-disable-line no-new
  276.       } catch (e) {
  277.         return false;
  278.       }
  279.     } else {
  280.       return false;
  281.     }
  282.     // Old fetch implementations hasn't body and ReadableStream implementation
  283.     // See: https://github.com/shaka-project/shaka-player/issues/5088
  284.     if (window.Response) {
  285.       const response = new Response('');
  286.       if (!response.body) {
  287.         return false;
  288.       }
  289.     } else {
  290.       return false;
  291.     }
  292.     return !!(window.fetch && !('polyfill' in window.fetch) &&
  293.       window.AbortController);
  294.   }
  295. };
  298. /**
  299.  * @typedef {{
  300.  *   canceled: boolean,
  301.  *   timedOut: boolean
  302.  * }}
  303.  * @property {boolean} canceled
  304.  *   Indicates if the request was canceled.
  305.  * @property {boolean} timedOut
  306.  *   Indicates if the request timed out.
  307.  */
  308. shaka.net.HttpFetchPlugin.AbortStatus;
  311. /**
  312.  * Overridden in unit tests, but compiled out in production.
  313.  *
  314.  * @const {function(string, !RequestInit)}
  315.  * @private
  316.  */
  317. shaka.net.HttpFetchPlugin.fetch_ = window.fetch;
  320. /**
  321.  * Overridden in unit tests, but compiled out in production.
  322.  *
  323.  * @const {function(new: AbortController)}
  324.  * @private
  325.  */
  326. shaka.net.HttpFetchPlugin.AbortController_ = window.AbortController;
  329. /**
  330.  * Overridden in unit tests, but compiled out in production.
  331.  *
  332.  * @const {function(new: ReadableStream, !Object)}
  333.  * @private
  334.  */
  335. shaka.net.HttpFetchPlugin.ReadableStream_ = window.ReadableStream;
  338. /**
  339.  * Overridden in unit tests, but compiled out in production.
  340.  *
  341.  * @const {function(new: Headers)}
  342.  * @private
  343.  */
  344. shaka.net.HttpFetchPlugin.Headers_ = window.Headers;
  347. if (shaka.net.HttpFetchPlugin.isSupported()) {
  348.   shaka.net.NetworkingEngine.registerScheme(
  349.       'http', shaka.net.HttpFetchPlugin.parse,
  350.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  351.       /* progressSupport= */ true);
  352.   shaka.net.NetworkingEngine.registerScheme(
  353.       'https', shaka.net.HttpFetchPlugin.parse,
  354.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  355.       /* progressSupport= */ true);
  356.   shaka.net.NetworkingEngine.registerScheme(
  357.       'blob', shaka.net.HttpFetchPlugin.parse,
  358.       shaka.net.NetworkingEngine.PluginPriority.PREFERRED,
  359.       /* progressSupport= */ true);
  360. }