/* vim:set ts=4 sw=4 sts=4 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 "nsHttpConnection.h"
#include "nsHttpTransaction.h"
#include "nsTArray.h"
#include "nsThreadUtils.h"
#include "nsClassHashtable.h"
#include "nsDataHashtable.h"
#include "nsAutoPtr.h"
#include "mozilla/ReentrantMonitor.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/Attributes.h"
#include "AlternateServices.h"
#include "ARefBase.h"
#include "nsWeakReference.h"
#include "TCPFastOpen.h"
#include "nsINamed.h"
#include "nsIObserver.h"
#include "nsITimer.h"
class nsIHttpUpgradeListener;
namespace mozilla {
namespace net {
class EventTokenBucket;
class NullHttpTransaction;
struct HttpRetParams;
// 8d411b53-54bc-4a99-8b78-ff125eab1564
#define NS_HALFOPENSOCKET_IID \
{ \
0x8d411b53, 0x54bc, 0x4a99, { \
0x8b, 0x78, 0xff, 0x12, 0x5e, 0xab, 0x15, 0x64 \
} \
}
//-----------------------------------------------------------------------------
// message handlers have this signature
class nsHttpConnectionMgr;
typedef void (nsHttpConnectionMgr::*nsConnEventHandler)(int32_t, ARefBase *);
class nsHttpConnectionMgr final : public nsIObserver, public AltSvcCache {
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOBSERVER
// parameter names
enum nsParamName {
MAX_URGENT_START_Q,
MAX_CONNECTIONS,
MAX_PERSISTENT_CONNECTIONS_PER_HOST,
MAX_PERSISTENT_CONNECTIONS_PER_PROXY,
MAX_REQUEST_DELAY,
THROTTLING_ENABLED,
THROTTLING_SUSPEND_FOR,
THROTTLING_RESUME_FOR,
THROTTLING_READ_LIMIT,
THROTTLING_READ_INTERVAL,
THROTTLING_HOLD_TIME,
THROTTLING_MAX_TIME
};
//-------------------------------------------------------------------------
// NOTE: functions below may only be called on the main thread.
//-------------------------------------------------------------------------
nsHttpConnectionMgr();
MOZ_MUST_USE nsresult
Init(uint16_t maxUrgentExcessiveConns, uint16_t maxConnections,
uint16_t maxPersistentConnectionsPerHost,
uint16_t maxPersistentConnectionsPerProxy, uint16_t maxRequestDelay,
bool throttleEnabled, uint32_t throttleVersion,
uint32_t throttleSuspendFor, uint32_t throttleResumeFor,
uint32_t throttleReadLimit, uint32_t throttleReadInterval,
uint32_t throttleHoldTime, uint32_t throttleMaxTime);
MOZ_MUST_USE nsresult Shutdown();
//-------------------------------------------------------------------------
// 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);
// this cancels all outstanding transactions but does not shut down the mgr
void AbortAndCloseAllConnections(int32_t, ARefBase *);
// 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();
// adds a transaction to the list of managed transactions.
MOZ_MUST_USE nsresult AddTransaction(nsHttpTransaction *, int32_t priority);
// called to reschedule the given transaction. it must already have been
// added to the connection manager via AddTransaction.
MOZ_MUST_USE nsresult RescheduleTransaction(nsHttpTransaction *,
int32_t priority);
// TOOD
void UpdateClassOfServiceOnTransaction(nsHttpTransaction *,
uint32_t classOfService);
// cancels a transaction w/ the given reason.
MOZ_MUST_USE nsresult CancelTransaction(nsHttpTransaction *, nsresult reason);
MOZ_MUST_USE nsresult CancelTransactions(nsHttpConnectionInfo *,
nsresult reason);
// called to force the connection manager to prune its list of idle
// connections.
MOZ_MUST_USE nsresult PruneDeadConnections();
// called to close active connections with no registered "traffic"
MOZ_MUST_USE nsresult PruneNoTraffic();
// "VerifyTraffic" means marking connections now, and then check again in
// N seconds to see if there's been any traffic and if not, kill
// that connection.
MOZ_MUST_USE nsresult VerifyTraffic();
// Close all idle persistent connections and prevent any active connections
// from being reused. Optional connection info resets CI specific
// information such as Happy Eyeballs history.
MOZ_MUST_USE nsresult DoShiftReloadConnectionCleanup(nsHttpConnectionInfo *);
// called to get a reference to the socket transport service. the socket
// transport service is not available when the connection manager is down.
MOZ_MUST_USE nsresult GetSocketThreadTarget(nsIEventTarget **);
// called to indicate a transaction for the connectionInfo is likely coming
// soon. The connection manager may use this information to start a TCP
// and/or SSL level handshake for that resource immediately so that it is
// ready when the transaction is submitted. No obligation is taken on by the
// connection manager, nor is the submitter obligated to actually submit a
// real transaction for this connectionInfo.
MOZ_MUST_USE nsresult SpeculativeConnect(nsHttpConnectionInfo *,
nsIInterfaceRequestor *,
uint32_t caps = 0,
NullHttpTransaction * = nullptr);
// called when a connection is done processing a transaction. if the
// connection can be reused then it will be added to the idle list, else
// it will be closed.
MOZ_MUST_USE nsresult ReclaimConnection(nsHttpConnection *conn);
// called by the main thread to execute the taketransport() logic on the
// socket thread after a 101 response has been received and the socket
// needs to be transferred to an expectant upgrade listener such as
// websockets.
MOZ_MUST_USE nsresult CompleteUpgrade(
nsAHttpConnection *aConn, nsIHttpUpgradeListener *aUpgradeListener);
// called to update a parameter after the connection manager has already
// been initialized.
MOZ_MUST_USE nsresult UpdateParam(nsParamName name, uint16_t value);
// called from main thread to post a new request token bucket
// to the socket thread
MOZ_MUST_USE nsresult UpdateRequestTokenBucket(EventTokenBucket *aBucket);
// clears the connection history mCT
MOZ_MUST_USE nsresult ClearConnectionHistory();
void ReportFailedToProcess(nsIURI *uri);
// Causes a large amount of connection diagnostic information to be
// printed to the javascript console
void PrintDiagnostics();
//-------------------------------------------------------------------------
// 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,
nsHttpConnection *conn);
// called to force the transaction queue to be processed once more, giving
// preference to the specified connection.
MOZ_MUST_USE nsresult ProcessPendingQ(nsHttpConnectionInfo *);
MOZ_MUST_USE bool ProcessPendingQForEntry(nsHttpConnectionInfo *);
// Try and process all pending transactions
MOZ_MUST_USE nsresult ProcessPendingQ();
// 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.
MOZ_MUST_USE nsresult CloseIdleConnection(nsHttpConnection *);
MOZ_MUST_USE nsresult RemoveIdleConnection(nsHttpConnection *);
// 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 GetConnectionData(nsTArray<HttpRetParams> *);
void ResetIPFamilyPreference(nsHttpConnectionInfo *);
uint16_t MaxRequestDelay() { return mMaxRequestDelay; }
// public, so that the SPDY/http2 seesions can activate
void ActivateTimeoutTick();
nsresult UpdateCurrentTopLevelOuterContentWindowId(uint64_t aWindowId);
// 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 CurrentTopLevelOuterContentWindowId() {
return mCurrentTopLevelOuterContentWindowId;
}
private:
virtual ~nsHttpConnectionMgr();
class nsHalfOpenSocket;
class PendingTransactionInfo;
// nsConnectionEntry
//
// mCT maps connection info hash key to nsConnectionEntry object, which
// contains list of active and idle connections as well as the list of
// pending transactions.
//
class nsConnectionEntry {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsConnectionEntry)
explicit nsConnectionEntry(nsHttpConnectionInfo *ci);
RefPtr<nsHttpConnectionInfo> mConnInfo;
nsTArray<RefPtr<PendingTransactionInfo>>
mUrgentStartQ; // the urgent start transaction queue
// This table provides a mapping from top level outer content window id
// to a queue of pending transaction information.
// The transaction's order in pending queue is decided by whether it's a
// blocking transaction and its priority.
// Note that the window id could be 0 if the http request
// is initialized without a window.
nsClassHashtable<nsUint64HashKey, nsTArray<RefPtr<PendingTransactionInfo>>>
mPendingTransactionTable;
nsTArray<RefPtr<nsHttpConnection>> mActiveConns; // active connections
nsTArray<RefPtr<nsHttpConnection>>
mIdleConns; // idle persistent connections
nsTArray<nsHalfOpenSocket *> mHalfOpens; // half open connections
nsTArray<RefPtr<nsHalfOpenSocket>> mHalfOpenFastOpenBackups; // backup half
// open
// connections
// for
// connection
// in fast
// open phase
bool AvailableForDispatchNow();
// calculate the number of half open sockets that have not had at least 1
// connection complete
uint32_t UnconnectedHalfOpens();
// Remove a particular half open socket from the mHalfOpens array
void RemoveHalfOpen(nsHalfOpenSocket *);
// Spdy sometimes resolves the address in the socket manager in order
// to re-coalesce sharded HTTP hosts. The dotted decimal address is
// combined with the Anonymous flag and OA from the connection information
// to build the hash key for hosts in the same ip pool.
//
nsTArray<nsCString> mCoalescingKeys;
// To have the UsingSpdy flag means some host with the same connection
// entry has done NPN=spdy/* at some point. It does not mean every
// connection is currently using spdy.
bool mUsingSpdy : 1;
// Flags to remember our happy-eyeballs decision.
// Reset only by Ctrl-F5 reload.
// True when we've first connected an IPv4 server for this host,
// initially false.
bool mPreferIPv4 : 1;
// True when we've first connected an IPv6 server for this host,
// initially false.
bool mPreferIPv6 : 1;
// True if this connection entry has initiated a socket
bool mUsedForConnection : 1;
// Try using TCP Fast Open.
bool mUseFastOpen : 1;
bool mDoNotDestroy : 1;
// Set the IP family preference flags according the connected family
void RecordIPFamilyPreference(uint16_t family);
// Resets all flags to their default values
void ResetIPFamilyPreference();
// Return the count of pending transactions for all window ids.
size_t PendingQLength() const;
// Add a transaction information into the pending queue in
// |mPendingTransactionTable| according to the transaction's
// top level outer content window id.
void InsertTransaction(PendingTransactionInfo *info,
bool aInsertAsFirstForTheSamePriority = false);
// Append transactions to the |result| whose window id
// is equal to |windowId|.
// NOTE: maxCount == 0 will get all transactions in the queue.
void AppendPendingQForFocusedWindow(
uint64_t windowId, nsTArray<RefPtr<PendingTransactionInfo>> &result,
uint32_t maxCount = 0);
// Append transactions whose window id isn't equal to |windowId|.
// NOTE: windowId == 0 will get all transactions for both
// focused and non-focused windows.
void AppendPendingQForNonFocusedWindows(
uint64_t windowId, nsTArray<RefPtr<PendingTransactionInfo>> &result,
uint32_t maxCount = 0);
// Remove the empty pendingQ in |mPendingTransactionTable|.
void RemoveEmptyPendingQ();
private:
~nsConnectionEntry();
};
public:
static nsAHttpConnection *MakeConnectionHandle(nsHttpConnection *aWrapped);
void RegisterOriginCoalescingKey(nsHttpConnection *, const nsACString &host,
int32_t port);
private:
// nsHalfOpenSocket is used to hold the state of an opening TCP socket
// while we wait for it to establish and bind it to a connection
class nsHalfOpenSocket final : public nsIOutputStreamCallback,
public nsITransportEventSink,
public nsIInterfaceRequestor,
public nsITimerCallback,
public nsINamed,
public nsSupportsWeakReference,
public TCPFastOpen {
~nsHalfOpenSocket();
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_HALFOPENSOCKET_IID)
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAMCALLBACK
NS_DECL_NSITRANSPORTEVENTSINK
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSITIMERCALLBACK
NS_DECL_NSINAMED
nsHalfOpenSocket(nsConnectionEntry *ent, nsAHttpTransaction *trans,
uint32_t caps, bool speculative, bool isFromPredictor,
bool urgentStart);
MOZ_MUST_USE nsresult SetupStreams(nsISocketTransport **,
nsIAsyncInputStream **,
nsIAsyncOutputStream **, bool isBackup);
MOZ_MUST_USE nsresult SetupPrimaryStreams();
MOZ_MUST_USE nsresult SetupBackupStreams();
void SetupBackupTimer();
void CancelBackupTimer();
void Abandon();
double Duration(TimeStamp epoch);
nsISocketTransport *SocketTransport() { return mSocketTransport; }
nsISocketTransport *BackupTransport() { return mBackupTransport; }
nsAHttpTransaction *Transaction() { return mTransaction; }
bool IsSpeculative() { return mSpeculative; }
bool IsFromPredictor() { return mIsFromPredictor; }
bool Allow1918() { return mAllow1918; }
void SetAllow1918(bool val) { mAllow1918 = val; }
bool HasConnected() { return mHasConnected; }
void PrintDiagnostics(nsCString &log);
// Checks whether the transaction can be dispatched using this
// half-open's connection. If this half-open is marked as urgent-start,
// it only accepts urgent start transactions. Call only before Claim().
bool AcceptsTransaction(nsHttpTransaction *trans);
bool Claim();
void Unclaim();
bool FastOpenEnabled() override;
nsresult StartFastOpen() override;
void SetFastOpenConnected(nsresult, bool aWillRetry) override;
void FastOpenNotSupported() override;
void SetFastOpenStatus(uint8_t tfoStatus) override;
void CancelFastOpenConnection();
private:
nsresult SetupConn(nsIAsyncOutputStream *out, bool aFastOpen);
// To find out whether |mTransaction| is still in the connection entry's
// pending queue. If the transaction is found and |removeWhenFound| is
// true, the transaction will be removed from the pending queue.
already_AddRefed<PendingTransactionInfo> FindTransactionHelper(
bool removeWhenFound);
RefPtr<nsAHttpTransaction> mTransaction;
bool mDispatchedMTransaction;
nsCOMPtr<nsISocketTransport> mSocketTransport;
nsCOMPtr<nsIAsyncOutputStream> mStreamOut;
nsCOMPtr<nsIAsyncInputStream> mStreamIn;
uint32_t mCaps;
// mSpeculative is set if the socket was created from
// SpeculativeConnect(). It is cleared when a transaction would normally
// start a new connection from scratch but instead finds this one in
// the half open list and claims it for its own use. (which due to
// the vagaries of scheduling from the pending queue might not actually
// match up - but it prevents a speculative connection from opening
// more connections that are needed.)
bool mSpeculative;
// If created with a non-null urgent transaction, remember it, so we can
// mark the connection as urgent rightaway it's created.
bool mUrgentStart;
// mIsFromPredictor is set if the socket originated from the network
// Predictor. It is used to gather telemetry data on used speculative
// connections from the predictor.
bool mIsFromPredictor;
bool mAllow1918;
TimeStamp mPrimarySynStarted;
TimeStamp mBackupSynStarted;
// mHasConnected tracks whether one of the sockets has completed the
// connection process. It may have completed unsuccessfully.
bool mHasConnected;
bool mPrimaryConnectedOK;
bool mBackupConnectedOK;
bool mBackupConnStatsSet;
// A nsHalfOpenSocket can be made for a concrete non-null transaction,
// but the transaction can be dispatch to another connection. In that
// case we can free this transaction to be claimed by other
// transactions.
bool mFreeToUse;
nsresult mPrimaryStreamStatus;
bool mFastOpenInProgress;
RefPtr<nsHttpConnection> mConnectionNegotiatingFastOpen;
uint8_t mFastOpenStatus;
RefPtr<nsConnectionEntry> mEnt;
nsCOMPtr<nsITimer> mSynTimer;
nsCOMPtr<nsISocketTransport> mBackupTransport;
nsCOMPtr<nsIAsyncOutputStream> mBackupStreamOut;
nsCOMPtr<nsIAsyncInputStream> mBackupStreamIn;
};
friend class nsHalfOpenSocket;
class PendingTransactionInfo : public ARefBase {
public:
explicit PendingTransactionInfo(nsHttpTransaction *trans)
: mTransaction(trans) {}
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PendingTransactionInfo, override)
void PrintDiagnostics(nsCString &log);
public: // meant to be public.
RefPtr<nsHttpTransaction> mTransaction;
nsWeakPtr mHalfOpen;
nsWeakPtr mActiveConn;
private:
virtual ~PendingTransactionInfo() {}
};
friend class PendingTransactionInfo;
class PendingComparator {
public:
bool Equals(const PendingTransactionInfo *aPendingTrans,
const nsAHttpTransaction *aTrans) const {
return aPendingTrans->mTransaction.get() == aTrans;
}
};
//-------------------------------------------------------------------------
// NOTE: these members may be accessed from any thread (use mReentrantMonitor)
//-------------------------------------------------------------------------
ReentrantMonitor mReentrantMonitor;
nsCOMPtr<nsIEventTarget> mSocketThreadTarget;
// connection limits
uint16_t mMaxUrgentExcessiveConns;
uint16_t mMaxConns;
uint16_t mMaxPersistConnsPerHost;
uint16_t mMaxPersistConnsPerProxy;
uint16_t mMaxRequestDelay; // in seconds
bool mThrottleEnabled;
uint32_t mThrottleVersion;
uint32_t mThrottleSuspendFor;
uint32_t mThrottleResumeFor;
uint32_t mThrottleReadLimit;
uint32_t mThrottleReadInterval;
uint32_t mThrottleHoldTime;
TimeDuration mThrottleMaxTime;
Atomic<bool, mozilla::Relaxed> mIsShuttingDown;
//-------------------------------------------------------------------------
// NOTE: these members are only accessed on the socket transport thread
//-------------------------------------------------------------------------
MOZ_MUST_USE bool ProcessPendingQForEntry(nsConnectionEntry *,
bool considerAll);
bool DispatchPendingQ(nsTArray<RefPtr<PendingTransactionInfo>> &pendingQ,
nsConnectionEntry *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(
nsConnectionEntry *ent,
nsTArray<RefPtr<PendingTransactionInfo>> &pendingQ, bool considerAll);
// Return total active connection count, which is the sum of
// active connections and unconnected half open connections.
uint32_t TotalActiveConnections(nsConnectionEntry *ent) const;
// Return |mMaxPersistConnsPerProxy| or |mMaxPersistConnsPerHost|,
// depending whether the proxy is used.
uint32_t MaxPersistConnections(nsConnectionEntry *ent) const;
bool AtActiveConnectionLimit(nsConnectionEntry *, uint32_t caps);
MOZ_MUST_USE nsresult
TryDispatchTransaction(nsConnectionEntry *ent, bool onlyReusedConnection,
PendingTransactionInfo *pendingTransInfo);
MOZ_MUST_USE nsresult TryDispatchTransactionOnIdleConn(
nsConnectionEntry *ent, PendingTransactionInfo *pendingTransInfo,
bool respectUrgency, bool *allUrgent = nullptr);
MOZ_MUST_USE nsresult DispatchTransaction(nsConnectionEntry *,
nsHttpTransaction *,
nsHttpConnection *);
MOZ_MUST_USE nsresult DispatchAbstractTransaction(nsConnectionEntry *,
nsAHttpTransaction *,
uint32_t,
nsHttpConnection *,
int32_t);
bool RestrictConnections(nsConnectionEntry *);
MOZ_MUST_USE nsresult ProcessNewTransaction(nsHttpTransaction *);
MOZ_MUST_USE nsresult EnsureSocketThreadTarget();
void ClosePersistentConnections(nsConnectionEntry *ent);
void ReportProxyTelemetry(nsConnectionEntry *ent);
MOZ_MUST_USE nsresult
CreateTransport(nsConnectionEntry *, nsAHttpTransaction *, uint32_t, bool,
bool, bool, bool, PendingTransactionInfo *pendingTransInfo);
void AddActiveConn(nsHttpConnection *, nsConnectionEntry *);
void DecrementActiveConnCount(nsHttpConnection *);
void StartedConnect();
void RecvdConnect();
// This function will unclaim the claimed connection or set a halfOpen
// socket to the speculative state if the transaction claiming them ends up
// using another connection.
void ReleaseClaimedSockets(nsConnectionEntry *ent,
PendingTransactionInfo *pendingTransInfo);
void InsertTransactionSorted(
nsTArray<RefPtr<PendingTransactionInfo>> &pendingQ,
PendingTransactionInfo *pendingTransInfo,
bool aInsertAsFirstForTheSamePriority = false);
nsConnectionEntry *GetOrCreateConnectionEntry(nsHttpConnectionInfo *,
bool allowWildCard);
MOZ_MUST_USE nsresult MakeNewConnection(
nsConnectionEntry *ent, PendingTransactionInfo *pendingTransInfo);
// Manage h2 connection coalescing
// The hashtable contains arrays of weak pointers to nsHttpConnections
nsClassHashtable<nsCStringHashKey, nsTArray<nsWeakPtr>> mCoalescingHash;
nsHttpConnection *FindCoalescableConnection(nsConnectionEntry *ent,
bool justKidding);
nsHttpConnection *FindCoalescableConnectionByHashKey(nsConnectionEntry *ent,
const nsCString &key,
bool justKidding);
void UpdateCoalescingForNewConn(nsHttpConnection *conn,
nsConnectionEntry *ent);
nsHttpConnection *GetSpdyActiveConn(nsConnectionEntry *ent);
void ProcessSpdyPendingQ(nsConnectionEntry *ent);
void DispatchSpdyPendingQ(nsTArray<RefPtr<PendingTransactionInfo>> &pendingQ,
nsConnectionEntry *ent, nsHttpConnection *conn);
// used to marshall events to the socket transport thread.
MOZ_MUST_USE nsresult PostEvent(nsConnEventHandler handler,
int32_t iparam = 0,
ARefBase *vparam = nullptr);
// Used to close all transactions in the |pendingQ| with the given |reason|.
// Note that the |pendingQ| will be also cleared.
void CancelTransactionsHelper(
nsTArray<RefPtr<PendingTransactionInfo>> &pendingQ,
const nsHttpConnectionInfo *ci, const nsConnectionEntry *ent,
nsresult reason);
// message handlers
void OnMsgShutdown(int32_t, ARefBase *);
void OnMsgShutdownConfirm(int32_t, ARefBase *);
void OnMsgNewTransaction(int32_t, ARefBase *);
void OnMsgReschedTransaction(int32_t, ARefBase *);
void OnMsgUpdateClassOfServiceOnTransaction(int32_t, 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 OnMsgReclaimConnection(int32_t, ARefBase *);
void OnMsgCompleteUpgrade(int32_t, ARefBase *);
void OnMsgUpdateParam(int32_t, ARefBase *);
void OnMsgDoShiftReloadConnectionCleanup(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 OnMsgUpdateCurrentTopLevelOuterContentWindowId(int32_t, ARefBase *);
// Total number of active connections in all of the ConnectionEntry objects
// that are accessed from mCT connection table.
uint16_t mNumActiveConns;
// Total number of idle connections in all of the ConnectionEntry objects
// that are accessed from mCT connection table.
uint16_t mNumIdleConns;
// Total number of spdy connections which are a subset of the active conns
uint16_t mNumSpdyActiveConns;
// Total number of connections in mHalfOpens ConnectionEntry objects
// that are accessed from mCT connection table
uint32_t mNumHalfOpenConns;
// Holds time in seconds for next wake-up to prune dead connections.
uint64_t mTimeOfNextWakeUp;
// Timer for next pruning of dead connections.
nsCOMPtr<nsITimer> mTimer;
// Timer for pruning stalled connections after changed network.
nsCOMPtr<nsITimer> mTrafficTimer;
bool mPruningNoTraffic;
// 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;
uint32_t mTimeoutTickNext;
//
// the connection table
//
// this table is indexed by connection key. each entry is a
// nsConnectionEntry object. It is unlocked and therefore must only
// be accessed from the socket thread.
//
nsRefPtrHashtable<nsCStringHashKey, nsConnectionEntry> mCT;
// Read Timeout Tick handlers
void TimeoutTick();
// For diagnostics
void OnMsgPrintDiagnostics(int32_t, ARefBase *);
nsCString mLogData;
uint64_t mCurrentTopLevelOuterContentWindowId;
// 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;
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 excludeActive = false);
void ResumeReadOf(nsTArray<RefPtr<nsHttpTransaction>> *);
// Cached status of the active tab active transactions existence,
// saves a lot of hashtable lookups
bool mActiveTabTransactionsExist;
bool mActiveTabUnthrottledTransactionsExist;
void LogActiveTransactions(char);
nsTArray<RefPtr<PendingTransactionInfo>> *GetTransactionPendingQHelper(
nsConnectionEntry *ent, nsAHttpTransaction *trans);
// When current active tab is changed, this function uses
// |previousWindowId| to select background transactions and
// mCurrentTopLevelOuterContentWindowId| to select foreground transactions.
// Then, it notifies selected transactions' connection of the new active tab
// id.
void NotifyConnectionOfWindowIdChange(uint64_t previousWindowId);
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsHttpConnectionMgr::nsHalfOpenSocket,
NS_HALFOPENSOCKET_IID)
} // namespace net
} // namespace mozilla
#endif // !nsHttpConnectionMgr_h__