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.RequestType');
  9. goog.provide('shaka.net.NetworkingEngine.PendingRequest');
  11. goog.require('goog.Uri');
  12. goog.require('goog.asserts');
  13. goog.require('shaka.net.Backoff');
  14. goog.require('shaka.util.AbortableOperation');
  15. goog.require('shaka.util.BufferUtils');
  16. goog.require('shaka.util.Error');
  17. goog.require('shaka.util.FakeEvent');
  18. goog.require('shaka.util.FakeEventTarget');
  19. goog.require('shaka.util.IDestroyable');
  20. goog.require('shaka.util.ObjectUtils');
  21. goog.require('shaka.util.OperationManager');
  22. goog.require('shaka.util.Timer');
  25. /**
  26.  * @event shaka.net.NetworkingEngine.RetryEvent
  27.  * @description Fired when the networking engine receives a recoverable error
  28.  *   and retries.
  29.  * @property {string} type
  30.  *   'retry'
  31.  * @property {?shaka.util.Error} error
  32.  *   The error that caused the retry. If it was a non-Shaka error, this is set
  33.  *   to null.
  34.  * @exportDoc
  35.  */
  38. /**
  39.  * NetworkingEngine wraps all networking operations.  This accepts plugins that
  40.  * handle the actual request.  A plugin is registered using registerScheme.
  41.  * Each scheme has at most one plugin to handle the request.
  42.  *
  43.  * @implements {shaka.util.IDestroyable}
  44.  * @export
  45.  */
  46. shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
  47.   /**
  48.    * @param {function(number, number)=} onProgressUpdated Called when a progress
  49.    *   event is triggered. Passed the duration, in milliseconds, that the
  50.    *   request took, and the number of bytes transferred.
  51.    * @param {shaka.net.NetworkingEngine.OnHeadersReceived=} onHeadersReceived
  52.    *   Called when the headers are received for a download.
  53.    * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
  54.    *   Called when a download fails, for any reason.
  55.    */
  56.   constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed) {
  57.     super();
  59.     /** @private {boolean} */
  60.     this.destroyed_ = false;
  62.     /** @private {!shaka.util.OperationManager} */
  63.     this.operationManager_ = new shaka.util.OperationManager();
  65.     /** @private {!Set.<shaka.extern.RequestFilter>} */
  66.     this.requestFilters_ = new Set();
  68.     /** @private {!Set.<shaka.extern.ResponseFilter>} */
  69.     this.responseFilters_ = new Set();
  71.     /** @private {?function(number, number)} */
  72.     this.onProgressUpdated_ = onProgressUpdated || null;
  74.     /** @private {?shaka.net.NetworkingEngine.OnHeadersReceived} */
  75.     this.onHeadersReceived_ = onHeadersReceived || null;
  77.     /** @private {?shaka.net.NetworkingEngine.OnDownloadFailed} */
  78.     this.onDownloadFailed_ = onDownloadFailed || null;
  80.     /** @private {boolean} */
  81.     this.forceHTTPS_ = false;
  82.   }
  84.   /**
  85.    * @param {boolean} forceHTTPS
  86.    * @export
  87.    */
  88.   setForceHTTPS(forceHTTPS) {
  89.     this.forceHTTPS_ = forceHTTPS;
  90.   }
  92.   /**
  93.    * Registers a scheme plugin.  This plugin will handle all requests with the
  94.    * given scheme.  If a plugin with the same scheme already exists, it is
  95.    * replaced, unless the existing plugin is of higher priority.
  96.    * If no priority is provided, this defaults to the highest priority of
  97.    * APPLICATION.
  98.    *
  99.    * @param {string} scheme
  100.    * @param {shaka.extern.SchemePlugin} plugin
  101.    * @param {number=} priority
  102.    * @param {boolean=} progressSupport
  103.    * @export
  104.    */
  105.   static registerScheme(scheme, plugin, priority, progressSupport = false) {
  106.     goog.asserts.assert(
  107.         priority == undefined || priority > 0, 'explicit priority must be > 0');
  108.     priority =
  109.         priority || shaka.net.NetworkingEngine.PluginPriority.APPLICATION;
  110.     const existing = shaka.net.NetworkingEngine.schemes_[scheme];
  111.     if (!existing || priority >= existing.priority) {
  112.       shaka.net.NetworkingEngine.schemes_[scheme] = {
  113.         priority: priority,
  114.         plugin: plugin,
  115.         progressSupport: progressSupport,
  116.       };
  117.     }
  118.   }
  120.   /**
  121.    * Removes a scheme plugin.
  122.    *
  123.    * @param {string} scheme
  124.    * @export
  125.    */
  126.   static unregisterScheme(scheme) {
  127.     delete shaka.net.NetworkingEngine.schemes_[scheme];
  128.   }
  130.   /**
  131.    * Registers a new request filter.  All filters are applied in the order they
  132.    * are registered.
  133.    *
  134.    * @param {shaka.extern.RequestFilter} filter
  135.    * @export
  136.    */
  137.   registerRequestFilter(filter) {
  138.     this.requestFilters_.add(filter);
  139.   }
  141.   /**
  142.    * Removes a request filter.
  143.    *
  144.    * @param {shaka.extern.RequestFilter} filter
  145.    * @export
  146.    */
  147.   unregisterRequestFilter(filter) {
  148.     this.requestFilters_.delete(filter);
  149.   }
  151.   /**
  152.    * Clears all request filters.
  153.    *
  154.    * @export
  155.    */
  156.   clearAllRequestFilters() {
  157.     this.requestFilters_.clear();
  158.   }
  160.   /**
  161.    * Registers a new response filter.  All filters are applied in the order they
  162.    * are registered.
  163.    *
  164.    * @param {shaka.extern.ResponseFilter} filter
  165.    * @export
  166.    */
  167.   registerResponseFilter(filter) {
  168.     this.responseFilters_.add(filter);
  169.   }
  171.   /**
  172.    * Removes a response filter.
  173.    *
  174.    * @param {shaka.extern.ResponseFilter} filter
  175.    * @export
  176.    */
  177.   unregisterResponseFilter(filter) {
  178.     this.responseFilters_.delete(filter);
  179.   }
  181.   /**
  182.    * Clears all response filters.
  183.    *
  184.    * @export
  185.    */
  186.   clearAllResponseFilters() {
  187.     this.responseFilters_.clear();
  188.   }
  190.   /**
  191.    * Gets a copy of the default retry parameters.
  192.    *
  193.    * @return {shaka.extern.RetryParameters}
  194.    *
  195.    * NOTE: The implementation moved to shaka.net.Backoff to avoid a circular
  196.    * dependency between the two classes.
  197.    *
  198.    * @export
  199.    */
  200.   static defaultRetryParameters() {
  201.     return shaka.net.Backoff.defaultRetryParameters();
  202.   }
  204.   /**
  205.    * Makes a simple network request for the given URIs.
  206.    *
  207.    * @param {!Array.<string>} uris
  208.    * @param {shaka.extern.RetryParameters} retryParams
  209.    * @param {?function(BufferSource):!Promise=} streamDataCallback
  210.    * @return {shaka.extern.Request}
  211.    * @export
  212.    */
  213.   static makeRequest(uris, retryParams, streamDataCallback = null) {
  214.     return {
  215.       uris: uris,
  216.       method: 'GET',
  217.       body: null,
  218.       headers: {},
  219.       allowCrossSiteCredentials: false,
  220.       retryParameters: retryParams,
  221.       licenseRequestType: null,
  222.       sessionId: null,
  223.       streamDataCallback: streamDataCallback,
  224.     };
  225.   }
  227.   /**
  228.    * @override
  229.    * @export
  230.    */
  231.   destroy() {
  232.     this.destroyed_ = true;
  233.     this.requestFilters_.clear();
  234.     this.responseFilters_.clear();
  236.     // FakeEventTarget implements IReleasable
  237.     super.release();
  239.     return this.operationManager_.destroy();
  240.   }
  242.   /**
  243.    * Makes a network request and returns the resulting data.
  244.    *
  245.    * @param {shaka.net.NetworkingEngine.RequestType} type
  246.    * @param {shaka.extern.Request} request
  247.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  248.    * @export
  249.    */
  250.   request(type, request) {
  251.     const ObjectUtils = shaka.util.ObjectUtils;
  252.     const numBytesRemainingObj =
  253.         new shaka.net.NetworkingEngine.NumBytesRemainingClass();
  255.     // Reject all requests made after destroy is called.
  256.     if (this.destroyed_) {
  257.       const p = Promise.reject(new shaka.util.Error(
  258.           shaka.util.Error.Severity.CRITICAL,
  259.           shaka.util.Error.Category.PLAYER,
  260.           shaka.util.Error.Code.OPERATION_ABORTED));
  261.       // Silence uncaught rejection errors, which may otherwise occur any place
  262.       // we don't explicitly handle aborted operations.
  263.       p.catch(() => {});
  264.       return new shaka.net.NetworkingEngine.PendingRequest(
  265.           p, () => Promise.resolve(), numBytesRemainingObj);
  266.     }
  268.     goog.asserts.assert(
  269.         request.uris && request.uris.length, 'Request without URIs!');
  271.     // If a request comes from outside the library, some parameters may be left
  272.     // undefined.  To make it easier for application developers, we will fill
  273.     // them in with defaults if necessary.
  274.     //
  275.     // We clone retryParameters and uris so that if a filter modifies the
  276.     // request, it doesn't contaminate future requests.
  277.     request.method = request.method || 'GET';
  278.     request.headers = request.headers || {};
  279.     request.retryParameters = request.retryParameters ?
  280.         ObjectUtils.cloneObject(request.retryParameters) :
  281.         shaka.net.NetworkingEngine.defaultRetryParameters();
  282.     request.uris = ObjectUtils.cloneObject(request.uris);
  284.     // Apply the registered filters to the request.
  285.     const requestFilterOperation = this.filterRequest_(type, request);
  286.     const requestOperation = requestFilterOperation.chain(
  287.         () => this.makeRequestWithRetry_(type, request, numBytesRemainingObj));
  288.     const responseFilterOperation = requestOperation.chain(
  289.         (responseAndGotProgress) =>
  290.           this.filterResponse_(type, responseAndGotProgress));
  292.     // Keep track of time spent in filters.
  293.     const requestFilterStartTime = Date.now();
  294.     let requestFilterMs = 0;
  295.     requestFilterOperation.promise.then(() => {
  296.       requestFilterMs = Date.now() - requestFilterStartTime;
  297.     }, () => {});  // Silence errors in this fork of the Promise chain.
  299.     let responseFilterStartTime = 0;
  300.     requestOperation.promise.then(() => {
  301.       responseFilterStartTime = Date.now();
  302.     }, () => {});  // Silence errors in this fork of the Promise chain.
  304.     const op = responseFilterOperation.chain((responseAndGotProgress) => {
  305.       const responseFilterMs = Date.now() - responseFilterStartTime;
  306.       const response = responseAndGotProgress.response;
  307.       response.timeMs += requestFilterMs;
  308.       response.timeMs += responseFilterMs;
  309.       if (!responseAndGotProgress.gotProgress &&
  310.           this.onProgressUpdated_ &&
  311.           !response.fromCache &&
  312.           request.method != 'HEAD' &&
  313.           type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
  314.         this.onProgressUpdated_(response.timeMs, response.data.byteLength);
  315.       }
  316.       return response;
  317.     }, (e) => {
  318.       // Any error thrown from elsewhere should be recategorized as CRITICAL
  319.       // here.  This is because by the time it gets here, we've exhausted
  320.       // retries.
  321.       if (e) {
  322.         goog.asserts.assert(e instanceof shaka.util.Error, 'Wrong error type');
  323.         e.severity = shaka.util.Error.Severity.CRITICAL;
  324.       }
  326.       throw e;
  327.     });
  329.     // Return the pending request, which carries the response operation, and the
  330.     // number of bytes remaining to be downloaded, updated by the progress
  331.     // events.  Add the operation to the manager for later cleanup.
  332.     const pendingRequest =
  333.         new shaka.net.NetworkingEngine.PendingRequest(
  334.             op.promise, () => op.abort(), numBytesRemainingObj);
  335.     this.operationManager_.manage(pendingRequest);
  336.     return pendingRequest;
  337.   }
  339.   /**
  340.    * @param {shaka.net.NetworkingEngine.RequestType} type
  341.    * @param {shaka.extern.Request} request
  342.    * @return {!shaka.util.AbortableOperation.<undefined>}
  343.    * @private
  344.    */
  345.   filterRequest_(type, request) {
  346.     let filterOperation = shaka.util.AbortableOperation.completed(undefined);
  348.     for (const requestFilter of this.requestFilters_) {
  349.       // Request filters are run sequentially.
  350.       filterOperation = filterOperation.chain(() => {
  351.         if (request.body) {
  352.           // TODO: For v4.0 we should remove this or change to always pass a
  353.           // Uint8Array.  To make it easier for apps to write filters, it may be
  354.           // better to always pass a Uint8Array so they know what they are
  355.           // getting; but we shouldn't use ArrayBuffer since that would require
  356.           // copying buffers if this is a partial view.
  357.           request.body = shaka.util.BufferUtils.toArrayBuffer(request.body);
  358.         }
  359.         return requestFilter(type, request);
  360.       });
  361.     }
  363.     // Catch any errors thrown by request filters, and substitute
  364.     // them with a Shaka-native error.
  365.     return filterOperation.chain(undefined, (e) => {
  366.       if (e instanceof shaka.util.Error &&
  367.           e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  368.         // Don't change anything if the operation was aborted.
  369.         throw e;
  370.       }
  372.       throw new shaka.util.Error(
  373.           shaka.util.Error.Severity.CRITICAL,
  374.           shaka.util.Error.Category.NETWORK,
  375.           shaka.util.Error.Code.REQUEST_FILTER_ERROR, e);
  376.     });
  377.   }
  379.   /**
  380.    * @param {shaka.net.NetworkingEngine.RequestType} type
  381.    * @param {shaka.extern.Request} request
  382.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  383.    *            numBytesRemainingObj
  384.    * @return {!shaka.extern.IAbortableOperation.<
  385.    *            shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  386.    * @private
  387.    */
  388.   makeRequestWithRetry_(type, request, numBytesRemainingObj) {
  389.     const backoff = new shaka.net.Backoff(
  390.         request.retryParameters, /* autoReset= */ false);
  391.     const index = 0;
  392.     return this.send_(
  393.         type, request, backoff, index, /* lastError= */ null,
  394.         numBytesRemainingObj);
  395.   }
  397.   /**
  398.    * Sends the given request to the correct plugin and retry using Backoff.
  399.    *
  400.    * @param {shaka.net.NetworkingEngine.RequestType} type
  401.    * @param {shaka.extern.Request} request
  402.    * @param {!shaka.net.Backoff} backoff
  403.    * @param {number} index
  404.    * @param {?shaka.util.Error} lastError
  405.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  406.    *     numBytesRemainingObj
  407.    * @return {!shaka.extern.IAbortableOperation.<
  408.    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  409.    * @private
  410.    */
  411.   send_(type, request, backoff, index, lastError, numBytesRemainingObj) {
  412.     if (this.forceHTTPS_) {
  413.       request.uris[index] = request.uris[index].replace('http://', 'https://');
  414.     }
  416.     const uri = new goog.Uri(request.uris[index]);
  417.     let scheme = uri.getScheme();
  418.     // Whether it got a progress event.
  419.     let gotProgress = false;
  420.     if (!scheme) {
  421.       // If there is no scheme, infer one from the location.
  422.       scheme = shaka.net.NetworkingEngine.getLocationProtocol_();
  423.       goog.asserts.assert(
  424.           scheme[scheme.length - 1] == ':',
  425.           'location.protocol expected to end with a colon!');
  426.       // Drop the colon.
  427.       scheme = scheme.slice(0, -1);
  429.       // Override the original URI to make the scheme explicit.
  430.       uri.setScheme(scheme);
  431.       request.uris[index] = uri.toString();
  432.     }
  434.     // Schemes are meant to be case-insensitive.
  435.     // See https://github.com/shaka-project/shaka-player/issues/2173
  436.     // and https://tools.ietf.org/html/rfc3986#section-3.1
  437.     scheme = scheme.toLowerCase();
  439.     const object = shaka.net.NetworkingEngine.schemes_[scheme];
  440.     const plugin = object ? object.plugin : null;
  441.     if (!plugin) {
  442.       return shaka.util.AbortableOperation.failed(
  443.           new shaka.util.Error(
  444.               shaka.util.Error.Severity.CRITICAL,
  445.               shaka.util.Error.Category.NETWORK,
  446.               shaka.util.Error.Code.UNSUPPORTED_SCHEME,
  447.               uri));
  448.     }
  449.     const progressSupport = object.progressSupport;
  452.     // Every attempt must have an associated backoff.attempt() call so that the
  453.     // accounting is correct.
  454.     const backoffOperation =
  455.         shaka.util.AbortableOperation.notAbortable(backoff.attempt());
  457.     /** @type {?shaka.util.Timer} */
  458.     let connectionTimer = null;
  460.     /** @type {?shaka.util.Timer} */
  461.     let stallTimer = null;
  463.     let aborted = false;
  465.     let headersReceivedCalled = false;
  467.     let startTimeMs;
  468.     const sendOperation = backoffOperation.chain(() => {
  469.       if (this.destroyed_) {
  470.         return shaka.util.AbortableOperation.aborted();
  471.       }
  473.       startTimeMs = Date.now();
  474.       const segment = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  476.       const progressUpdated = (time, bytes, numBytesRemaining) => {
  477.         if (connectionTimer) {
  478.           connectionTimer.stop();
  479.         }
  480.         if (stallTimer) {
  481.           stallTimer.tickAfter(stallTimeoutMs / 1000);
  482.         }
  483.         if (this.onProgressUpdated_ && type == segment) {
  484.           this.onProgressUpdated_(time, bytes);
  485.           gotProgress = true;
  486.           numBytesRemainingObj.setBytes(numBytesRemaining);
  487.         }
  488.       };
  489.       const headersReceived = (headers) => {
  490.         if (this.onHeadersReceived_) {
  491.           this.onHeadersReceived_(headers, request, type);
  492.         }
  493.         headersReceivedCalled = true;
  494.       };
  495.       const requestPlugin = plugin(
  496.           request.uris[index], request, type, progressUpdated, headersReceived);
  498.       if (!progressSupport) {
  499.         return requestPlugin;
  500.       }
  502.       const connectionTimeoutMs = request.retryParameters.connectionTimeout;
  503.       if (connectionTimeoutMs) {
  504.         connectionTimer = new shaka.util.Timer(() => {
  505.           aborted = true;
  506.           requestPlugin.abort();
  507.         });
  509.         connectionTimer.tickAfter(connectionTimeoutMs / 1000);
  510.       }
  512.       const stallTimeoutMs = request.retryParameters.stallTimeout;
  513.       if (stallTimeoutMs) {
  514.         stallTimer = new shaka.util.Timer(() => {
  515.           aborted = true;
  516.           requestPlugin.abort();
  517.         });
  518.       }
  520.       return requestPlugin;
  521.     }).chain((response) => {
  522.       if (connectionTimer) {
  523.         connectionTimer.stop();
  524.       }
  525.       if (stallTimer) {
  526.         stallTimer.stop();
  527.       }
  528.       if (response.timeMs == undefined) {
  529.         response.timeMs = Date.now() - startTimeMs;
  530.       }
  531.       const responseAndGotProgress = {
  532.         response: response,
  533.         gotProgress: gotProgress,
  534.       };
  535.       if (!headersReceivedCalled) {
  536.         // The plugin did not call headersReceived, perhaps because it is not
  537.         // able to track that information. So, fire the event manually.
  538.         if (this.onHeadersReceived_) {
  539.           this.onHeadersReceived_(response.headers, request, type);
  540.         }
  541.       }
  543.       return responseAndGotProgress;
  544.     }, (error) => {
  545.       if (connectionTimer) {
  546.         connectionTimer.stop();
  547.       }
  548.       if (stallTimer) {
  549.         stallTimer.stop();
  550.       }
  551.       if (this.onDownloadFailed_) {
  552.         let shakaError = null;
  553.         let httpResponseCode = 0;
  554.         if (error instanceof shaka.util.Error) {
  555.           shakaError = error;
  556.           if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
  557.             httpResponseCode = /** @type {number} */ (error.data[1]);
  558.           }
  559.         }
  560.         this.onDownloadFailed_(request, shakaError, httpResponseCode, aborted);
  561.       }
  562.       if (this.destroyed_) {
  563.         return shaka.util.AbortableOperation.aborted();
  564.       }
  566.       if (aborted) {
  567.         // It is necessary to change the error code to the correct one because
  568.         // otherwise the retry logic would not work.
  569.         error = new shaka.util.Error(
  570.             shaka.util.Error.Severity.RECOVERABLE,
  571.             shaka.util.Error.Category.NETWORK,
  572.             shaka.util.Error.Code.TIMEOUT,
  573.             request.uris[index], type);
  574.       }
  576.       if (error instanceof shaka.util.Error) {
  577.         if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  578.           // Don't change anything if the operation was aborted.
  579.           throw error;
  580.         } else if (error.code == shaka.util.Error.Code.ATTEMPTS_EXHAUSTED) {
  581.           goog.asserts.assert(lastError, 'Should have last error');
  582.           throw lastError;
  583.         }
  585.         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
  586.           const data = (new Map()).set('error', error);
  587.           const event = new shaka.util.FakeEvent('retry', data);
  588.           this.dispatchEvent(event);
  590.           // Move to the next URI.
  591.           index = (index + 1) % request.uris.length;
  592.           return this.send_(
  593.               type, request, backoff, index, error, numBytesRemainingObj);
  594.         }
  595.       }
  597.       // The error was not recoverable, so do not try again.
  598.       throw error;
  599.     });
  601.     return sendOperation;
  602.   }
  604.   /**
  605.    * @param {shaka.net.NetworkingEngine.RequestType} type
  606.    * @param {shaka.net.NetworkingEngine.ResponseAndGotProgress}
  607.    *        responseAndGotProgress
  608.    * @return {!shaka.extern.IAbortableOperation.<
  609.    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  610.    * @private
  611.    */
  612.   filterResponse_(type, responseAndGotProgress) {
  613.     let filterOperation = shaka.util.AbortableOperation.completed(undefined);
  614.     for (const responseFilter of this.responseFilters_) {
  615.       // Response filters are run sequentially.
  616.       filterOperation = filterOperation.chain(() => {
  617.         const resp = responseAndGotProgress.response;
  618.         if (resp.data) {
  619.           // TODO: See TODO in filterRequest_.
  620.           resp.data = shaka.util.BufferUtils.toArrayBuffer(resp.data);
  621.         }
  622.         return responseFilter(type, resp);
  623.       });
  624.     }
  625.     // If successful, return the filtered response with whether it got
  626.     // progress.
  627.     return filterOperation.chain(() => {
  628.       return responseAndGotProgress;
  629.     }, (e) => {
  630.       // Catch any errors thrown by request filters, and substitute
  631.       // them with a Shaka-native error.
  633.       // The error is assumed to be critical if the original wasn't a Shaka
  634.       // error.
  635.       let severity = shaka.util.Error.Severity.CRITICAL;
  636.       if (e instanceof shaka.util.Error) {
  637.         if (e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  638.           // Don't change anything if the operation was aborted.
  639.           throw e;
  640.         }
  642.         severity = e.severity;
  643.       }
  645.       throw new shaka.util.Error(
  646.           severity,
  647.           shaka.util.Error.Category.NETWORK,
  648.           shaka.util.Error.Code.RESPONSE_FILTER_ERROR, e);
  649.     });
  650.   }
  652.   /**
  653.    * This is here only for testability.  We can't mock location in our tests on
  654.    * all browsers, so instead we mock this.
  655.    *
  656.    * @return {string} The value of location.protocol.
  657.    * @private
  658.    */
  659.   static getLocationProtocol_() {
  660.     return location.protocol;
  661.   }
  662. };
  664. /**
  665.  * A wrapper class for the number of bytes remaining to be downloaded for the
  666.  * request.
  667.  * Instead of using PendingRequest directly, this class is needed to be sent to
  668.  * plugin as a parameter, and a Promise is returned, before PendingRequest is
  669.  * created.
  670.  *
  671.  * @export
  672.  */
  673. shaka.net.NetworkingEngine.NumBytesRemainingClass = class {
  674.   /**
  675.    * Constructor
  676.    */
  677.   constructor() {
  678.     /** @private {number} */
  679.     this.bytesToLoad_ = 0;
  680.   }
  682.   /**
  683.    * @param {number} bytesToLoad
  684.    */
  685.   setBytes(bytesToLoad) {
  686.     this.bytesToLoad_ = bytesToLoad;
  687.   }
  689.   /**
  690.    * @return {number}
  691.    */
  692.   getBytes() {
  693.     return this.bytesToLoad_;
  694.   }
  695. };
  697. /**
  698.  * A pending network request. This can track the current progress of the
  699.  * download, and allows the request to be aborted if the network is slow.
  700.  *
  701.  * @implements {shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  702.  * @extends {shaka.util.AbortableOperation}
  703.  * @export
  704.  */
  705. shaka.net.NetworkingEngine.PendingRequest =
  706. class extends shaka.util.AbortableOperation {
  707.   /**
  708.    * @param {!Promise} promise
  709.    *   A Promise which represents the underlying operation.  It is resolved
  710.    *   when the operation is complete, and rejected if the operation fails or
  711.    *   is aborted.  Aborted operations should be rejected with a
  712.    *   shaka.util.Error object using the error code OPERATION_ABORTED.
  713.    * @param {function():!Promise} onAbort
  714.    *   Will be called by this object to abort the underlying operation.  This
  715.    *   is not cancelation, and will not necessarily result in any work being
  716.    *   undone.  abort() should return a Promise which is resolved when the
  717.    *   underlying operation has been aborted.  The returned Promise should
  718.    *   never be rejected.
  719.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  720.    *   numBytesRemainingObj
  721.    */
  722.   constructor(promise, onAbort, numBytesRemainingObj) {
  723.     super(promise, onAbort);
  725.     /** @private {shaka.net.NetworkingEngine.NumBytesRemainingClass} */
  726.     this.bytesRemaining_ = numBytesRemainingObj;
  727.   }
  729.   /**
  730.    * @return {number}
  731.    */
  732.   getBytesRemaining() {
  733.     return this.bytesRemaining_.getBytes();
  734.   }
  735. };
  737. /**
  738.  * Request types.  Allows a filter to decide which requests to read/alter.
  739.  *
  740.  * @enum {number}
  741.  * @export
  742.  */
  743. shaka.net.NetworkingEngine.RequestType = {
  744.   'MANIFEST': 0,
  745.   'SEGMENT': 1,
  746.   'LICENSE': 2,
  747.   'APP': 3,
  748.   'TIMING': 4,
  749.   'SERVER_CERTIFICATE': 5,
  750. };
  753. /**
  754.  * Priority level for network scheme plugins.
  755.  * If multiple plugins are provided for the same scheme, only the
  756.  * highest-priority one is used.
  757.  *
  758.  * @enum {number}
  759.  * @export
  760.  */
  761. shaka.net.NetworkingEngine.PluginPriority = {
  762.   'FALLBACK': 1,
  763.   'PREFERRED': 2,
  764.   'APPLICATION': 3,
  765. };
  768. /**
  769.  * @typedef {{
  770.  *   plugin: shaka.extern.SchemePlugin,
  771.  *   priority: number,
  772.  *   progressSupport: boolean
  773.  * }}
  774.  * @property {shaka.extern.SchemePlugin} plugin
  775.  *   The associated plugin.
  776.  * @property {number} priority
  777.  *   The plugin's priority.
  778.  * @property {boolean} progressSupport
  779.  *   The plugin's supports progress events
  780.  */
  781. shaka.net.NetworkingEngine.SchemeObject;
  784. /**
  785.  * Contains the scheme plugins.
  786.  *
  787.  * @private {!Object.<string, shaka.net.NetworkingEngine.SchemeObject>}
  788.  */
  789. shaka.net.NetworkingEngine.schemes_ = {};
  791. /**
  792.  * @typedef {{
  793.  *   response: shaka.extern.Response,
  794.  *   gotProgress: boolean
  795.  * }}
  796.  *
  797.  * @description
  798.  * Defines a response wrapper object, including the response object and whether
  799.  * progress event is fired by the scheme plugin.
  800.  *
  801.  * @property {shaka.extern.Response} response
  802.  * @property {boolean} gotProgress
  803.  * @private
  804.  */
  805. shaka.net.NetworkingEngine.ResponseAndGotProgress;
  808. /**
  809.  * @typedef {function(
  810.  *    !Object.<string, string>,
  811.  *    !shaka.extern.Request,
  812.  *    !shaka.net.NetworkingEngine.RequestType)}
  813.  *
  814.  * @description
  815.  * A callback function that passes the shaka.extern.HeadersReceived along to
  816.  * the player, plus some extra data.
  817.  * @export
  818.  */
  819. shaka.net.NetworkingEngine.OnHeadersReceived;
  822. /**
  823.  * @typedef {function(
  824.  *    !shaka.extern.Request,
  825.  *    ?shaka.util.Error,
  826.  *    number,
  827.  *    boolean)}
  828.  *
  829.  * @description
  830.  * A callback function that notifies the player when a download fails, for any
  831.  * reason (e.g. even if the download was aborted).
  832.  * @export
  833.  */
  834. shaka.net.NetworkingEngine.OnDownloadFailed;