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