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.       drmInfo: null,
  224.       initData: null,
  225.       initDataType: null,
  226.       streamDataCallback: streamDataCallback,
  227.     };
  228.   }
  230.   /**
  231.    * @override
  232.    * @export
  233.    */
  234.   destroy() {
  235.     this.destroyed_ = true;
  236.     this.requestFilters_.clear();
  237.     this.responseFilters_.clear();
  239.     // FakeEventTarget implements IReleasable
  240.     super.release();
  242.     return this.operationManager_.destroy();
  243.   }
  245.   /**
  246.    * Makes a network request and returns the resulting data.
  247.    *
  248.    * @param {shaka.net.NetworkingEngine.RequestType} type
  249.    * @param {shaka.extern.Request} request
  250.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  251.    * @export
  252.    */
  253.   request(type, request) {
  254.     const ObjectUtils = shaka.util.ObjectUtils;
  255.     const numBytesRemainingObj =
  256.         new shaka.net.NetworkingEngine.NumBytesRemainingClass();
  258.     // Reject all requests made after destroy is called.
  259.     if (this.destroyed_) {
  260.       const p = Promise.reject(new shaka.util.Error(
  261.           shaka.util.Error.Severity.CRITICAL,
  262.           shaka.util.Error.Category.PLAYER,
  263.           shaka.util.Error.Code.OPERATION_ABORTED));
  264.       // Silence uncaught rejection errors, which may otherwise occur any place
  265.       // we don't explicitly handle aborted operations.
  266.       p.catch(() => {});
  267.       return new shaka.net.NetworkingEngine.PendingRequest(
  268.           p, () => Promise.resolve(), numBytesRemainingObj);
  269.     }
  271.     goog.asserts.assert(
  272.         request.uris && request.uris.length, 'Request without URIs!');
  274.     // If a request comes from outside the library, some parameters may be left
  275.     // undefined.  To make it easier for application developers, we will fill
  276.     // them in with defaults if necessary.
  277.     //
  278.     // We clone retryParameters and uris so that if a filter modifies the
  279.     // request, it doesn't contaminate future requests.
  280.     request.method = request.method || 'GET';
  281.     request.headers = request.headers || {};
  282.     request.retryParameters = request.retryParameters ?
  283.         ObjectUtils.cloneObject(request.retryParameters) :
  284.         shaka.net.NetworkingEngine.defaultRetryParameters();
  285.     request.uris = ObjectUtils.cloneObject(request.uris);
  287.     // Apply the registered filters to the request.
  288.     const requestFilterOperation = this.filterRequest_(type, request);
  289.     const requestOperation = requestFilterOperation.chain(
  290.         () => this.makeRequestWithRetry_(type, request, numBytesRemainingObj));
  291.     const responseFilterOperation = requestOperation.chain(
  292.         (responseAndGotProgress) =>
  293.           this.filterResponse_(type, responseAndGotProgress));
  295.     // Keep track of time spent in filters.
  296.     const requestFilterStartTime = Date.now();
  297.     let requestFilterMs = 0;
  298.     requestFilterOperation.promise.then(() => {
  299.       requestFilterMs = Date.now() - requestFilterStartTime;
  300.     }, () => {});  // Silence errors in this fork of the Promise chain.
  302.     let responseFilterStartTime = 0;
  303.     requestOperation.promise.then(() => {
  304.       responseFilterStartTime = Date.now();
  305.     }, () => {});  // Silence errors in this fork of the Promise chain.
  307.     const op = responseFilterOperation.chain((responseAndGotProgress) => {
  308.       const responseFilterMs = Date.now() - responseFilterStartTime;
  309.       const response = responseAndGotProgress.response;
  310.       response.timeMs += requestFilterMs;
  311.       response.timeMs += responseFilterMs;
  312.       if (!responseAndGotProgress.gotProgress &&
  313.           this.onProgressUpdated_ &&
  314.           !response.fromCache &&
  315.           type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
  316.         this.onProgressUpdated_(response.timeMs, response.data.byteLength);
  317.       }
  318.       return response;
  319.     }, (e) => {
  320.       // Any error thrown from elsewhere should be recategorized as CRITICAL
  321.       // here.  This is because by the time it gets here, we've exhausted
  322.       // retries.
  323.       if (e) {
  324.         goog.asserts.assert(e instanceof shaka.util.Error, 'Wrong error type');
  325.         e.severity = shaka.util.Error.Severity.CRITICAL;
  326.       }
  328.       throw e;
  329.     });
  331.     // Return the pending request, which carries the response operation, and the
  332.     // number of bytes remaining to be downloaded, updated by the progress
  333.     // events.  Add the operation to the manager for later cleanup.
  334.     const pendingRequest =
  335.         new shaka.net.NetworkingEngine.PendingRequest(
  336.             op.promise, () => op.abort(), numBytesRemainingObj);
  337.     this.operationManager_.manage(pendingRequest);
  338.     return pendingRequest;
  339.   }
  341.   /**
  342.    * @param {shaka.net.NetworkingEngine.RequestType} type
  343.    * @param {shaka.extern.Request} request
  344.    * @return {!shaka.util.AbortableOperation.<undefined>}
  345.    * @private
  346.    */
  347.   filterRequest_(type, request) {
  348.     let filterOperation = shaka.util.AbortableOperation.completed(undefined);
  350.     for (const requestFilter of this.requestFilters_) {
  351.       // Request filters are run sequentially.
  352.       filterOperation = filterOperation.chain(() => {
  353.         if (request.body) {
  354.           // TODO: For v4.0 we should remove this or change to always pass a
  355.           // Uint8Array.  To make it easier for apps to write filters, it may be
  356.           // better to always pass a Uint8Array so they know what they are
  357.           // getting; but we shouldn't use ArrayBuffer since that would require
  358.           // copying buffers if this is a partial view.
  359.           request.body = shaka.util.BufferUtils.toArrayBuffer(request.body);
  360.         }
  361.         return requestFilter(type, request);
  362.       });
  363.     }
  365.     // Catch any errors thrown by request filters, and substitute
  366.     // them with a Shaka-native error.
  367.     return filterOperation.chain(undefined, (e) => {
  368.       if (e instanceof shaka.util.Error &&
  369.           e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  370.         // Don't change anything if the operation was aborted.
  371.         throw e;
  372.       }
  374.       throw new shaka.util.Error(
  375.           shaka.util.Error.Severity.CRITICAL,
  376.           shaka.util.Error.Category.NETWORK,
  377.           shaka.util.Error.Code.REQUEST_FILTER_ERROR, e);
  378.     });
  379.   }
  381.   /**
  382.    * @param {shaka.net.NetworkingEngine.RequestType} type
  383.    * @param {shaka.extern.Request} request
  384.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  385.    *            numBytesRemainingObj
  386.    * @return {!shaka.extern.IAbortableOperation.<
  387.    *            shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  388.    * @private
  389.    */
  390.   makeRequestWithRetry_(type, request, numBytesRemainingObj) {
  391.     const backoff = new shaka.net.Backoff(
  392.         request.retryParameters, /* autoReset= */ false);
  393.     const index = 0;
  394.     return this.send_(
  395.         type, request, backoff, index, /* lastError= */ null,
  396.         numBytesRemainingObj);
  397.   }
  399.   /**
  400.    * Sends the given request to the correct plugin and retry using Backoff.
  401.    *
  402.    * @param {shaka.net.NetworkingEngine.RequestType} type
  403.    * @param {shaka.extern.Request} request
  404.    * @param {!shaka.net.Backoff} backoff
  405.    * @param {number} index
  406.    * @param {?shaka.util.Error} lastError
  407.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  408.    *     numBytesRemainingObj
  409.    * @return {!shaka.extern.IAbortableOperation.<
  410.    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  411.    * @private
  412.    */
  413.   send_(type, request, backoff, index, lastError, numBytesRemainingObj) {
  414.     if (this.forceHTTPS_) {
  415.       request.uris[index] = request.uris[index].replace('http://', 'https://');
  416.     }
  418.     const uri = new goog.Uri(request.uris[index]);
  419.     let scheme = uri.getScheme();
  420.     // Whether it got a progress event.
  421.     let gotProgress = false;
  422.     if (!scheme) {
  423.       // If there is no scheme, infer one from the location.
  424.       scheme = shaka.net.NetworkingEngine.getLocationProtocol_();
  425.       goog.asserts.assert(
  426.           scheme[scheme.length - 1] == ':',
  427.           'location.protocol expected to end with a colon!');
  428.       // Drop the colon.
  429.       scheme = scheme.slice(0, -1);
  431.       // Override the original URI to make the scheme explicit.
  432.       uri.setScheme(scheme);
  433.       request.uris[index] = uri.toString();
  434.     }
  436.     // Schemes are meant to be case-insensitive.
  437.     // See https://github.com/shaka-project/shaka-player/issues/2173
  438.     // and https://tools.ietf.org/html/rfc3986#section-3.1
  439.     scheme = scheme.toLowerCase();
  441.     const object = shaka.net.NetworkingEngine.schemes_[scheme];
  442.     const plugin = object ? object.plugin : null;
  443.     if (!plugin) {
  444.       return shaka.util.AbortableOperation.failed(
  445.           new shaka.util.Error(
  446.               shaka.util.Error.Severity.CRITICAL,
  447.               shaka.util.Error.Category.NETWORK,
  448.               shaka.util.Error.Code.UNSUPPORTED_SCHEME,
  449.               uri));
  450.     }
  451.     const progressSupport = object.progressSupport;
  454.     // Every attempt must have an associated backoff.attempt() call so that the
  455.     // accounting is correct.
  456.     const backoffOperation =
  457.         shaka.util.AbortableOperation.notAbortable(backoff.attempt());
  459.     /** @type {?shaka.util.Timer} */
  460.     let connectionTimer = null;
  462.     /** @type {?shaka.util.Timer} */
  463.     let stallTimer = null;
  465.     let aborted = false;
  467.     let headersReceivedCalled = false;
  469.     let startTimeMs;
  470.     const sendOperation = backoffOperation.chain(() => {
  471.       if (this.destroyed_) {
  472.         return shaka.util.AbortableOperation.aborted();
  473.       }
  475.       startTimeMs = Date.now();
  476.       const segment = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  478.       const progressUpdated = (time, bytes, numBytesRemaining) => {
  479.         if (connectionTimer) {
  480.           connectionTimer.stop();
  481.         }
  482.         if (stallTimer) {
  483.           stallTimer.tickAfter(stallTimeoutMs / 1000);
  484.         }
  485.         if (this.onProgressUpdated_ && type == segment) {
  486.           this.onProgressUpdated_(time, bytes);
  487.           gotProgress = true;
  488.           numBytesRemainingObj.setBytes(numBytesRemaining);
  489.         }
  490.       };
  491.       const headersReceived = (headers) => {
  492.         if (this.onHeadersReceived_) {
  493.           this.onHeadersReceived_(headers, request, type);
  494.         }
  495.         headersReceivedCalled = true;
  496.       };
  497.       const requestPlugin = plugin(
  498.           request.uris[index], request, type, progressUpdated, headersReceived);
  500.       if (!progressSupport) {
  501.         return requestPlugin;
  502.       }
  504.       const connectionTimeoutMs = request.retryParameters.connectionTimeout;
  505.       if (connectionTimeoutMs) {
  506.         connectionTimer = new shaka.util.Timer(() => {
  507.           aborted = true;
  508.           requestPlugin.abort();
  509.         });
  511.         connectionTimer.tickAfter(connectionTimeoutMs / 1000);
  512.       }
  514.       const stallTimeoutMs = request.retryParameters.stallTimeout;
  515.       if (stallTimeoutMs) {
  516.         stallTimer = new shaka.util.Timer(() => {
  517.           aborted = true;
  518.           requestPlugin.abort();
  519.         });
  520.       }
  522.       return requestPlugin;
  523.     }).chain((response) => {
  524.       if (connectionTimer) {
  525.         connectionTimer.stop();
  526.       }
  527.       if (stallTimer) {
  528.         stallTimer.stop();
  529.       }
  530.       if (response.timeMs == undefined) {
  531.         response.timeMs = Date.now() - startTimeMs;
  532.       }
  533.       const responseAndGotProgress = {
  534.         response: response,
  535.         gotProgress: gotProgress,
  536.       };
  537.       if (!headersReceivedCalled) {
  538.         // The plugin did not call headersReceived, perhaps because it is not
  539.         // able to track that information. So, fire the event manually.
  540.         if (this.onHeadersReceived_) {
  541.           this.onHeadersReceived_(response.headers, request, type);
  542.         }
  543.       }
  545.       return responseAndGotProgress;
  546.     }, (error) => {
  547.       if (connectionTimer) {
  548.         connectionTimer.stop();
  549.       }
  550.       if (stallTimer) {
  551.         stallTimer.stop();
  552.       }
  553.       if (this.onDownloadFailed_) {
  554.         let shakaError = null;
  555.         let httpResponseCode = 0;
  556.         if (error instanceof shaka.util.Error) {
  557.           shakaError = error;
  558.           if (error.code == shaka.util.Error.Code.BAD_HTTP_STATUS) {
  559.             httpResponseCode = /** @type {number} */ (error.data[1]);
  560.           }
  561.         }
  562.         this.onDownloadFailed_(request, shakaError, httpResponseCode, aborted);
  563.       }
  564.       if (this.destroyed_) {
  565.         return shaka.util.AbortableOperation.aborted();
  566.       }
  568.       if (aborted) {
  569.         // It is necessary to change the error code to the correct one because
  570.         // otherwise the retry logic would not work.
  571.         error = new shaka.util.Error(
  572.             shaka.util.Error.Severity.RECOVERABLE,
  573.             shaka.util.Error.Category.NETWORK,
  574.             shaka.util.Error.Code.TIMEOUT,
  575.             request.uris[index], type);
  576.       }
  578.       if (error instanceof shaka.util.Error) {
  579.         if (error.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  580.           // Don't change anything if the operation was aborted.
  581.           throw error;
  582.         } else if (error.code == shaka.util.Error.Code.ATTEMPTS_EXHAUSTED) {
  583.           goog.asserts.assert(lastError, 'Should have last error');
  584.           throw lastError;
  585.         }
  587.         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
  588.           const data = (new Map()).set('error', error);
  589.           const event = new shaka.util.FakeEvent('retry', data);
  590.           this.dispatchEvent(event);
  592.           // Move to the next URI.
  593.           index = (index + 1) % request.uris.length;
  594.           return this.send_(
  595.               type, request, backoff, index, error, numBytesRemainingObj);
  596.         }
  597.       }
  599.       // The error was not recoverable, so do not try again.
  600.       throw error;
  601.     });
  603.     return sendOperation;
  604.   }
  606.   /**
  607.    * @param {shaka.net.NetworkingEngine.RequestType} type
  608.    * @param {shaka.net.NetworkingEngine.ResponseAndGotProgress}
  609.    *        responseAndGotProgress
  610.    * @return {!shaka.extern.IAbortableOperation.<
  611.    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
  612.    * @private
  613.    */
  614.   filterResponse_(type, responseAndGotProgress) {
  615.     let filterOperation = shaka.util.AbortableOperation.completed(undefined);
  616.     for (const responseFilter of this.responseFilters_) {
  617.       // Response filters are run sequentially.
  618.       filterOperation = filterOperation.chain(() => {
  619.         const resp = responseAndGotProgress.response;
  620.         if (resp.data) {
  621.           // TODO: See TODO in filterRequest_.
  622.           resp.data = shaka.util.BufferUtils.toArrayBuffer(resp.data);
  623.         }
  624.         return responseFilter(type, resp);
  625.       });
  626.     }
  627.     // If successful, return the filtered response with whether it got
  628.     // progress.
  629.     return filterOperation.chain(() => {
  630.       return responseAndGotProgress;
  631.     }, (e) => {
  632.       // Catch any errors thrown by request filters, and substitute
  633.       // them with a Shaka-native error.
  635.       // The error is assumed to be critical if the original wasn't a Shaka
  636.       // error.
  637.       let severity = shaka.util.Error.Severity.CRITICAL;
  638.       if (e instanceof shaka.util.Error) {
  639.         if (e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
  640.           // Don't change anything if the operation was aborted.
  641.           throw e;
  642.         }
  644.         severity = e.severity;
  645.       }
  647.       throw new shaka.util.Error(
  648.           severity,
  649.           shaka.util.Error.Category.NETWORK,
  650.           shaka.util.Error.Code.RESPONSE_FILTER_ERROR, e);
  651.     });
  652.   }
  654.   /**
  655.    * This is here only for testability.  We can't mock location in our tests on
  656.    * all browsers, so instead we mock this.
  657.    *
  658.    * @return {string} The value of location.protocol.
  659.    * @private
  660.    */
  661.   static getLocationProtocol_() {
  662.     return location.protocol;
  663.   }
  664. };
  666. /**
  667.  * A wrapper class for the number of bytes remaining to be downloaded for the
  668.  * request.
  669.  * Instead of using PendingRequest directly, this class is needed to be sent to
  670.  * plugin as a parameter, and a Promise is returned, before PendingRequest is
  671.  * created.
  672.  *
  673.  * @export
  674.  */
  675. shaka.net.NetworkingEngine.NumBytesRemainingClass = class {
  676.   /**
  677.    * Constructor
  678.    */
  679.   constructor() {
  680.     /** @private {number} */
  681.     this.bytesToLoad_ = 0;
  682.   }
  684.   /**
  685.    * @param {number} bytesToLoad
  686.    */
  687.   setBytes(bytesToLoad) {
  688.     this.bytesToLoad_ = bytesToLoad;
  689.   }
  691.   /**
  692.    * @return {number}
  693.    */
  694.   getBytes() {
  695.     return this.bytesToLoad_;
  696.   }
  697. };
  699. /**
  700.  * A pending network request. This can track the current progress of the
  701.  * download, and allows the request to be aborted if the network is slow.
  702.  *
  703.  * @implements {shaka.extern.IAbortableOperation.<shaka.extern.Response>}
  704.  * @extends {shaka.util.AbortableOperation}
  705.  * @export
  706.  */
  707. shaka.net.NetworkingEngine.PendingRequest =
  708. class extends shaka.util.AbortableOperation {
  709.   /**
  710.    * @param {!Promise} promise
  711.    *   A Promise which represents the underlying operation.  It is resolved
  712.    *   when the operation is complete, and rejected if the operation fails or
  713.    *   is aborted.  Aborted operations should be rejected with a
  714.    *   shaka.util.Error object using the error code OPERATION_ABORTED.
  715.    * @param {function():!Promise} onAbort
  716.    *   Will be called by this object to abort the underlying operation.  This
  717.    *   is not cancelation, and will not necessarily result in any work being
  718.    *   undone.  abort() should return a Promise which is resolved when the
  719.    *   underlying operation has been aborted.  The returned Promise should
  720.    *   never be rejected.
  721.    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
  722.    *   numBytesRemainingObj
  723.    */
  724.   constructor(promise, onAbort, numBytesRemainingObj) {
  725.     super(promise, onAbort);
  727.     /** @private {shaka.net.NetworkingEngine.NumBytesRemainingClass} */
  728.     this.bytesRemaining_ = numBytesRemainingObj;
  729.   }
  731.   /**
  732.    * @return {number}
  733.    */
  734.   getBytesRemaining() {
  735.     return this.bytesRemaining_.getBytes();
  736.   }
  737. };
  739. /**
  740.  * Request types.  Allows a filter to decide which requests to read/alter.
  741.  *
  742.  * @enum {number}
  743.  * @export
  744.  */
  745. shaka.net.NetworkingEngine.RequestType = {
  746.   'MANIFEST': 0,
  747.   'SEGMENT': 1,
  748.   'LICENSE': 2,
  749.   'APP': 3,
  750.   'TIMING': 4,
  751.   'SERVER_CERTIFICATE': 5,
  752. };
  755. /**
  756.  * Priority level for network scheme plugins.
  757.  * If multiple plugins are provided for the same scheme, only the
  758.  * highest-priority one is used.
  759.  *
  760.  * @enum {number}
  761.  * @export
  762.  */
  763. shaka.net.NetworkingEngine.PluginPriority = {
  764.   'FALLBACK': 1,
  765.   'PREFERRED': 2,
  766.   'APPLICATION': 3,
  767. };
  770. /**
  771.  * @typedef {{
  772.  *   plugin: shaka.extern.SchemePlugin,
  773.  *   priority: number,
  774.  *   progressSupport: boolean
  775.  * }}
  776.  * @property {shaka.extern.SchemePlugin} plugin
  777.  *   The associated plugin.
  778.  * @property {number} priority
  779.  *   The plugin's priority.
  780.  * @property {boolean} progressSupport
  781.  *   The plugin's supports progress events
  782.  */
  783. shaka.net.NetworkingEngine.SchemeObject;
  786. /**
  787.  * Contains the scheme plugins.
  788.  *
  789.  * @private {!Object.<string, shaka.net.NetworkingEngine.SchemeObject>}
  790.  */
  791. shaka.net.NetworkingEngine.schemes_ = {};
  793. /**
  794.  * @typedef {{
  795.  *   response: shaka.extern.Response,
  796.  *   gotProgress: boolean
  797.  * }}
  798.  *
  799.  * @description
  800.  * Defines a response wrapper object, including the response object and whether
  801.  * progress event is fired by the scheme plugin.
  802.  *
  803.  * @property {shaka.extern.Response} response
  804.  * @property {boolean} gotProgress
  805.  * @private
  806.  */
  807. shaka.net.NetworkingEngine.ResponseAndGotProgress;
  810. /**
  811.  * @typedef {function(
  812.  *    !Object.<string, string>,
  813.  *    !shaka.extern.Request,
  814.  *    !shaka.net.NetworkingEngine.RequestType)}
  815.  *
  816.  * @description
  817.  * A callback function that passes the shaka.extern.HeadersReceived along to
  818.  * the player, plus some extra data.
  819.  * @export
  820.  */
  821. shaka.net.NetworkingEngine.OnHeadersReceived;
  824. /**
  825.  * @typedef {function(
  826.  *    !shaka.extern.Request,
  827.  *    ?shaka.util.Error,
  828.  *    number,
  829.  *    boolean)}
  830.  *
  831.  * @description
  832.  * A callback function that notifies the player when a download fails, for any
  833.  * reason (e.g. even if the download was aborted).
  834.  * @export
  835.  */
  836. shaka.net.NetworkingEngine.OnDownloadFailed;