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