Source: lib/net/networking_engine.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.net.NetworkingEngine');
  8. goog.provide('shaka.net.NetworkingEngine.AdvancedRequestType');
  9. goog.provide('shaka.net.NetworkingEngine.RequestType');
  10. goog.provide('shaka.net.NetworkingEngine.PendingRequest');
  12. goog.require('goog.Uri');
  13. goog.require('goog.asserts');
  14. goog.require('shaka.net.Backoff');
  15. goog.require('shaka.util.AbortableOperation');
  16. goog.require('shaka.util.BufferUtils');
  17. goog.require('shaka.util.Error');
  18. goog.require('shaka.util.FakeEvent');
  19. goog.require('shaka.util.FakeEventTarget');
  20. goog.require('shaka.util.IDestroyable');
  21. goog.require('shaka.util.ObjectUtils');
  22. goog.require('shaka.util.OperationManager');
  23. goog.require('shaka.util.Timer');
  26. /**
  27.  * @event shaka.net.NetworkingEngine.RetryEvent
  28.  * @description Fired when the networking engine receives a recoverable error
  29.  *   and retries.
  30.  * @property {string} type
  31.  *   'retry'
  32.  * @property {?shaka.util.Error} error
  33.  *   The error that caused the retry. If it was a non-Shaka error, this is set
  34.  *   to null.
  35.  * @exportDoc
  36.  */
  39. /**
  40.  * NetworkingEngine wraps all networking operations.  This accepts plugins that
  41.  * handle the actual request.  A plugin is registered using registerScheme.
  42.  * Each scheme has at most one plugin to handle the request.
  43.  *
  44.  * @implements {shaka.util.IDestroyable}
  45.  * @export
  46.  */
  47. shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
  48.   /**
  49.    * @param {shaka.net.NetworkingEngine.onProgressUpdated=} onProgressUpdated
  50.    *   Called when
  51.    *   a progress event is triggered. Passed the duration, in milliseconds,
  52.    *   that the request took, the number of bytes transferred, and the boolean
  53.    *   of whether the switching is allowed.
  54.    * @param {shaka.net.NetworkingEngine.OnHeadersReceived=} onHeadersReceived
  55.    *   Called when the headers are received for a download.
  56.    * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
  57.    *   Called when a download fails, for any reason.
  58.    * @param {shaka.net.NetworkingEngine.OnRequest=} onRequest
  59.    *   Called when a request is made
  60.    * @param {shaka.net.NetworkingEngine.OnRetry=} onRetry
  61.    *   Called when a request retry is made
  62.    * @param {shaka.net.NetworkingEngine.OnResponse=} onResponse
  63.    *   Called when receive the response
  64.    */
  65.   constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed,
  66.       onRequest, onRetry, onResponse) {
  67.     super();
  69.     /** @private {boolean} */
  70.     this.destroyed_ = false;
  72.     /** @private {!shaka.util.OperationManager} */
  73.     this.operationManager_ = new shaka.util.OperationManager();
  75.     /** @private {!Set.<shaka.extern.RequestFilter>} */
  76.     this.requestFilters_ = new Set();
  78.     /** @private {!Set.<shaka.extern.ResponseFilter>} */
  79.     this.responseFilters_ = new Set();
  81.     /** @private {?shaka.net.NetworkingEngine.onProgressUpdated} */
  82.     this.onProgressUpdated_ = onProgressUpdated || null;
  84.     /** @private {?shaka.net.NetworkingEngine.OnHeadersReceived} */
  85.     this.onHeadersReceived_ = onHeadersReceived || null;
  87.     /** @private {?shaka.net.NetworkingEngine.OnDownloadFailed} */
  88.     this.onDownloadFailed_ = onDownloadFailed || null;
  90.     /** @private {?shaka.net.NetworkingEngine.OnRequest} */
  91.     this.onRequest_ = onRequest || null;
  93.     /** @private {?shaka.net.NetworkingEngine.OnRetry} */
  94.     this.onRetry_ = onRetry || null;
  96.     /** @private {?shaka.net.NetworkingEngine.OnResponse} */
  97.     this.onResponse_ = onResponse || null;
  99.     /** @private {boolean} */
  100.     this.forceHTTP_ = false;
  102.     /** @private {boolean} */
  103.     this.forceHTTPS_ = false;
  104.   }
  106.   /**
  107.    * @param {boolean} forceHTTP
  108.    * @export
  109.    */
  110.   setForceHTTP(forceHTTP) {
  111.     this.forceHTTP_ = forceHTTP;
  112.   }
  114.   /**
  115.    * @param {boolean} forceHTTPS
  116.    * @export
  117.    */
  118.   setForceHTTPS(forceHTTPS) {
  119.     this.forceHTTPS_ = forceHTTPS;
  120.   }
  122.   /**
  123.    * Registers a scheme plugin.  This plugin will handle all requests with the
  124.    * given scheme.  If a plugin with the same scheme already exists, it is
  125.    * replaced, unless the existing plugin is of higher priority.
  126.    * If no priority is provided, this defaults to the highest priority of
  127.    * APPLICATION.
  128.    *
  129.    * @param {string} scheme
  130.    * @param {shaka.extern.SchemePlugin} plugin
  131.    * @param {number=} priority
  132.    * @param {boolean=} progressSupport
  133.    * @export
  134.    */
  135.   static registerScheme(scheme, plugin, priority, progressSupport = false) {
  136.     goog.asserts.assert(
  137.         priority == undefined || priority > 0, 'explicit priority must be > 0');
  138.     priority =
  139.         priority || shaka.net.NetworkingEngine.PluginPriority.APPLICATION;
  140.     const existing = shaka.net.NetworkingEngine.schemes_[scheme];
  141.     if (!existing || priority >= existing.priority) {
  142.       shaka.net.NetworkingEngine.schemes_[scheme] = {
  143.         priority: priority,
  144.         plugin: plugin,
  145.         progressSupport: progressSupport,
  146.       };
  147.     }
  148.   }
  150.   /**
  151.    * Removes a scheme plugin.
  152.    *
  153.    * @param {string} scheme
  154.    * @export
  155.    */
  156.   static unregisterScheme(scheme) {
  157.     delete shaka.net.NetworkingEngine.schemes_[scheme];
  158.   }
  160.   /**
  161.    * Copies all of the filters from this networking engine into another.
  162.    * @param {!shaka.net.NetworkingEngine} other
  163.    */
  164.   copyFiltersInto(other) {
  165.     for (const filter of this.requestFilters_) {
  166.       other.requestFilters_.add(filter);
  167.     }
  168.     for (const filter of this.responseFilters_) {
  169.       other.responseFilters_.add(filter);
  170.     }
  171.   }
  173.   /**
  174.    * Registers a new request filter.  All filters are applied in the order they
  175.    * are registered.
  176.    *
  177.    * @param {shaka.extern.RequestFilter} filter
  178.    * @export
  179.    */
  180.   registerRequestFilter(filter) {
  181.     this.requestFilters_.add(filter);
  182.   }
  184.   /**
  185.    * Removes a request filter.
  186.    *
  187.    * @param {shaka.extern.RequestFilter} filter
  188.    * @export
  189.    */
  190.   unregisterRequestFilter(filter) {
  191.     this.requestFilters_.delete(filter);
  192.   }
  194.   /**
  195.    * Clears all request filters.
  196.    *
  197.    * @export
  198.    */
  199.   clearAllRequestFilters() {
  200.     this.requestFilters_.clear();
  201.   }
  203.   /**
  204.    * Registers a new response filter.  All filters are applied in the order they
  205.    * are registered.
  206.    *
  207.    * @param {shaka.extern.ResponseFilter} filter
  208.    * @export
  209.    */
  210.   registerResponseFilter(filter) {
  211.     this.responseFilters_.add(filter);
  212.   }
  214.   /**
  215.    * Removes a response filter.
  216.    *
  217.    * @param {shaka.extern.ResponseFilter} filter
  218.    * @export
  219.    */
  220.   unregisterResponseFilter(filter) {
  221.     this.responseFilters_.delete(filter);
  222.   }
  224.   /**
  225.    * Clears all response filters.
  226.    *
  227.    * @export
  228.    */
  229.   clearAllResponseFilters() {
  230.     this.responseFilters_.clear();
  231.   }
  233.   /**
  234.    * Gets a copy of the default retry parameters.
  235.    *
  236.    * @return {shaka.extern.RetryParameters}
  237.    *
  238.    * NOTE: The implementation moved to shaka.net.Backoff to avoid a circular
  239.    * dependency between the two classes.
  240.    *
  241.    * @export
  242.    */
  243.   static defaultRetryParameters() {
  244.     return shaka.net.Backoff.defaultRetryParameters();
  245.   }
  247.   /**
  248.    * Makes a simple network request for the given URIs.
  249.    *
  250.    * @param {!Array.<string>} uris
  251.    * @param {shaka.extern.RetryParameters} retryParams
  252.    * @param {?function(BufferSource):!Promise=} streamDataCallback
  253.    * @return {shaka.extern.Request}
  254.    * @export
  255.    */
  256.   static makeRequest(uris, retryParams, streamDataCallback = null) {
  257.     return {
  258.       uris: uris,
  259.       method: 'GET',
  260.       body: null,
  261.       headers: {},
  262.       allowCrossSiteCredentials: false,
  263.       retryParameters: retryParams,
  264.       licenseRequestType: null,
  265.       sessionId: null,
  266.       drmInfo: null,
  267.       initData: null,
  268.       initDataType: null,
  269.       streamDataCallback: streamDataCallback,
  270.     };
  271.   }
  273.   /**
  274.    * @override
  275.    * @export
  276.    */
  277.   destroy() {
  278.     this.destroyed_ = true;
  279.     this.requestFilters_.clear();
  280.     this.responseFilters_.clear();
  282.     // FakeEventTarget implements IReleasable
  283.     super.release();
  285.     return this.operationManager_.destroy();
  286.   }
  288.   /**
  289.    * Makes a network request and returns the resulting data.
  290.    *
  291.    * @param {shaka.net.NetworkingEngine.RequestType} type
  292.    * @param {shaka.extern.Request} request
  293.    * @param {shaka.extern.RequestContext=} context
  294.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  295.    * @export
  296.    */
  297.   request(type, request, context) {
  298.     const ObjectUtils = shaka.util.ObjectUtils;
  299.     const numBytesRemainingObj =
  300.         new shaka.net.NetworkingEngine.NumBytesRemainingClass();
  302.     // Reject all requests made after destroy is called.
  303.     if (this.destroyed_) {
  304.       const p = Promise.reject(new shaka.util.Error(
  305.           shaka.util.Error.Severity.CRITICAL,
  306.           shaka.util.Error.Category.PLAYER,
  307.           shaka.util.Error.Code.OPERATION_ABORTED));
  308.       // Silence uncaught rejection errors, which may otherwise occur any place
  309.       // we don't explicitly handle aborted operations.
  310.       p.catch(() => {});
  311.       return new shaka.net.NetworkingEngine.PendingRequest(
  312.           p, () => Promise.resolve(), numBytesRemainingObj);
  313.     }
  315.     goog.asserts.assert(
  316.         request.uris && request.uris.length, 'Request without URIs!');
  318.     // If a request comes from outside the library, some parameters may be left
  319.     // undefined.  To make it easier for application developers, we will fill
  320.     // them in with defaults if necessary.
  321.     //
  322.     // We clone retryParameters and uris so that if a filter modifies the
  323.     // request, it doesn't contaminate future requests.
  324.     request.method = request.method || 'GET';
  325.     request.headers = request.headers || {};
  326.     request.retryParameters = request.retryParameters ?
  327.         ObjectUtils.cloneObject(request.retryParameters) :
  328.         shaka.net.NetworkingEngine.defaultRetryParameters();
  329.     request.uris = ObjectUtils.cloneObject(request.uris);
  331.     // Apply the registered filters to the request.
  332.     const requestFilterOperation = this.filterRequest_(type, request, context);
  333.     const requestOperation = requestFilterOperation.chain(
  334.         () => this.makeRequestWithRetry_(type, request, context,
  335.             numBytesRemainingObj));
  336.     const responseFilterOperation = requestOperation.chain(
  337.         (responseAndGotProgress) =>
  338.           this.filterResponse_(type, responseAndGotProgress, context));
  340.     // Keep track of time spent in filters.
  341.     const requestFilterStartTime = Date.now();
  342.     let requestFilterMs = 0;
  343.     requestFilterOperation.promise.then(() => {
  344.       requestFilterMs = Date.now() - requestFilterStartTime;
  345.     }, () => {});  // Silence errors in this fork of the Promise chain.
  347.     let responseFilterStartTime = 0;
  348.     requestOperation.promise.then(() => {
  349.       responseFilterStartTime = Date.now();
  350.     }, () => {});  // Silence errors in this fork of the Promise chain.
  352.     const op = responseFilterOperation.chain((responseAndGotProgress) => {
  353.       const responseFilterMs = Date.now() - responseFilterStartTime;
  354.       const response = responseAndGotProgress.response;
  355.       response.timeMs += requestFilterMs;
  356.       response.timeMs += responseFilterMs;
  357.       if (!responseAndGotProgress.gotProgress &&
  358.           this.onProgressUpdated_ &&
  359.           !response.fromCache &&
  360.           request.method != 'HEAD' &&
  361.           type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
  362.         const allowSwitch = this.allowSwitch_(context);
  363.         this.onProgressUpdated_(
  364.             response.timeMs, response.data.byteLength, allowSwitch);
  365.       }
  366.       if (this.onResponse_) {
  367.         this.onResponse_(type, response, context);
  368.       }
  369.       return response;
  370.     }, (e) => {
  371.       // Any error thrown from elsewhere should be recategorized as CRITICAL
  372.       // here.  This is because by the time it gets here, we've exhausted
  373.       // retries.
  374.       if (e) {
  375.         goog.asserts.assert(e instanceof shaka.util.Error, 'Wrong error type');
  376.         e.severity = shaka.util.Error.Severity.CRITICAL;
  377.       }
  379.       throw e;
  380.     });
  382.     // Return the pending request, which carries the response operation, and the
  383.     // number of bytes remaining to be downloaded, updated by the progress
  384.     // events.  Add the operation to the manager for later cleanup.
  385.     const pendingRequest =
  386.         new shaka.net.NetworkingEngine.PendingRequest(
  387.             op.promise, () => op.abort(), numBytesRemainingObj);
  388.     this.operationManager_.manage(pendingRequest);
  389.     return pendingRequest;
  390.   }
  392.   /**
  393.    * @param {shaka.net.NetworkingEngine.RequestType} type
  394.    * @param {shaka.extern.Request} request
  395.    * @param {shaka.extern.RequestContext=} context
  396.    * @return {!shaka.util.AbortableOperation.<undefined>}
  397.    * @private
  398.    */
  399.   filterRequest_(type, request, context) {
  400.     let filterOperation = shaka.util.AbortableOperation.completed(undefined);
  402.     const applyFilter = (requestFilter) => {
  403.       filterOperation = filterOperation.chain(() => {
  404.         if (request.body) {
  405.           // TODO: For v4.0 we should remove this or change to always pass a
  406.           // Uint8Array.  To make it easier for apps to write filters, it may be
  407.           // better to always pass a Uint8Array so they know what they are
  408.           // getting; but we shouldn't use ArrayBuffer since that would require
  409.           // copying buffers if this is a partial view.
  410.           request.body = shaka.util.BufferUtils.toArrayBuffer(request.body);
  411.         }
  412.         return requestFilter(type, request, context);
  413.       });
  414.     };
  416.     if (this.onRequest_) {
  417.       applyFilter(this.onRequest_);
  418.     }
  420.     for (const requestFilter of this.requestFilters_) {
  421.       // Request filters are run sequentially.
  422.       applyFilter(requestFilter);
  423.     }
  425.     // Catch any errors thrown by request filters, and substitute
  426.     // them with a Shaka-native error.
  427.     return filterOperation.chain(undefined, (e) => {
  428.       if (e instanceof shaka.util.Error &&
  429.           e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  430.         // Don't change anything if the operation was aborted.
  431.         throw e;
  432.       }
  434.       throw new shaka.util.Error(
  435.           shaka.util.Error.Severity.CRITICAL,
  436.           shaka.util.Error.Category.NETWORK,
  437.           shaka.util.Error.Code.REQUEST_FILTER_ERROR, e);
  438.     });
  439.   }
  441.   /**
  442.    * @param {shaka.net.NetworkingEngine.RequestType} type
  443.    * @param {shaka.extern.Request} request
  444.    * @param {(shaka.extern.RequestContext|undefined)} context
  445.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  446.    *            numBytesRemainingObj
  447.    * @return {!shaka.extern.IAbortableOperation.<
  448.    *            shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  449.    * @private
  450.    */
  451.   makeRequestWithRetry_(type, request, context, numBytesRemainingObj) {
  452.     const backoff = new shaka.net.Backoff(
  453.         request.retryParameters, /* autoReset= */ false);
  454.     const index = 0;
  455.     return this.send_(
  456.         type, request, context, backoff, index, /* lastError= */ null,
  457.         numBytesRemainingObj);
  458.   }
  460.   /**
  461.    * Sends the given request to the correct plugin and retry using Backoff.
  462.    *
  463.    * @param {shaka.net.NetworkingEngine.RequestType} type
  464.    * @param {shaka.extern.Request} request
  465.    * @param {(shaka.extern.RequestContext|undefined)} context
  466.    * @param {!shaka.net.Backoff} backoff
  467.    * @param {number} index
  468.    * @param {?shaka.util.Error} lastError
  469.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  470.    *     numBytesRemainingObj
  471.    * @return {!shaka.extern.IAbortableOperation.<
  472.    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  473.    * @private
  474.    */
  475.   send_(type, request, context, backoff, index, lastError,
  476.       numBytesRemainingObj) {
  477.     if (this.forceHTTP_) {
  478.       request.uris[index] = request.uris[index].replace('https://', 'http://');
  479.     }
  480.     if (this.forceHTTPS_) {
  481.       request.uris[index] = request.uris[index].replace('http://', 'https://');
  482.     }
  484.     if (index > 0 && this.onRetry_) {
  485.       const newUri = request.uris[index];
  486.       const oldUri = request.uris[index - 1];
  487.       this.onRetry_(type, context, newUri, oldUri);
  488.     }
  490.     const uri = new goog.Uri(request.uris[index]);
  491.     let scheme = uri.getScheme();
  492.     // Whether it got a progress event.
  493.     let gotProgress = false;
  494.     if (!scheme) {
  495.       // If there is no scheme, infer one from the location.
  496.       scheme = shaka.net.NetworkingEngine.getLocationProtocol_();
  497.       goog.asserts.assert(
  498.           scheme[scheme.length - 1] == ':',
  499.           'location.protocol expected to end with a colon!');
  500.       // Drop the colon.
  501.       scheme = scheme.slice(0, -1);
  503.       // Override the original URI to make the scheme explicit.
  504.       uri.setScheme(scheme);
  505.       request.uris[index] = uri.toString();
  506.     }
  508.     // Schemes are meant to be case-insensitive.
  509.     // See https://github.com/shaka-project/shaka-player/issues/2173
  510.     // and https://tools.ietf.org/html/rfc3986#section-3.1
  511.     scheme = scheme.toLowerCase();
  513.     const object = shaka.net.NetworkingEngine.schemes_[scheme];
  514.     const plugin = object ? object.plugin : null;
  515.     if (!plugin) {
  516.       return shaka.util.AbortableOperation.failed(
  517.           new shaka.util.Error(
  518.               shaka.util.Error.Severity.CRITICAL,
  519.               shaka.util.Error.Category.NETWORK,
  520.               shaka.util.Error.Code.UNSUPPORTED_SCHEME,
  521.               uri));
  522.     }
  523.     const progressSupport = object.progressSupport;
  526.     // Every attempt must have an associated backoff.attempt() call so that the
  527.     // accounting is correct.
  528.     const backoffOperation =
  529.         shaka.util.AbortableOperation.notAbortable(backoff.attempt());
  531.     /** @type {?shaka.util.Timer} */
  532.     let connectionTimer = null;
  534.     /** @type {?shaka.util.Timer} */
  535.     let stallTimer = null;
  537.     let aborted = false;
  539.     let headersReceivedCalled = false;
  541.     let startTimeMs;
  542.     const sendOperation = backoffOperation.chain(() => {
  543.       if (this.destroyed_) {
  544.         return shaka.util.AbortableOperation.aborted();
  545.       }
  547.       startTimeMs = Date.now();
  548.       const segment = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  549.       let packetNumber = 0;
  551.       const progressUpdated = (time, bytes, numBytesRemaining) => {
  552.         if (connectionTimer) {
  553.           connectionTimer.stop();
  554.         }
  555.         if (stallTimer) {
  556.           stallTimer.tickAfter(stallTimeoutMs / 1000);
  557.         }
  558.         if (this.onProgressUpdated_ && type == segment) {
  559.           packetNumber++;
  560.           request.packetNumber = packetNumber;
  561.           const allowSwitch = this.allowSwitch_(context);
  562.           this.onProgressUpdated_(time, bytes, allowSwitch, request);
  563.           gotProgress = true;
  564.           numBytesRemainingObj.setBytes(numBytesRemaining);
  565.         }
  566.       };
  567.       const headersReceived = (headers) => {
  568.         if (this.onHeadersReceived_) {
  569.           this.onHeadersReceived_(headers, request, type);
  570.         }
  571.         headersReceivedCalled = true;
  572.         request.timeToFirstByte = Date.now() -
  573.         /** @type {number} */ (request.requestStartTime);
  574.       };
  575.       request.requestStartTime = Date.now();
  577.       const requestPlugin = plugin(
  578.           request.uris[index], request, type, progressUpdated, headersReceived);
  580.       if (!progressSupport) {
  581.         return requestPlugin;
  582.       }
  584.       const connectionTimeoutMs = request.retryParameters.connectionTimeout;
  585.       if (connectionTimeoutMs) {
  586.         connectionTimer = new shaka.util.Timer(() => {
  587.           aborted = true;
  588.           requestPlugin.abort();
  589.         });
  591.         connectionTimer.tickAfter(connectionTimeoutMs / 1000);
  592.       }
  594.       const stallTimeoutMs = request.retryParameters.stallTimeout;
  595.       if (stallTimeoutMs) {
  596.         stallTimer = new shaka.util.Timer(() => {
  597.           aborted = true;
  598.           requestPlugin.abort();
  599.         });
  600.       }
  602.       return requestPlugin;
  603.     }).chain((response) => {
  604.       if (connectionTimer) {
  605.         connectionTimer.stop();
  606.       }
  607.       if (stallTimer) {
  608.         stallTimer.stop();
  609.       }
  610.       if (response.timeMs == undefined) {
  611.         response.timeMs = Date.now() - startTimeMs;
  612.       }
  613.       const responseAndGotProgress = {
  614.         response: response,
  615.         gotProgress: gotProgress,
  616.       };
  617.       if (!headersReceivedCalled) {
  618.         // The plugin did not call headersReceived, perhaps because it is not
  619.         // able to track that information. So, fire the event manually.
  620.         if (this.onHeadersReceived_) {
  621.           this.onHeadersReceived_(response.headers, request, type);
  622.         }
  623.       }
  625.       return responseAndGotProgress;
  626.     }, (error) => {
  627.       if (connectionTimer) {
  628.         connectionTimer.stop();
  629.       }
  630.       if (stallTimer) {
  631.         stallTimer.stop();
  632.       }
  633.       if (this.onDownloadFailed_) {
  634.         let shakaError = null;
  635.         let httpResponseCode = 0;
  636.         if (error instanceof shaka.util.Error) {
  637.           shakaError = error;
  638.           if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
  639.             httpResponseCode = /** @type {number} */ (error.data[1]);
  640.           }
  641.         }
  642.         this.onDownloadFailed_(request, shakaError, httpResponseCode, aborted);
  643.       }
  644.       if (this.destroyed_) {
  645.         return shaka.util.AbortableOperation.aborted();
  646.       }
  648.       if (aborted) {
  649.         // It is necessary to change the error code to the correct one because
  650.         // otherwise the retry logic would not work.
  651.         error = new shaka.util.Error(
  652.             shaka.util.Error.Severity.RECOVERABLE,
  653.             shaka.util.Error.Category.NETWORK,
  654.             shaka.util.Error.Code.TIMEOUT,
  655.             request.uris[index], type);
  656.       }
  658.       if (error instanceof shaka.util.Error) {
  659.         if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  660.           // Don't change anything if the operation was aborted.
  661.           throw error;
  662.         } else if (error.code == shaka.util.Error.Code.ATTEMPTS_EXHAUSTED) {
  663.           goog.asserts.assert(lastError, 'Should have last error');
  664.           throw lastError;
  665.         }
  667.         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
  668.           const data = (new Map()).set('error', error);
  669.           const event = new shaka.util.FakeEvent('retry', data);
  670.           this.dispatchEvent(event);
  672.           // Move to the next URI.
  673.           index = (index + 1) % request.uris.length;
  674.           return this.send_(
  675.               type, request, context, backoff, index, error,
  676.               numBytesRemainingObj);
  677.         }
  678.       }
  680.       // The error was not recoverable, so do not try again.
  681.       throw error;
  682.     });
  684.     return sendOperation;
  685.   }
  687.   /**
  688.    * @param {shaka.net.NetworkingEngine.RequestType} type
  689.    * @param {shaka.net.NetworkingEngine.ResponseAndGotProgress}
  690.    *        responseAndGotProgress
  691.    * @param {shaka.extern.RequestContext=} context
  692.    * @return {!shaka.extern.IAbortableOperation.<
  693.    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  694.    * @private
  695.    */
  696.   filterResponse_(type, responseAndGotProgress, context) {
  697.     let filterOperation = shaka.util.AbortableOperation.completed(undefined);
  698.     for (const responseFilter of this.responseFilters_) {
  699.       // Response filters are run sequentially.
  700.       filterOperation = filterOperation.chain(() => {
  701.         const resp = responseAndGotProgress.response;
  702.         if (resp.data) {
  703.           // TODO: See TODO in filterRequest_.
  704.           resp.data = shaka.util.BufferUtils.toArrayBuffer(resp.data);
  705.         }
  706.         return responseFilter(type, resp, context);
  707.       });
  708.     }
  709.     // If successful, return the filtered response with whether it got
  710.     // progress.
  711.     return filterOperation.chain(() => {
  712.       return responseAndGotProgress;
  713.     }, (e) => {
  714.       // Catch any errors thrown by request filters, and substitute
  715.       // them with a Shaka-native error.
  717.       // The error is assumed to be critical if the original wasn't a Shaka
  718.       // error.
  719.       let severity = shaka.util.Error.Severity.CRITICAL;
  720.       if (e instanceof shaka.util.Error) {
  721.         if (e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  722.           // Don't change anything if the operation was aborted.
  723.           throw e;
  724.         }
  726.         severity = e.severity;
  727.       }
  729.       throw new shaka.util.Error(
  730.           severity,
  731.           shaka.util.Error.Category.NETWORK,
  732.           shaka.util.Error.Code.RESPONSE_FILTER_ERROR, e);
  733.     });
  734.   }
  736.   /**
  737.    * @param {(shaka.extern.RequestContext|undefined)} context
  738.    * @return {boolean}
  739.    * @private
  740.    */
  741.   allowSwitch_(context) {
  742.     if (context) {
  743.       const segment = context.segment;
  744.       const stream = context.stream;
  745.       if (segment && stream && stream.fastSwitching) {
  746.         if (segment.isPartial()) {
  747.           return false;
  748.         }
  749.       }
  750.     }
  751.     return true;
  752.   }
  754.   /**
  755.    * This is here only for testability.  We can't mock location in our tests on
  756.    * all browsers, so instead we mock this.
  757.    *
  758.    * @return {string} The value of location.protocol.
  759.    * @private
  760.    */
  761.   static getLocationProtocol_() {
  762.     return location.protocol;
  763.   }
  764. };
  766. /**
  767.  * A wrapper class for the number of bytes remaining to be downloaded for the
  768.  * request.
  769.  * Instead of using PendingRequest directly, this class is needed to be sent to
  770.  * plugin as a parameter, and a Promise is returned, before PendingRequest is
  771.  * created.
  772.  *
  773.  * @export
  774.  */
  775. shaka.net.NetworkingEngine.NumBytesRemainingClass = class {
  776.   /**
  777.    * Constructor
  778.    */
  779.   constructor() {
  780.     /** @private {number} */
  781.     this.bytesToLoad_ = 0;
  782.   }
  784.   /**
  785.    * @param {number} bytesToLoad
  786.    */
  787.   setBytes(bytesToLoad) {
  788.     this.bytesToLoad_ = bytesToLoad;
  789.   }
  791.   /**
  792.    * @return {number}
  793.    */
  794.   getBytes() {
  795.     return this.bytesToLoad_;
  796.   }
  797. };
  799. /**
  800.  * A pending network request. This can track the current progress of the
  801.  * download, and allows the request to be aborted if the network is slow.
  802.  *
  803.  * @implements {shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  804.  * @extends {shaka.util.AbortableOperation}
  805.  * @export
  806.  */
  807. shaka.net.NetworkingEngine.PendingRequest =
  808. class extends shaka.util.AbortableOperation {
  809.   /**
  810.    * @param {!Promise} promise
  811.    *   A Promise which represents the underlying operation.  It is resolved
  812.    *   when the operation is complete, and rejected if the operation fails or
  813.    *   is aborted.  Aborted operations should be rejected with a
  814.    *   shaka.util.Error object using the error code OPERATION_ABORTED.
  815.    * @param {function():!Promise} onAbort
  816.    *   Will be called by this object to abort the underlying operation.  This
  817.    *   is not cancelation, and will not necessarily result in any work being
  818.    *   undone.  abort() should return a Promise which is resolved when the
  819.    *   underlying operation has been aborted.  The returned Promise should
  820.    *   never be rejected.
  821.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  822.    *   numBytesRemainingObj
  823.    */
  824.   constructor(promise, onAbort, numBytesRemainingObj) {
  825.     super(promise, onAbort);
  827.     /** @private {shaka.net.NetworkingEngine.NumBytesRemainingClass} */
  828.     this.bytesRemaining_ = numBytesRemainingObj;
  829.   }
  831.   /**
  832.    * @return {number}
  833.    */
  834.   getBytesRemaining() {
  835.     return this.bytesRemaining_.getBytes();
  836.   }
  837. };
  839. /**
  840.  * Request types.  Allows a filter to decide which requests to read/alter.
  841.  *
  842.  * @enum {number}
  843.  * @export
  844.  */
  845. shaka.net.NetworkingEngine.RequestType = {
  846.   'MANIFEST': 0,
  847.   'SEGMENT': 1,
  848.   'LICENSE': 2,
  849.   'APP': 3,
  850.   'TIMING': 4,
  851.   'SERVER_CERTIFICATE': 5,
  852.   'KEY': 6,
  853.   'ADS': 7,
  854.   'CONTENT_STEERING': 8,
  855. };
  857. /**
  858.  * A more advanced form of the RequestType structure, meant to describe
  859.  * sub-types of basic request types.
  860.  * For example, an INIT_SEGMENT is a sub-type of SEGMENT.
  861.  * This is meant to allow for more specificity to be added to the request type
  862.  * data, without breaking backwards compatibility.
  863.  *
  864.  * @enum {number}
  865.  * @export
  866.  */
  867. shaka.net.NetworkingEngine.AdvancedRequestType = {
  868.   'INIT_SEGMENT': 0,
  869.   'MEDIA_SEGMENT': 1,
  870.   'MEDIA_PLAYLIST': 2,
  871.   'MASTER_PLAYLIST': 3,
  872.   'MPD': 4,
  873.   'MSS': 5,
  874. };
  877. /**
  878.  * Priority level for network scheme plugins.
  879.  * If multiple plugins are provided for the same scheme, only the
  880.  * highest-priority one is used.
  881.  *
  882.  * @enum {number}
  883.  * @export
  884.  */
  885. shaka.net.NetworkingEngine.PluginPriority = {
  886.   'FALLBACK': 1,
  887.   'PREFERRED': 2,
  888.   'APPLICATION': 3,
  889. };
  892. /**
  893.  * @typedef {{
  894.  *   plugin: shaka.extern.SchemePlugin,
  895.  *   priority: number,
  896.  *   progressSupport: boolean
  897.  * }}
  898.  * @property {shaka.extern.SchemePlugin} plugin
  899.  *   The associated plugin.
  900.  * @property {number} priority
  901.  *   The plugin's priority.
  902.  * @property {boolean} progressSupport
  903.  *   The plugin's supports progress events
  904.  */
  905. shaka.net.NetworkingEngine.SchemeObject;
  908. /**
  909.  * Contains the scheme plugins.
  910.  *
  911.  * @private {!Object.<string, shaka.net.NetworkingEngine.SchemeObject>}
  912.  */
  913. shaka.net.NetworkingEngine.schemes_ = {};
  915. /**
  916.  * @typedef {{
  917.  *   response: shaka.extern.Response,
  918.  *   gotProgress: boolean
  919.  * }}
  920.  *
  921.  * @description
  922.  * Defines a response wrapper object, including the response object and whether
  923.  * progress event is fired by the scheme plugin.
  924.  *
  925.  * @property {shaka.extern.Response} response
  926.  * @property {boolean} gotProgress
  927.  * @private
  928.  */
  929. shaka.net.NetworkingEngine.ResponseAndGotProgress;
  932. /**
  933.  * @typedef {function(
  934.  *    !Object.<string, string>,
  935.  *    !shaka.extern.Request,
  936.  *    !shaka.net.NetworkingEngine.RequestType)}
  937.  *
  938.  * @description
  939.  * A callback function that passes the shaka.extern.HeadersReceived along to
  940.  * the player, plus some extra data.
  941.  * @export
  942.  */
  943. shaka.net.NetworkingEngine.OnHeadersReceived;
  945. /**
  946.  * @typedef {function(
  947.  *    number,
  948.  *    number,
  949.  *    boolean,
  950.  *    shaka.extern.Request=)}
  951.  *
  952.  * @description
  953.  * A callback that is passed the duration, in milliseconds,
  954.  * that the request took, the number of bytes transferred, a boolean
  955.  * representing whether the switching is allowed and a ref to the
  956.  * original request.
  957.  * @export
  958.  */
  959. shaka.net.NetworkingEngine.onProgressUpdated;
  961. /**
  962.  * @typedef {function(
  963.  *    !shaka.extern.Request,
  964.  *    ?shaka.util.Error,
  965.  *    number,
  966.  *    boolean)}
  967.  *
  968.  * @description
  969.  * A callback function that notifies the player when a download fails, for any
  970.  * reason (e.g. even if the download was aborted).
  971.  * @export
  972.  */
  973. shaka.net.NetworkingEngine.OnDownloadFailed;
  976. /**
  977.  * @typedef {function(
  978.  *    !shaka.net.NetworkingEngine.RequestType,
  979.  *    !shaka.extern.Request,
  980.  *    (shaka.extern.RequestContext|undefined))}
  981.  *
  982.  * @description
  983.  * A callback function called on every request
  984.  * @export
  985.  */
  986. shaka.net.NetworkingEngine.OnRequest;
  989. /**
  990.  * @typedef {function(
  991.  *    !shaka.net.NetworkingEngine.RequestType,
  992.  *    (shaka.extern.RequestContext|undefined),
  993.  *    string,
  994.  *    string)}
  995.  *
  996.  * @description
  997.  * A callback function called on every request retry. The first string is the
  998.  * new URI and the second string is the old URI.
  999.  * @export
  1000.  */
  1001. shaka.net.NetworkingEngine.OnRetry;
  1004. /**
  1005.  * @typedef {function(
  1006.  *    !shaka.net.NetworkingEngine.RequestType,
  1007.  *    !shaka.extern.Response,
  1008.  *    (shaka.extern.RequestContext|undefined))}
  1009.  *
  1010.  * @description
  1011.  * A callback function called on every request
  1012.  * @export
  1013.  */
  1014. shaka.net.NetworkingEngine.OnResponse;