forked from mirrors/gecko-dev
ca85c42741
The current serverCertificateHashes implementation does not follow the WebTransport specification, that introduced serverCertificateHashes as a tool to replace certificate chain verification. Instead it introduced the hashes as an additional check. This patch moves the check to the Http3Session object and modifies the connection manager' hashes to prevent crossSite certificate poisoning. It is - as the WebTransport Implementation in Firefox - currently limited to http3 only. However, since the hashes live on the ConnectionEntries, it should be possible to extend this in the future. Differential Revision: https://phabricator.services.mozilla.com/D197857
485 lines
20 KiB
C++
485 lines
20 KiB
C++
/* vim:t ts=4 sw=2 sts=2 et cin: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef nsHttpConnectionMgr_h__
|
|
#define nsHttpConnectionMgr_h__
|
|
|
|
#include "DnsAndConnectSocket.h"
|
|
#include "HttpConnectionBase.h"
|
|
#include "HttpConnectionMgrShell.h"
|
|
#include "nsHttpConnection.h"
|
|
#include "nsHttpTransaction.h"
|
|
#include "nsTArray.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsClassHashtable.h"
|
|
#include "mozilla/ReentrantMonitor.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "ARefBase.h"
|
|
#include "nsWeakReference.h"
|
|
#include "ConnectionEntry.h"
|
|
|
|
#include "nsINamed.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsITimer.h"
|
|
|
|
class nsIHttpUpgradeListener;
|
|
|
|
namespace mozilla::net {
|
|
class EventTokenBucket;
|
|
class NullHttpTransaction;
|
|
struct HttpRetParams;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// message handlers have this signature
|
|
class nsHttpConnectionMgr;
|
|
using nsConnEventHandler = void (nsHttpConnectionMgr::*)(int32_t, ARefBase*);
|
|
|
|
class nsHttpConnectionMgr final : public HttpConnectionMgrShell,
|
|
public nsIObserver,
|
|
nsINamed {
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
NS_DECL_HTTPCONNECTIONMGRSHELL
|
|
NS_DECL_NSIOBSERVER
|
|
NS_DECL_NSINAMED
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: functions below may only be called on the main thread.
|
|
//-------------------------------------------------------------------------
|
|
|
|
nsHttpConnectionMgr();
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: functions below may be called on any thread.
|
|
//-------------------------------------------------------------------------
|
|
|
|
[[nodiscard]] nsresult CancelTransactions(nsHttpConnectionInfo*,
|
|
nsresult code);
|
|
|
|
// The connection manager needs to know the hashes used for a WebTransport
|
|
// connection authenticated with serverCertHashes
|
|
nsresult StoreServerCertHashes(
|
|
nsHttpConnectionInfo* aConnInfo, bool aNoSpdy, bool aNoHttp3,
|
|
nsTArray<RefPtr<nsIWebTransportHash>>&& aServerCertHashes);
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: functions below may be called only on the socket thread.
|
|
//-------------------------------------------------------------------------
|
|
|
|
// called to change the connection entry associated with conn from specific
|
|
// into a wildcard (i.e. http2 proxy friendy) mapping
|
|
void MoveToWildCardConnEntry(nsHttpConnectionInfo* specificCI,
|
|
nsHttpConnectionInfo* wildcardCI,
|
|
HttpConnectionBase* conn);
|
|
|
|
// Remove a transaction from the pendingQ of it's connection entry. Returns
|
|
// true if the transaction is removed successfully, otherwise returns false.
|
|
bool RemoveTransFromConnEntry(nsHttpTransaction* aTrans,
|
|
const nsACString& aHashKey);
|
|
|
|
// Directly dispatch the transaction or insert it in to the pendingQ.
|
|
[[nodiscard]] nsresult ProcessNewTransaction(nsHttpTransaction* aTrans);
|
|
|
|
// This is used to force an idle connection to be closed and removed from
|
|
// the idle connection list. It is called when the idle connection detects
|
|
// that the network peer has closed the transport.
|
|
[[nodiscard]] nsresult CloseIdleConnection(nsHttpConnection*);
|
|
[[nodiscard]] nsresult RemoveIdleConnection(nsHttpConnection*);
|
|
|
|
// Close a single connection and prevent it from being reused.
|
|
[[nodiscard]] nsresult DoSingleConnectionCleanup(nsHttpConnectionInfo*);
|
|
|
|
// The connection manager needs to know when a normal HTTP connection has been
|
|
// upgraded to SPDY because the dispatch and idle semantics are a little
|
|
// bit different.
|
|
void ReportSpdyConnection(nsHttpConnection*, bool usingSpdy,
|
|
bool disallowHttp3);
|
|
|
|
void ReportHttp3Connection(HttpConnectionBase*);
|
|
|
|
bool GetConnectionData(nsTArray<HttpRetParams>*);
|
|
|
|
void ResetIPFamilyPreference(nsHttpConnectionInfo*);
|
|
|
|
uint16_t MaxRequestDelay() { return mMaxRequestDelay; }
|
|
|
|
// tracks and untracks active transactions according their throttle status
|
|
void AddActiveTransaction(nsHttpTransaction* aTrans);
|
|
void RemoveActiveTransaction(nsHttpTransaction* aTrans,
|
|
Maybe<bool> const& aOverride = Nothing());
|
|
void UpdateActiveTransaction(nsHttpTransaction* aTrans);
|
|
|
|
// called by nsHttpTransaction::WriteSegments. decides whether the
|
|
// transaction should limit reading its reponse data. There are various
|
|
// conditions this methods evaluates. If called by an active-tab
|
|
// non-throttled transaction, the throttling window time will be prolonged.
|
|
bool ShouldThrottle(nsHttpTransaction* aTrans);
|
|
|
|
// prolongs the throttling time window to now + the window preferred delay.
|
|
// called when:
|
|
// - any transaction is activated
|
|
// - or when a currently unthrottled transaction for the active window
|
|
// receives data
|
|
void TouchThrottlingTimeWindow(bool aEnsureTicker = true);
|
|
|
|
// return true iff the connection has pending transactions for the active tab.
|
|
// it's mainly used to disallow throttling (limit reading) of a response
|
|
// belonging to the same conn info to free up a connection ASAP.
|
|
// NOTE: relatively expensive to call, there are two hashtable lookups.
|
|
bool IsConnEntryUnderPressure(nsHttpConnectionInfo*);
|
|
|
|
uint64_t CurrentBrowserId() { return mCurrentBrowserId; }
|
|
|
|
void DoFallbackConnection(SpeculativeTransaction* aTrans, bool aFetchHTTPSRR);
|
|
void DoSpeculativeConnection(SpeculativeTransaction* aTrans,
|
|
bool aFetchHTTPSRR);
|
|
|
|
HttpConnectionBase* GetH2orH3ActiveConn(ConnectionEntry* ent, bool aNoHttp2,
|
|
bool aNoHttp3);
|
|
|
|
void IncreaseNumDnsAndConnectSockets();
|
|
void DecreaseNumDnsAndConnectSockets();
|
|
|
|
// Wen a new idle connection has been added, this function is called to
|
|
// increment mNumIdleConns and update PruneDeadConnections timer.
|
|
void NewIdleConnectionAdded(uint32_t timeToLive);
|
|
void DecrementNumIdleConns();
|
|
|
|
const nsTArray<RefPtr<nsIWebTransportHash>>* GetServerCertHashes(
|
|
nsHttpConnectionInfo* aConnInfo);
|
|
|
|
uint64_t GenerateNewWebTransportId() { return mMaxWebTransportId++; }
|
|
|
|
private:
|
|
virtual ~nsHttpConnectionMgr();
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: functions below may be called on any thread.
|
|
//-------------------------------------------------------------------------
|
|
|
|
// Schedules next pruning of dead connection to happen after
|
|
// given time.
|
|
void PruneDeadConnectionsAfter(uint32_t time);
|
|
|
|
// Stops timer scheduled for next pruning of dead connections if
|
|
// there are no more idle connections or active spdy ones
|
|
void ConditionallyStopPruneDeadConnectionsTimer();
|
|
|
|
// Stops timer used for the read timeout tick if there are no currently
|
|
// active connections.
|
|
void ConditionallyStopTimeoutTick();
|
|
|
|
// called to close active connections with no registered "traffic"
|
|
[[nodiscard]] nsresult PruneNoTraffic();
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: functions below may be called only on the socket thread.
|
|
//-------------------------------------------------------------------------
|
|
|
|
[[nodiscard]] bool ProcessPendingQForEntry(nsHttpConnectionInfo*);
|
|
|
|
// public, so that the SPDY/http2 seesions can activate
|
|
void ActivateTimeoutTick();
|
|
|
|
already_AddRefed<PendingTransactionInfo> FindTransactionHelper(
|
|
bool removeWhenFound, ConnectionEntry* aEnt, nsAHttpTransaction* aTrans);
|
|
|
|
void DoSpeculativeConnectionInternal(ConnectionEntry* aEnt,
|
|
SpeculativeTransaction* aTrans,
|
|
bool aFetchHTTPSRR);
|
|
|
|
already_AddRefed<ConnectionEntry> FindConnectionEntry(
|
|
const nsHttpConnectionInfo* ci);
|
|
|
|
public:
|
|
void RegisterOriginCoalescingKey(HttpConnectionBase*, const nsACString& host,
|
|
int32_t port);
|
|
// A test if be-conservative should be used when proxy is setup for the
|
|
// connection
|
|
bool BeConservativeIfProxied(nsIProxyInfo* proxy);
|
|
|
|
bool AllowToRetryDifferentIPFamilyForHttp3(nsHttpConnectionInfo* ci,
|
|
nsresult aError);
|
|
void SetRetryDifferentIPFamilyForHttp3(nsHttpConnectionInfo* ci,
|
|
uint16_t aIPFamily);
|
|
|
|
protected:
|
|
friend class ConnectionEntry;
|
|
void IncrementActiveConnCount();
|
|
void DecrementActiveConnCount(HttpConnectionBase*);
|
|
|
|
private:
|
|
friend class DnsAndConnectSocket;
|
|
friend class PendingTransactionInfo;
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: these members may be accessed from any thread (use mReentrantMonitor)
|
|
//-------------------------------------------------------------------------
|
|
|
|
ReentrantMonitor mReentrantMonitor{"nsHttpConnectionMgr.mReentrantMonitor"};
|
|
// This is used as a flag that we're shut down, and no new events should be
|
|
// dispatched.
|
|
nsCOMPtr<nsIEventTarget> mSocketThreadTarget
|
|
MOZ_GUARDED_BY(mReentrantMonitor);
|
|
|
|
Atomic<bool, mozilla::Relaxed> mIsShuttingDown{false};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: these members are only accessed on the socket transport thread
|
|
//-------------------------------------------------------------------------
|
|
// connection limits
|
|
uint16_t mMaxUrgentExcessiveConns{0};
|
|
uint16_t mMaxConns{0};
|
|
uint16_t mMaxPersistConnsPerHost{0};
|
|
uint16_t mMaxPersistConnsPerProxy{0};
|
|
uint16_t mMaxRequestDelay{0}; // in seconds
|
|
bool mThrottleEnabled{false};
|
|
uint32_t mThrottleVersion{2};
|
|
uint32_t mThrottleSuspendFor{0};
|
|
uint32_t mThrottleResumeFor{0};
|
|
uint32_t mThrottleReadLimit{0};
|
|
uint32_t mThrottleReadInterval{0};
|
|
uint32_t mThrottleHoldTime{0};
|
|
TimeDuration mThrottleMaxTime;
|
|
bool mBeConservativeForProxy{true};
|
|
|
|
[[nodiscard]] bool ProcessPendingQForEntry(ConnectionEntry*,
|
|
bool considerAll);
|
|
bool DispatchPendingQ(nsTArray<RefPtr<PendingTransactionInfo>>& pendingQ,
|
|
ConnectionEntry* ent, bool considerAll);
|
|
|
|
// This function selects transactions from mPendingTransactionTable to
|
|
// dispatch according to the following conditions:
|
|
// 1. When ActiveTabPriority() is false, only get transactions from the
|
|
// queue whose window id is 0.
|
|
// 2. If |considerAll| is false, either get transactions from the focused
|
|
// window queue or non-focused ones.
|
|
// 3. If |considerAll| is true, fill the |pendingQ| with the transactions from
|
|
// both focused window and non-focused window queues.
|
|
void PreparePendingQForDispatching(
|
|
ConnectionEntry* ent, nsTArray<RefPtr<PendingTransactionInfo>>& pendingQ,
|
|
bool considerAll);
|
|
|
|
// Return |mMaxPersistConnsPerProxy| or |mMaxPersistConnsPerHost|,
|
|
// depending whether the proxy is used.
|
|
uint32_t MaxPersistConnections(ConnectionEntry* ent) const;
|
|
|
|
bool AtActiveConnectionLimit(ConnectionEntry*, uint32_t caps);
|
|
[[nodiscard]] nsresult TryDispatchTransaction(
|
|
ConnectionEntry* ent, bool onlyReusedConnection,
|
|
PendingTransactionInfo* pendingTransInfo);
|
|
[[nodiscard]] nsresult TryDispatchTransactionOnIdleConn(
|
|
ConnectionEntry* ent, PendingTransactionInfo* pendingTransInfo,
|
|
bool respectUrgency, bool* allUrgent = nullptr);
|
|
[[nodiscard]] nsresult DispatchTransaction(ConnectionEntry*,
|
|
nsHttpTransaction*,
|
|
HttpConnectionBase*);
|
|
[[nodiscard]] nsresult DispatchAbstractTransaction(ConnectionEntry*,
|
|
nsAHttpTransaction*,
|
|
uint32_t,
|
|
HttpConnectionBase*,
|
|
int32_t);
|
|
[[nodiscard]] nsresult EnsureSocketThreadTarget();
|
|
void ReportProxyTelemetry(ConnectionEntry* ent);
|
|
void StartedConnect();
|
|
void RecvdConnect();
|
|
|
|
ConnectionEntry* GetOrCreateConnectionEntry(
|
|
nsHttpConnectionInfo*, bool prohibitWildCard, bool aNoHttp2,
|
|
bool aNoHttp3, bool* aIsWildcard,
|
|
bool* aAvailableForDispatchNow = nullptr);
|
|
|
|
[[nodiscard]] nsresult MakeNewConnection(
|
|
ConnectionEntry* ent, PendingTransactionInfo* pendingTransInfo);
|
|
|
|
// Manage h2/3 connection coalescing
|
|
// The hashtable contains arrays of weak pointers to HttpConnectionBases
|
|
nsClassHashtable<nsCStringHashKey, nsTArray<nsWeakPtr>> mCoalescingHash;
|
|
|
|
HttpConnectionBase* FindCoalescableConnection(ConnectionEntry* ent,
|
|
bool justKidding, bool aNoHttp2,
|
|
bool aNoHttp3);
|
|
HttpConnectionBase* FindCoalescableConnectionByHashKey(ConnectionEntry* ent,
|
|
const nsCString& key,
|
|
bool justKidding,
|
|
bool aNoHttp2,
|
|
bool aNoHttp3);
|
|
void UpdateCoalescingForNewConn(HttpConnectionBase* conn,
|
|
ConnectionEntry* ent, bool aNoHttp3);
|
|
|
|
void ProcessSpdyPendingQ(ConnectionEntry* ent);
|
|
void DispatchSpdyPendingQ(nsTArray<RefPtr<PendingTransactionInfo>>& pendingQ,
|
|
ConnectionEntry* ent, HttpConnectionBase* connH2,
|
|
HttpConnectionBase* connH3);
|
|
// used to marshall events to the socket transport thread.
|
|
[[nodiscard]] nsresult PostEvent(nsConnEventHandler handler,
|
|
int32_t iparam = 0,
|
|
ARefBase* vparam = nullptr);
|
|
|
|
void OnMsgReclaimConnection(HttpConnectionBase*);
|
|
|
|
// message handlers
|
|
void OnMsgShutdown(int32_t, ARefBase*);
|
|
void OnMsgShutdownConfirm(int32_t, ARefBase*);
|
|
void OnMsgNewTransaction(int32_t, ARefBase*);
|
|
void OnMsgNewTransactionWithStickyConn(int32_t, ARefBase*);
|
|
void OnMsgReschedTransaction(int32_t, ARefBase*);
|
|
void OnMsgUpdateClassOfServiceOnTransaction(ClassOfService, ARefBase*);
|
|
void OnMsgCancelTransaction(int32_t, ARefBase*);
|
|
void OnMsgCancelTransactions(int32_t, ARefBase*);
|
|
void OnMsgProcessPendingQ(int32_t, ARefBase*);
|
|
void OnMsgPruneDeadConnections(int32_t, ARefBase*);
|
|
void OnMsgSpeculativeConnect(int32_t, ARefBase*);
|
|
void OnMsgCompleteUpgrade(int32_t, ARefBase*);
|
|
void OnMsgUpdateParam(int32_t, ARefBase*);
|
|
void OnMsgDoShiftReloadConnectionCleanup(int32_t, ARefBase*);
|
|
void OnMsgDoSingleConnectionCleanup(int32_t, ARefBase*);
|
|
void OnMsgProcessFeedback(int32_t, ARefBase*);
|
|
void OnMsgProcessAllSpdyPendingQ(int32_t, ARefBase*);
|
|
void OnMsgUpdateRequestTokenBucket(int32_t, ARefBase*);
|
|
void OnMsgVerifyTraffic(int32_t, ARefBase*);
|
|
void OnMsgPruneNoTraffic(int32_t, ARefBase*);
|
|
void OnMsgUpdateCurrentBrowserId(int32_t, ARefBase*);
|
|
void OnMsgClearConnectionHistory(int32_t, ARefBase*);
|
|
void OnMsgStoreServerCertHashes(int32_t, ARefBase*);
|
|
|
|
// Total number of active connections in all of the ConnectionEntry objects
|
|
// that are accessed from mCT connection table.
|
|
uint16_t mNumActiveConns{0};
|
|
// Total number of idle connections in all of the ConnectionEntry objects
|
|
// that are accessed from mCT connection table.
|
|
uint16_t mNumIdleConns{0};
|
|
// Total number of spdy or http3 connections which are a subset of the active
|
|
// conns
|
|
uint16_t mNumSpdyHttp3ActiveConns{0};
|
|
// Total number of connections in DnsAndConnectSockets ConnectionEntry objects
|
|
// that are accessed from mCT connection table
|
|
uint32_t mNumDnsAndConnectSockets{0};
|
|
|
|
// Holds time in seconds for next wake-up to prune dead connections.
|
|
uint64_t mTimeOfNextWakeUp{UINT64_MAX};
|
|
// Timer for next pruning of dead connections.
|
|
nsCOMPtr<nsITimer> mTimer;
|
|
// Timer for pruning stalled connections after changed network.
|
|
nsCOMPtr<nsITimer> mTrafficTimer;
|
|
bool mPruningNoTraffic{false};
|
|
|
|
// A 1s tick to call nsHttpConnection::ReadTimeoutTick on
|
|
// active http/1 connections and check for orphaned half opens.
|
|
// Disabled when there are no active or half open connections.
|
|
nsCOMPtr<nsITimer> mTimeoutTick;
|
|
bool mTimeoutTickArmed{false};
|
|
uint32_t mTimeoutTickNext{1};
|
|
|
|
//
|
|
// the connection table
|
|
//
|
|
// this table is indexed by connection key. each entry is a
|
|
// ConnectionEntry object. It is unlocked and therefore must only
|
|
// be accessed from the socket thread.
|
|
//
|
|
nsRefPtrHashtable<nsCStringHashKey, ConnectionEntry> mCT;
|
|
|
|
// Read Timeout Tick handlers
|
|
void TimeoutTick();
|
|
|
|
// For diagnostics
|
|
void OnMsgPrintDiagnostics(int32_t, ARefBase*);
|
|
|
|
nsCString mLogData;
|
|
uint64_t mCurrentBrowserId{0};
|
|
|
|
// Called on a pref change
|
|
void SetThrottlingEnabled(bool aEnable);
|
|
|
|
// we only want to throttle for a limited amount of time after a new
|
|
// active transaction is added so that we don't block downloads on comet,
|
|
// socket and any kind of longstanding requests that don't need bandwidth.
|
|
// these methods track this time.
|
|
bool InThrottlingTimeWindow();
|
|
|
|
// Two hashtalbes keeping track of active transactions regarding window id and
|
|
// throttling. Used by the throttling algorithm to obtain number of
|
|
// transactions for the active tab and for inactive tabs according their
|
|
// throttle status. mActiveTransactions[0] are all unthrottled transactions,
|
|
// mActiveTransactions[1] throttled.
|
|
nsClassHashtable<nsUint64HashKey, nsTArray<RefPtr<nsHttpTransaction>>>
|
|
mActiveTransactions[2];
|
|
|
|
// V1 specific
|
|
// Whether we are inside the "stop reading" interval, altered by the throttle
|
|
// ticker
|
|
bool mThrottlingInhibitsReading{false};
|
|
|
|
TimeStamp mThrottlingWindowEndsAt;
|
|
|
|
// ticker for the 'stop reading'/'resume reading' signal
|
|
nsCOMPtr<nsITimer> mThrottleTicker;
|
|
// Checks if the combination of active transactions requires the ticker.
|
|
bool IsThrottleTickerNeeded();
|
|
// The method also unschedules the delayed resume of background tabs timer
|
|
// if the ticker was about to be scheduled.
|
|
void EnsureThrottleTickerIfNeeded();
|
|
// V1:
|
|
// Drops also the mThrottlingInhibitsReading flag. Immediate or delayed
|
|
// resume of currently throttled transactions is not affected by this method.
|
|
// V2:
|
|
// Immediate or delayed resume of currently throttled transactions is not
|
|
// affected by this method.
|
|
void DestroyThrottleTicker();
|
|
// V1:
|
|
// Handler for the ticker: alters the mThrottlingInhibitsReading flag.
|
|
// V2:
|
|
// Handler for the ticker: calls ResumeReading() for all throttled
|
|
// transactions.
|
|
void ThrottlerTick();
|
|
|
|
// mechanism to delay immediate resume of background tabs and chrome initiated
|
|
// throttled transactions after the last transaction blocking their unthrottle
|
|
// has been removed. Needs to be delayed because during a page load there is
|
|
// a number of intervals when there is no transaction that would cause
|
|
// throttling. Hence, throttling of long standing responses, like downloads,
|
|
// would be mostly ineffective if resumed during every such interval.
|
|
nsCOMPtr<nsITimer> mDelayedResumeReadTimer;
|
|
// Schedule the resume
|
|
void DelayedResumeBackgroundThrottledTransactions();
|
|
// Simply destroys the timer
|
|
void CancelDelayedResumeBackgroundThrottledTransactions();
|
|
// Handler for the timer: resumes all background throttled transactions
|
|
void ResumeBackgroundThrottledTransactions();
|
|
|
|
// Simple helpers, iterates the given hash/array and resume.
|
|
// @param excludeActive: skip active tabid transactions.
|
|
void ResumeReadOf(
|
|
nsClassHashtable<nsUint64HashKey, nsTArray<RefPtr<nsHttpTransaction>>>&,
|
|
bool excludeForActiveTab = false);
|
|
void ResumeReadOf(nsTArray<RefPtr<nsHttpTransaction>>*);
|
|
|
|
// Cached status of the active tab active transactions existence,
|
|
// saves a lot of hashtable lookups
|
|
bool mActiveTabTransactionsExist{false};
|
|
bool mActiveTabUnthrottledTransactionsExist{false};
|
|
|
|
void LogActiveTransactions(char);
|
|
|
|
// When current active tab is changed, this function uses
|
|
// |previousId| to select background transactions and
|
|
// |mCurrentBrowserId| to select foreground transactions.
|
|
// Then, it notifies selected transactions' connection of the new active tab
|
|
// id.
|
|
void NotifyConnectionOfBrowserIdChange(uint64_t previousId);
|
|
|
|
void CheckTransInPendingQueue(nsHttpTransaction* aTrans);
|
|
|
|
// Used for generating unique IDSs for dedicated connections, currently used
|
|
// by WebTransport
|
|
Atomic<uint64_t> mMaxWebTransportId{1};
|
|
};
|
|
|
|
} // namespace mozilla::net
|
|
|
|
#endif // !nsHttpConnectionMgr_h__
|