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