The Tor Browser: comparison netwerk/protocol/http/nsHttpConnectionMgr.cpp

--1:000000000000
+:eb5afc0ded76
+/* 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/. */
+// HttpLog.h should generally be included first
+#include "HttpLog.h"
+// Log on level :5, instead of default :4.
+#undef LOG
+#define LOG(args) LOG5(args)
+#undef LOG_ENABLED
+#define LOG_ENABLED() LOG5_ENABLED()
+#include "nsHttpConnectionMgr.h"
+#include "nsHttpConnection.h"
+#include "nsHttpPipeline.h"
+#include "nsHttpHandler.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsNetCID.h"
+#include "nsCOMPtr.h"
+#include "nsNetUtil.h"
+#include "mozilla/net/DNS.h"
+#include "nsISocketTransport.h"
+#include "nsISSLSocketControl.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/net/DashboardTypes.h"
+#include "NullHttpTransaction.h"
+#include "nsITransport.h"
+#include "nsISocketTransportService.h"
+#include <algorithm>
+#include "Http2Compression.h"
+#include "mozilla/ChaosMode.h"
+#include "mozilla/unused.h"
+#include <stdlib.h>
+#include "nsHttpRequestHead.h"
+// defined by the socket transport service while active
+extern PRThread *gSocketThread;
+namespace mozilla {
+namespace net {
+//-----------------------------------------------------------------------------
+NS_IMPL_ISUPPORTS(nsHttpConnectionMgr, nsIObserver)
+static void
+InsertTransactionSorted(nsTArray<nsHttpTransaction*> &pendingQ, nsHttpTransaction *trans)
+{
+// insert into queue with smallest valued number first.  search in reverse
+// order under the assumption that many of the existing transactions will
+// have the same priority (usually 0).
+uint32_t len = pendingQ.Length();
+if (pendingQ.IsEmpty()) {
+pendingQ.InsertElementAt(0, trans);
+return;
+}
+pendingQ.InsertElementAt(0, trans);
+// FIXME: Refactor into standalone helper (for nsHttpPipeline)
+// Or at least simplify this function if this shuffle ends up
+// being an improvement.
+uint32_t i = 0;
+for (i=0; i < len; ++i) {
+uint32_t ridx = rand() % len;
+nsHttpTransaction *tmp = pendingQ[i];
+pendingQ[i] = pendingQ[ridx];
+pendingQ[ridx] = tmp;
+}
+}
+//-----------------------------------------------------------------------------
+nsHttpConnectionMgr::nsHttpConnectionMgr()
+: mReentrantMonitor("nsHttpConnectionMgr.mReentrantMonitor")
+, mMaxConns(0)
+, mMaxPersistConnsPerHost(0)
+, mMaxPersistConnsPerProxy(0)
+, mIsShuttingDown(false)
+, mNumActiveConns(0)
+, mNumIdleConns(0)
+, mNumSpdyActiveConns(0)
+, mNumHalfOpenConns(0)
+, mTimeOfNextWakeUp(UINT64_MAX)
+, mTimeoutTickArmed(false)
+, mTimeoutTickNext(1)
+{
+LOG(("Creating nsHttpConnectionMgr @%x\n", this));
+}
+nsHttpConnectionMgr::~nsHttpConnectionMgr()
+{
+LOG(("Destroying nsHttpConnectionMgr @%x\n", this));
+if (mTimeoutTick)
+mTimeoutTick->Cancel();
+}
+nsresult
+nsHttpConnectionMgr::EnsureSocketThreadTarget()
+{
+nsresult rv;
+nsCOMPtr<nsIEventTarget> sts;
+nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);
+if (NS_SUCCEEDED(rv))
+sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+// do nothing if already initialized or if we've shut down
+if (mSocketThreadTarget || mIsShuttingDown)
+return NS_OK;
+mSocketThreadTarget = sts;
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::Init(uint16_t maxConns,
+uint16_t maxPersistConnsPerHost,
+uint16_t maxPersistConnsPerProxy,
+uint16_t maxRequestDelay,
+uint16_t maxPipelinedRequests,
+uint16_t maxOptimisticPipelinedRequests)
+{
+LOG(("nsHttpConnectionMgr::Init\n"));
+{
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+mMaxConns = maxConns;
+mMaxPersistConnsPerHost = maxPersistConnsPerHost;
+mMaxPersistConnsPerProxy = maxPersistConnsPerProxy;
+mMaxRequestDelay = maxRequestDelay;
+mMaxPipelinedRequests = maxPipelinedRequests;
+mMaxOptimisticPipelinedRequests = maxOptimisticPipelinedRequests;
+mIsShuttingDown = false;
+}
+return EnsureSocketThreadTarget();
+}
+nsresult
+nsHttpConnectionMgr::Shutdown()
+{
+LOG(("nsHttpConnectionMgr::Shutdown\n"));
+bool shutdown = false;
+{
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+// do nothing if already shutdown
+if (!mSocketThreadTarget)
+return NS_OK;
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgShutdown,
+0, &shutdown);
+// release our reference to the STS to prevent further events
+// from being posted.  this is how we indicate that we are
+// shutting down.
+mIsShuttingDown = true;
+mSocketThreadTarget = 0;
+if (NS_FAILED(rv)) {
+NS_WARNING("unable to post SHUTDOWN message");
+return rv;
+}
+}
+// wait for shutdown event to complete
+while (!shutdown)
+NS_ProcessNextEvent(NS_GetCurrentThread());
+Http2CompressionCleanup();
+return NS_OK;
+}
+nsresult
+nsHttpConnectionMgr::PostEvent(nsConnEventHandler handler, int32_t iparam, void *vparam)
+{
+EnsureSocketThreadTarget();
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+nsresult rv;
+if (!mSocketThreadTarget) {
+NS_WARNING("cannot post event if not initialized");
+rv = NS_ERROR_NOT_INITIALIZED;
+}
+else {
+nsRefPtr<nsIRunnable> event = new nsConnEvent(this, handler, iparam, vparam);
+rv = mSocketThreadTarget->Dispatch(event, NS_DISPATCH_NORMAL);
+}
+return rv;
+}
+void
+nsHttpConnectionMgr::PruneDeadConnectionsAfter(uint32_t timeInSeconds)
+{
+LOG(("nsHttpConnectionMgr::PruneDeadConnectionsAfter\n"));
+if(!mTimer)
+mTimer = do_CreateInstance("@mozilla.org/timer;1");
+// failure to create a timer is not a fatal error, but idle connections
+// will not be cleaned up until we try to use them.
+if (mTimer) {
+mTimeOfNextWakeUp = timeInSeconds + NowInSeconds();
+mTimer->Init(this, timeInSeconds*1000, nsITimer::TYPE_ONE_SHOT);
+} else {
+NS_WARNING("failed to create: timer for pruning the dead connections!");
+}
+}
+void
+nsHttpConnectionMgr::ConditionallyStopPruneDeadConnectionsTimer()
+{
+// Leave the timer in place if there are connections that potentially
+// need management
+if (mNumIdleConns || (mNumActiveConns && gHttpHandler->IsSpdyEnabled()))
+return;
+LOG(("nsHttpConnectionMgr::StopPruneDeadConnectionsTimer\n"));
+// Reset mTimeOfNextWakeUp so that we can find a new shortest value.
+mTimeOfNextWakeUp = UINT64_MAX;
+if (mTimer) {
+mTimer->Cancel();
+mTimer = nullptr;
+}
+}
+void
+nsHttpConnectionMgr::ConditionallyStopTimeoutTick()
+{
+LOG(("nsHttpConnectionMgr::ConditionallyStopTimeoutTick "
+"armed=%d active=%d\n", mTimeoutTickArmed, mNumActiveConns));
+if (!mTimeoutTickArmed)
+return;
+if (mNumActiveConns)
+return;
+LOG(("nsHttpConnectionMgr::ConditionallyStopTimeoutTick stop==true\n"));
+mTimeoutTick->Cancel();
+mTimeoutTickArmed = false;
+}
+//-----------------------------------------------------------------------------
+// nsHttpConnectionMgr::nsIObserver
+//-----------------------------------------------------------------------------
+NS_IMETHODIMP
+nsHttpConnectionMgr::Observe(nsISupports *subject,
+const char *topic,
+const char16_t *data)
+{
+LOG(("nsHttpConnectionMgr::Observe [topic=\"%s\"]\n", topic));
+if (0 == strcmp(topic, NS_TIMER_CALLBACK_TOPIC)) {
+nsCOMPtr<nsITimer> timer = do_QueryInterface(subject);
+if (timer == mTimer) {
+PruneDeadConnections();
+}
+else if (timer == mTimeoutTick) {
+TimeoutTick();
+}
+else {
+MOZ_ASSERT(false, "unexpected timer-callback");
+LOG(("Unexpected timer object\n"));
+return NS_ERROR_UNEXPECTED;
+}
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------------------
+nsresult
+nsHttpConnectionMgr::AddTransaction(nsHttpTransaction *trans, int32_t priority)
+{
+LOG(("nsHttpConnectionMgr::AddTransaction [trans=%x %d]\n", trans, priority));
+NS_ADDREF(trans);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgNewTransaction, priority, trans);
+if (NS_FAILED(rv))
+NS_RELEASE(trans);
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::RescheduleTransaction(nsHttpTransaction *trans, int32_t priority)
+{
+LOG(("nsHttpConnectionMgr::RescheduleTransaction [trans=%x %d]\n", trans, priority));
+NS_ADDREF(trans);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgReschedTransaction, priority, trans);
+if (NS_FAILED(rv))
+NS_RELEASE(trans);
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::CancelTransaction(nsHttpTransaction *trans, nsresult reason)
+{
+LOG(("nsHttpConnectionMgr::CancelTransaction [trans=%x reason=%x]\n", trans, reason));
+NS_ADDREF(trans);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgCancelTransaction,
+static_cast<int32_t>(reason), trans);
+if (NS_FAILED(rv))
+NS_RELEASE(trans);
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::PruneDeadConnections()
+{
+return PostEvent(&nsHttpConnectionMgr::OnMsgPruneDeadConnections);
+}
+nsresult
+nsHttpConnectionMgr::DoShiftReloadConnectionCleanup(nsHttpConnectionInfo *aCI)
+{
+nsRefPtr<nsHttpConnectionInfo> connInfo(aCI);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgDoShiftReloadConnectionCleanup,
+0, connInfo);
+if (NS_SUCCEEDED(rv))
+unused << connInfo.forget();
+return rv;
+}
+class SpeculativeConnectArgs
+{
+public:
+SpeculativeConnectArgs() { mOverridesOK = false; }
+virtual ~SpeculativeConnectArgs() {}
+// Added manually so we can use nsRefPtr without inheriting from
+// nsISupports
+NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
+NS_IMETHOD_(MozExternalRefCountType) Release(void);
+public: // intentional!
+nsRefPtr<NullHttpTransaction> mTrans;
+bool mOverridesOK;
+uint32_t mParallelSpeculativeConnectLimit;
+bool mIgnoreIdle;
+bool mIgnorePossibleSpdyConnections;
+// As above, added manually so we can use nsRefPtr without inheriting from
+// nsISupports
+protected:
+ThreadSafeAutoRefCnt mRefCnt;
+NS_DECL_OWNINGTHREAD
+};
+NS_IMPL_ADDREF(SpeculativeConnectArgs)
+NS_IMPL_RELEASE(SpeculativeConnectArgs)
+nsresult
+nsHttpConnectionMgr::SpeculativeConnect(nsHttpConnectionInfo *ci,
+nsIInterfaceRequestor *callbacks,
+uint32_t caps)
+{
+MOZ_ASSERT(NS_IsMainThread(), "nsHttpConnectionMgr::SpeculativeConnect called off main thread!");
+LOG(("nsHttpConnectionMgr::SpeculativeConnect [ci=%s]\n",
+ci->HashKey().get()));
+// Hosts that are Local IP Literals should not be speculatively
+// connected - Bug 853423.
+if (ci && ci->HostIsLocalIPLiteral()) {
+LOG(("nsHttpConnectionMgr::SpeculativeConnect skipping RFC1918 "
+"address [%s]", ci->Host()));
+return NS_OK;
+}
+nsRefPtr<SpeculativeConnectArgs> args = new SpeculativeConnectArgs();
+// Wrap up the callbacks and the target to ensure they're released on the target
+// thread properly.
+nsCOMPtr<nsIInterfaceRequestor> wrappedCallbacks;
+NS_NewInterfaceRequestorAggregation(callbacks, nullptr, getter_AddRefs(wrappedCallbacks));
+caps |= ci->GetAnonymous() ? NS_HTTP_LOAD_ANONYMOUS : 0;
+args->mTrans = new NullHttpTransaction(ci, wrappedCallbacks, caps);
+nsCOMPtr<nsISpeculativeConnectionOverrider> overrider =
+do_GetInterface(callbacks);
+if (overrider) {
+args->mOverridesOK = true;
+overrider->GetParallelSpeculativeConnectLimit(
+&args->mParallelSpeculativeConnectLimit);
+overrider->GetIgnoreIdle(&args->mIgnoreIdle);
+overrider->GetIgnorePossibleSpdyConnections(
+&args->mIgnorePossibleSpdyConnections);
+}
+nsresult rv =
+PostEvent(&nsHttpConnectionMgr::OnMsgSpeculativeConnect, 0, args);
+if (NS_SUCCEEDED(rv))
+unused << args.forget();
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::GetSocketThreadTarget(nsIEventTarget **target)
+{
+EnsureSocketThreadTarget();
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+NS_IF_ADDREF(*target = mSocketThreadTarget);
+return NS_OK;
+}
+nsresult
+nsHttpConnectionMgr::ReclaimConnection(nsHttpConnection *conn)
+{
+LOG(("nsHttpConnectionMgr::ReclaimConnection [conn=%x]\n", conn));
+NS_ADDREF(conn);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgReclaimConnection, 0, conn);
+if (NS_FAILED(rv))
+NS_RELEASE(conn);
+return rv;
+}
+// A structure used to marshall 2 pointers across the various necessary
+// threads to complete an HTTP upgrade.
+class nsCompleteUpgradeData
+{
+public:
+nsCompleteUpgradeData(nsAHttpConnection *aConn,
+nsIHttpUpgradeListener *aListener)
+: mConn(aConn), mUpgradeListener(aListener) {}
+nsRefPtr<nsAHttpConnection> mConn;
+nsCOMPtr<nsIHttpUpgradeListener> mUpgradeListener;
+};
+nsresult
+nsHttpConnectionMgr::CompleteUpgrade(nsAHttpConnection *aConn,
+nsIHttpUpgradeListener *aUpgradeListener)
+{
+nsCompleteUpgradeData *data =
+new nsCompleteUpgradeData(aConn, aUpgradeListener);
+nsresult rv;
+rv = PostEvent(&nsHttpConnectionMgr::OnMsgCompleteUpgrade, 0, data);
+if (NS_FAILED(rv))
+delete data;
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::UpdateParam(nsParamName name, uint16_t value)
+{
+uint32_t param = (uint32_t(name) << 16) | uint32_t(value);
+return PostEvent(&nsHttpConnectionMgr::OnMsgUpdateParam, 0,
+(void *)(uintptr_t) param);
+}
+nsresult
+nsHttpConnectionMgr::ProcessPendingQ(nsHttpConnectionInfo *ci)
+{
+LOG(("nsHttpConnectionMgr::ProcessPendingQ [ci=%s]\n", ci->HashKey().get()));
+NS_ADDREF(ci);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgProcessPendingQ, 0, ci);
+if (NS_FAILED(rv))
+NS_RELEASE(ci);
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::ProcessPendingQ()
+{
+LOG(("nsHttpConnectionMgr::ProcessPendingQ [All CI]\n"));
+return PostEvent(&nsHttpConnectionMgr::OnMsgProcessPendingQ, 0, nullptr);
+}
+void
+nsHttpConnectionMgr::OnMsgUpdateRequestTokenBucket(int32_t, void *param)
+{
+nsRefPtr<EventTokenBucket> tokenBucket =
+dont_AddRef(static_cast<EventTokenBucket *>(param));
+gHttpHandler->SetRequestTokenBucket(tokenBucket);
+}
+nsresult
+nsHttpConnectionMgr::UpdateRequestTokenBucket(EventTokenBucket *aBucket)
+{
+nsRefPtr<EventTokenBucket> bucket(aBucket);
+// Call From main thread when a new EventTokenBucket has been made in order
+// to post the new value to the socket thread.
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgUpdateRequestTokenBucket,
+0, bucket);
+if (NS_SUCCEEDED(rv))
+unused << bucket.forget();
+return rv;
+}
+// Given a nsHttpConnectionInfo find the connection entry object that
+// contains either the nshttpconnection or nshttptransaction parameter.
+// Normally this is done by the hashkey lookup of connectioninfo,
+// but if spdy coalescing is in play it might be found in a redirected
+// entry
+nsHttpConnectionMgr::nsConnectionEntry *
+nsHttpConnectionMgr::LookupConnectionEntry(nsHttpConnectionInfo *ci,
+nsHttpConnection *conn,
+nsHttpTransaction *trans)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+if (!ci)
+return nullptr;
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+// If there is no sign of coalescing (or it is disabled) then just
+// return the primary hash lookup
+if (!ent || !ent->mUsingSpdy || ent->mCoalescingKey.IsEmpty())
+return ent;
+// If there is no preferred coalescing entry for this host (or the
+// preferred entry is the one that matched the mCT hash lookup) then
+// there is only option
+nsConnectionEntry *preferred = mSpdyPreferredHash.Get(ent->mCoalescingKey);
+if (!preferred || (preferred == ent))
+return ent;
+if (conn) {
+// The connection could be either in preferred or ent. It is most
+// likely the only active connection in preferred - so start with that.
+if (preferred->mActiveConns.Contains(conn))
+return preferred;
+if (preferred->mIdleConns.Contains(conn))
+return preferred;
+}
+if (trans && preferred->mPendingQ.Contains(trans))
+return preferred;
+// Neither conn nor trans found in preferred, use the default entry
+return ent;
+}
+nsresult
+nsHttpConnectionMgr::CloseIdleConnection(nsHttpConnection *conn)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::CloseIdleConnection %p conn=%p",
+this, conn));
+if (!conn->ConnectionInfo())
+return NS_ERROR_UNEXPECTED;
+nsConnectionEntry *ent = LookupConnectionEntry(conn->ConnectionInfo(),
+conn, nullptr);
+if (!ent || !ent->mIdleConns.RemoveElement(conn))
+return NS_ERROR_UNEXPECTED;
+conn->Close(NS_ERROR_ABORT);
+NS_RELEASE(conn);
+mNumIdleConns--;
+ConditionallyStopPruneDeadConnectionsTimer();
+return NS_OK;
+}
+// This function lets a connection, after completing the NPN phase,
+// report whether or not it is using spdy through the usingSpdy
+// argument. It would not be necessary if NPN were driven out of
+// the connection manager. The connection entry associated with the
+// connection is then updated to indicate whether or not we want to use
+// spdy with that host and update the preliminary preferred host
+// entries used for de-sharding hostsnames.
+void
+nsHttpConnectionMgr::ReportSpdyConnection(nsHttpConnection *conn,
+bool usingSpdy)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsConnectionEntry *ent = LookupConnectionEntry(conn->ConnectionInfo(),
+conn, nullptr);
+if (!ent)
+return;
+ent->mTestedSpdy = true;
+if (!usingSpdy)
+return;
+ent->mUsingSpdy = true;
+mNumSpdyActiveConns++;
+uint32_t ttl = conn->TimeToLive();
+uint64_t timeOfExpire = NowInSeconds() + ttl;
+if (!mTimer || timeOfExpire < mTimeOfNextWakeUp)
+PruneDeadConnectionsAfter(ttl);
+// Lookup preferred directly from the hash instead of using
+// GetSpdyPreferredEnt() because we want to avoid the cert compatibility
+// check at this point because the cert is never part of the hash
+// lookup. Filtering on that has to be done at the time of use
+// rather than the time of registration (i.e. now).
+nsConnectionEntry *joinedConnection;
+nsConnectionEntry *preferred =
+mSpdyPreferredHash.Get(ent->mCoalescingKey);
+LOG(("ReportSpdyConnection %s %s ent=%p preferred=%p\n",
+ent->mConnInfo->Host(), ent->mCoalescingKey.get(),
+ent, preferred));
+if (!preferred) {
+if (!ent->mCoalescingKey.IsEmpty()) {
+mSpdyPreferredHash.Put(ent->mCoalescingKey, ent);
+ent->mSpdyPreferred = true;
+preferred = ent;
+}
+} else if ((preferred != ent) &&
+(joinedConnection = GetSpdyPreferredEnt(ent)) &&
+(joinedConnection != ent)) {
+//
+// A connection entry (e.g. made with a different hostname) with
+// the same IP address is preferred for future transactions over this
+// connection entry. Gracefully close down the connection to help
+// new transactions migrate over.
+LOG(("ReportSpdyConnection graceful close of conn=%p ent=%p to "
+"migrate to preferred\n", conn, ent));
+conn->DontReuse();
+} else if (preferred != ent) {
+LOG (("ReportSpdyConnection preferred host may be in false start or "
+"may have insufficient cert. Leave mapping in place but do not "
+"abandon this connection yet."));
+}
+PostEvent(&nsHttpConnectionMgr::OnMsgProcessAllSpdyPendingQ);
+}
+void
+nsHttpConnectionMgr::ReportSpdyCWNDSetting(nsHttpConnectionInfo *ci,
+uint32_t cwndValue)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+if (!gHttpHandler->UseSpdyPersistentSettings())
+return;
+if (!ci)
+return;
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (!ent)
+return;
+ent = GetSpdyPreferredEnt(ent);
+if (!ent) // just to be thorough - but that map should always exist
+return;
+cwndValue = std::max(2U, cwndValue);
+cwndValue = std::min(128U, cwndValue);
+ent->mSpdyCWND = cwndValue;
+ent->mSpdyCWNDTimeStamp = TimeStamp::Now();
+return;
+}
+// a value of 0 means no setting is available
+uint32_t
+nsHttpConnectionMgr::GetSpdyCWNDSetting(nsHttpConnectionInfo *ci)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+if (!gHttpHandler->UseSpdyPersistentSettings())
+return 0;
+if (!ci)
+return 0;
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (!ent)
+return 0;
+ent = GetSpdyPreferredEnt(ent);
+if (!ent) // just to be thorough - but that map should always exist
+return 0;
+if (ent->mSpdyCWNDTimeStamp.IsNull())
+return 0;
+// For privacy tracking reasons, and the fact that CWND is not
+// meaningful after some time, we don't honor stored CWND after 8
+// hours.
+TimeDuration age = TimeStamp::Now() - ent->mSpdyCWNDTimeStamp;
+if (age.ToMilliseconds() > (1000 * 60 * 60 * 8))
+return 0;
+return ent->mSpdyCWND;
+}
+nsHttpConnectionMgr::nsConnectionEntry *
+nsHttpConnectionMgr::GetSpdyPreferredEnt(nsConnectionEntry *aOriginalEntry)
+{
+if (!gHttpHandler->IsSpdyEnabled() ||
+!gHttpHandler->CoalesceSpdy() ||
+aOriginalEntry->mCoalescingKey.IsEmpty())
+return nullptr;
+nsConnectionEntry *preferred =
+mSpdyPreferredHash.Get(aOriginalEntry->mCoalescingKey);
+// if there is no redirection no cert validation is required
+if (preferred == aOriginalEntry)
+return aOriginalEntry;
+// if there is no preferred host or it is no longer using spdy
+// then skip pooling
+if (!preferred || !preferred->mUsingSpdy)
+return nullptr;
+// if there is not an active spdy session in this entry then
+// we cannot pool because the cert upon activation may not
+// be the same as the old one. Active sessions are prohibited
+// from changing certs.
+nsHttpConnection *activeSpdy = nullptr;
+for (uint32_t index = 0; index < preferred->mActiveConns.Length(); ++index) {
+if (preferred->mActiveConns[index]->CanDirectlyActivate()) {
+activeSpdy = preferred->mActiveConns[index];
+break;
+}
+}
+if (!activeSpdy) {
+// remove the preferred status of this entry if it cannot be
+// used for pooling.
+preferred->mSpdyPreferred = false;
+RemoveSpdyPreferredEnt(preferred->mCoalescingKey);
+LOG(("nsHttpConnectionMgr::GetSpdyPreferredConnection "
+"preferred host mapping %s to %s removed due to inactivity.\n",
+aOriginalEntry->mConnInfo->Host(),
+preferred->mConnInfo->Host()));
+return nullptr;
+}
+// Check that the server cert supports redirection
+nsresult rv;
+bool isJoined = false;
+nsCOMPtr<nsISupports> securityInfo;
+nsCOMPtr<nsISSLSocketControl> sslSocketControl;
+nsAutoCString negotiatedNPN;
+activeSpdy->GetSecurityInfo(getter_AddRefs(securityInfo));
+if (!securityInfo) {
+NS_WARNING("cannot obtain spdy security info");
+return nullptr;
+}
+sslSocketControl = do_QueryInterface(securityInfo, &rv);
+if (NS_FAILED(rv)) {
+NS_WARNING("sslSocketControl QI Failed");
+return nullptr;
+}
+if (gHttpHandler->SpdyInfo()->ProtocolEnabled(0))
+rv = sslSocketControl->JoinConnection(gHttpHandler->SpdyInfo()->VersionString[0],
+aOriginalEntry->mConnInfo->GetHost(),
+aOriginalEntry->mConnInfo->Port(),
+&isJoined);
+else
+rv = NS_OK;                               /* simulate failed join */
+// JoinConnection() may have failed due to spdy version level. Try the other
+// level we support (if any)
+if (NS_SUCCEEDED(rv) && !isJoined && gHttpHandler->SpdyInfo()->ProtocolEnabled(1)) {
+rv = sslSocketControl->JoinConnection(gHttpHandler->SpdyInfo()->VersionString[1],
+aOriginalEntry->mConnInfo->GetHost(),
+aOriginalEntry->mConnInfo->Port(),
+&isJoined);
+}
+if (NS_FAILED(rv) || !isJoined) {
+LOG(("nsHttpConnectionMgr::GetSpdyPreferredConnection "
+"Host %s cannot be confirmed to be joined "
+"with %s connections. rv=%x isJoined=%d",
+preferred->mConnInfo->Host(), aOriginalEntry->mConnInfo->Host(),
+rv, isJoined));
+Telemetry::Accumulate(Telemetry::SPDY_NPN_JOIN, false);
+return nullptr;
+}
+// IP pooling confirmed
+LOG(("nsHttpConnectionMgr::GetSpdyPreferredConnection "
+"Host %s has cert valid for %s connections, "
+"so %s will be coalesced with %s",
+preferred->mConnInfo->Host(), aOriginalEntry->mConnInfo->Host(),
+aOriginalEntry->mConnInfo->Host(), preferred->mConnInfo->Host()));
+Telemetry::Accumulate(Telemetry::SPDY_NPN_JOIN, true);
+return preferred;
+}
+void
+nsHttpConnectionMgr::RemoveSpdyPreferredEnt(nsACString &aHashKey)
+{
+if (aHashKey.IsEmpty())
+return;
+mSpdyPreferredHash.Remove(aHashKey);
+}
+//-----------------------------------------------------------------------------
+// enumeration callbacks
+PLDHashOperator
+nsHttpConnectionMgr::ProcessOneTransactionCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+if (self->ProcessPendingQForEntry(ent, false))
+return PL_DHASH_STOP;
+return PL_DHASH_NEXT;
+}
+PLDHashOperator
+nsHttpConnectionMgr::ProcessAllTransactionsCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+self->ProcessPendingQForEntry(ent, true);
+return PL_DHASH_NEXT;
+}
+// If the global number of connections is preventing the opening of
+// new connections to a host without idle connections, then
+// close them regardless of their TTL
+PLDHashOperator
+nsHttpConnectionMgr::PurgeExcessIdleConnectionsCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+while (self->mNumIdleConns + self->mNumActiveConns + 1 >= self->mMaxConns) {
+if (!ent->mIdleConns.Length()) {
+// There are no idle conns left in this connection entry
+return PL_DHASH_NEXT;
+}
+nsHttpConnection *conn = ent->mIdleConns[0];
+ent->mIdleConns.RemoveElementAt(0);
+conn->Close(NS_ERROR_ABORT);
+NS_RELEASE(conn);
+self->mNumIdleConns--;
+self->ConditionallyStopPruneDeadConnectionsTimer();
+}
+return PL_DHASH_STOP;
+}
+// If the global number of connections is preventing the opening of
+// new connections to a host without idle connections, then
+// close any spdy asap
+PLDHashOperator
+nsHttpConnectionMgr::PurgeExcessSpdyConnectionsCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+if (!ent->mUsingSpdy)
+return PL_DHASH_NEXT;
+nsHttpConnectionMgr *self = static_cast<nsHttpConnectionMgr *>(closure);
+for (uint32_t index = 0; index < ent->mActiveConns.Length(); ++index) {
+nsHttpConnection *conn = ent->mActiveConns[index];
+if (conn->UsingSpdy() && conn->CanReuse()) {
+conn->DontReuse();
+// stop on <= (particularly =) beacuse this dontreuse causes async close
+if (self->mNumIdleConns + self->mNumActiveConns + 1 <= self->mMaxConns)
+return PL_DHASH_STOP;
+}
+}
+return PL_DHASH_NEXT;
+}
+PLDHashOperator
+nsHttpConnectionMgr::PruneDeadConnectionsCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+LOG(("  pruning [ci=%s]\n", ent->mConnInfo->HashKey().get()));
+// Find out how long it will take for next idle connection to not be reusable
+// anymore.
+uint32_t timeToNextExpire = UINT32_MAX;
+int32_t count = ent->mIdleConns.Length();
+if (count > 0) {
+for (int32_t i=count-1; i>=0; --i) {
+nsHttpConnection *conn = ent->mIdleConns[i];
+if (!conn->CanReuse()) {
+ent->mIdleConns.RemoveElementAt(i);
+conn->Close(NS_ERROR_ABORT);
+NS_RELEASE(conn);
+self->mNumIdleConns--;
+} else {
+timeToNextExpire = std::min(timeToNextExpire, conn->TimeToLive());
+}
+}
+}
+if (ent->mUsingSpdy) {
+for (uint32_t index = 0; index < ent->mActiveConns.Length(); ++index) {
+nsHttpConnection *conn = ent->mActiveConns[index];
+if (conn->UsingSpdy()) {
+if (!conn->CanReuse()) {
+// marking it dont reuse will create an active tear down if
+// the spdy session is idle.
+conn->DontReuse();
+}
+else {
+timeToNextExpire = std::min(timeToNextExpire,
+conn->TimeToLive());
+}
+}
+}
+}
+// If time to next expire found is shorter than time to next wake-up, we need to
+// change the time for next wake-up.
+if (timeToNextExpire != UINT32_MAX) {
+uint32_t now = NowInSeconds();
+uint64_t timeOfNextExpire = now + timeToNextExpire;
+// If pruning of dead connections is not already scheduled to happen
+// or time found for next connection to expire is is before
+// mTimeOfNextWakeUp, we need to schedule the pruning to happen
+// after timeToNextExpire.
+if (!self->mTimer || timeOfNextExpire < self->mTimeOfNextWakeUp) {
+self->PruneDeadConnectionsAfter(timeToNextExpire);
+}
+} else {
+self->ConditionallyStopPruneDeadConnectionsTimer();
+}
+// if this entry is empty, we have too many entries,
+// and this doesn't represent some painfully determined
+// red condition, then we can clean it up and restart from
+// yellow
+if (ent->PipelineState()       != PS_RED &&
+self->mCT.Count()          >  125 &&
+ent->mIdleConns.Length()   == 0 &&
+ent->mActiveConns.Length() == 0 &&
+ent->mHalfOpens.Length()   == 0 &&
+ent->mPendingQ.Length()    == 0 &&
+((!ent->mTestedSpdy && !ent->mUsingSpdy) ||
+!gHttpHandler->IsSpdyEnabled() ||
+self->mCT.Count() > 300)) {
+LOG(("    removing empty connection entry\n"));
+return PL_DHASH_REMOVE;
+}
+// otherwise use this opportunity to compact our arrays...
+ent->mIdleConns.Compact();
+ent->mActiveConns.Compact();
+ent->mPendingQ.Compact();
+return PL_DHASH_NEXT;
+}
+PLDHashOperator
+nsHttpConnectionMgr::ShutdownPassCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+nsHttpTransaction *trans;
+nsHttpConnection *conn;
+// close all active connections
+while (ent->mActiveConns.Length()) {
+conn = ent->mActiveConns[0];
+ent->mActiveConns.RemoveElementAt(0);
+self->DecrementActiveConnCount(conn);
+conn->Close(NS_ERROR_ABORT);
+NS_RELEASE(conn);
+}
+// close all idle connections
+while (ent->mIdleConns.Length()) {
+conn = ent->mIdleConns[0];
+ent->mIdleConns.RemoveElementAt(0);
+self->mNumIdleConns--;
+conn->Close(NS_ERROR_ABORT);
+NS_RELEASE(conn);
+}
+// If all idle connections are removed,
+// we can stop pruning dead connections.
+self->ConditionallyStopPruneDeadConnectionsTimer();
+// close all pending transactions
+while (ent->mPendingQ.Length()) {
+trans = ent->mPendingQ[0];
+ent->mPendingQ.RemoveElementAt(0);
+trans->Close(NS_ERROR_ABORT);
+NS_RELEASE(trans);
+}
+// close all half open tcp connections
+for (int32_t i = ((int32_t) ent->mHalfOpens.Length()) - 1; i >= 0; i--)
+ent->mHalfOpens[i]->Abandon();
+return PL_DHASH_REMOVE;
+}
+//-----------------------------------------------------------------------------
+bool
+nsHttpConnectionMgr::ProcessPendingQForEntry(nsConnectionEntry *ent, bool considerAll)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::ProcessPendingQForEntry [ci=%s]\n",
+ent->mConnInfo->HashKey().get()));
+ProcessSpdyPendingQ(ent);
+nsHttpTransaction *trans;
+nsresult rv;
+bool dispatchedSuccessfully = false;
+int dispatchCount = 0;
+#ifdef WTF_DEBUG
+uint32_t total = ent->mPendingQ.Length();
+#endif
+// if !considerAll iterate the pending list until one is dispatched successfully.
+// Keep iterating afterwards only until a transaction fails to dispatch.
+// if considerAll == true then try and dispatch all items.
+for (uint32_t i = 0; i < ent->mPendingQ.Length(); ) {
+trans = ent->mPendingQ[i];
+// When this entry has already established a half-open
+// connection, we want to prevent any duplicate half-open
+// connections from being established and bound to this
+// transaction.
+bool alreadyHalfOpen = false;
+if (ent->SupportsPipelining()) {
+alreadyHalfOpen = (ent->UnconnectedHalfOpens() > 0);
+} else {
+for (int32_t j = 0; j < ((int32_t) ent->mHalfOpens.Length()); ++j) {
+if (ent->mHalfOpens[j]->Transaction() == trans) {
+alreadyHalfOpen = true;
+break;
+}
+}
+}
+rv = TryDispatchTransaction(ent, alreadyHalfOpen, trans);
+if (NS_SUCCEEDED(rv) || (rv != NS_ERROR_NOT_AVAILABLE)) {
+if (NS_SUCCEEDED(rv))
+LOG(("  dispatching pending transaction...\n"));
+else
+LOG(("  removing pending transaction based on "
+"TryDispatchTransaction returning hard error %x\n", rv));
+if (ent->mPendingQ.RemoveElement(trans)) {
+dispatchedSuccessfully = true;
+dispatchCount++;
+NS_RELEASE(trans);
+continue; // dont ++i as we just made the array shorter
+}
+LOG(("  transaction not found in pending queue\n"));
+}
+// We want to keep walking the dispatch table to ensure requests
+// get combined properly.
+//if (dispatchedSuccessfully && !considerAll)
+//    break;
+++i;
+}
+#ifdef WTF_DEBUG
+if (dispatchedSuccessfully) {
+fprintf(stderr, "WTF-queue: Dispatched %d/%d pending transactions for %s\n",
+dispatchCount, total, ent->mConnInfo->Host());
+return true;
+}
+#endif
+return dispatchedSuccessfully;
+}
+bool
+nsHttpConnectionMgr::ProcessPendingQForEntry(nsHttpConnectionInfo *ci)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (ent)
+return ProcessPendingQForEntry(ent, false);
+return false;
+}
+bool
+nsHttpConnectionMgr::SupportsPipelining(nsHttpConnectionInfo *ci)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (ent)
+return ent->SupportsPipelining();
+return false;
+}
+// nsHttpPipelineFeedback used to hold references across events
+class nsHttpPipelineFeedback
+{
+public:
+nsHttpPipelineFeedback(nsHttpConnectionInfo *ci,
+nsHttpConnectionMgr::PipelineFeedbackInfoType info,
+nsHttpConnection *conn, uint32_t data)
+: mConnInfo(ci)
+, mConn(conn)
+, mInfo(info)
+, mData(data)
+{
+}
+~nsHttpPipelineFeedback()
+{
+}
+nsRefPtr<nsHttpConnectionInfo> mConnInfo;
+nsRefPtr<nsHttpConnection> mConn;
+nsHttpConnectionMgr::PipelineFeedbackInfoType mInfo;
+uint32_t mData;
+};
+void
+nsHttpConnectionMgr::PipelineFeedbackInfo(nsHttpConnectionInfo *ci,
+PipelineFeedbackInfoType info,
+nsHttpConnection *conn,
+uint32_t data)
+{
+if (!ci)
+return;
+// Post this to the socket thread if we are not running there already
+if (PR_GetCurrentThread() != gSocketThread) {
+nsHttpPipelineFeedback *fb = new nsHttpPipelineFeedback(ci, info,
+conn, data);
+nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgProcessFeedback,
+0, fb);
+if (NS_FAILED(rv))
+delete fb;
+return;
+}
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (ent)
+ent->OnPipelineFeedbackInfo(info, conn, data);
+}
+void
+nsHttpConnectionMgr::ReportFailedToProcess(nsIURI *uri)
+{
+MOZ_ASSERT(uri);
+nsAutoCString host;
+int32_t port = -1;
+nsAutoCString username;
+bool usingSSL = false;
+bool isHttp = false;
+nsresult rv = uri->SchemeIs("https", &usingSSL);
+if (NS_SUCCEEDED(rv) && usingSSL)
+isHttp = true;
+if (NS_SUCCEEDED(rv) && !isHttp)
+rv = uri->SchemeIs("http", &isHttp);
+if (NS_SUCCEEDED(rv))
+rv = uri->GetAsciiHost(host);
+if (NS_SUCCEEDED(rv))
+rv = uri->GetPort(&port);
+if (NS_SUCCEEDED(rv))
+uri->GetUsername(username);
+if (NS_FAILED(rv) || !isHttp || host.IsEmpty())
+return;
+// report the event for all the permutations of anonymous and
+// private versions of this host
+nsRefPtr<nsHttpConnectionInfo> ci =
+new nsHttpConnectionInfo(host, port, username, nullptr, usingSSL);
+ci->SetAnonymous(false);
+ci->SetPrivate(false);
+PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
+ci = ci->Clone();
+ci->SetAnonymous(false);
+ci->SetPrivate(true);
+PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
+ci = ci->Clone();
+ci->SetAnonymous(true);
+ci->SetPrivate(false);
+PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
+ci = ci->Clone();
+ci->SetAnonymous(true);
+ci->SetPrivate(true);
+PipelineFeedbackInfo(ci, RedCorruptedContent, nullptr, 0);
+}
+// we're at the active connection limit if any one of the following conditions is true:
+//  (1) at max-connections
+//  (2) keep-alive enabled and at max-persistent-connections-per-server/proxy
+//  (3) keep-alive disabled and at max-connections-per-server
+bool
+nsHttpConnectionMgr::AtActiveConnectionLimit(nsConnectionEntry *ent, uint32_t caps)
+{
+nsHttpConnectionInfo *ci = ent->mConnInfo;
+LOG(("nsHttpConnectionMgr::AtActiveConnectionLimit [ci=%s caps=%x]\n",
+ci->HashKey().get(), caps));
+// update maxconns if potentially limited by the max socket count
+// this requires a dynamic reduction in the max socket count to a point
+// lower than the max-connections pref.
+uint32_t maxSocketCount = gHttpHandler->MaxSocketCount();
+if (mMaxConns > maxSocketCount) {
+mMaxConns = maxSocketCount;
+LOG(("nsHttpConnectionMgr %p mMaxConns dynamically reduced to %u",
+this, mMaxConns));
+}
+// If there are more active connections than the global limit, then we're
+// done. Purging idle connections won't get us below it.
+if (mNumActiveConns >= mMaxConns) {
+LOG(("  num active conns == max conns\n"));
+return true;
+}
+// Add in the in-progress tcp connections, we will assume they are
+// keepalive enabled.
+// Exclude half-open's that has already created a usable connection.
+// This prevents the limit being stuck on ipv6 connections that
+// eventually time out after typical 21 seconds of no ACK+SYN reply.
+uint32_t totalCount =
+ent->mActiveConns.Length() + ent->UnconnectedHalfOpens();
+uint16_t maxPersistConns;
+if (ci->UsingHttpProxy() && !ci->UsingConnect())
+maxPersistConns = mMaxPersistConnsPerProxy;
+else
+maxPersistConns = mMaxPersistConnsPerHost;
+LOG(("   connection count = %d, limit %d\n", totalCount, maxPersistConns));
+// use >= just to be safe
+bool result = (totalCount >= maxPersistConns);
+LOG(("  result: %s", result ? "true" : "false"));
+return result;
+}
+void
+nsHttpConnectionMgr::ClosePersistentConnections(nsConnectionEntry *ent)
+{
+LOG(("nsHttpConnectionMgr::ClosePersistentConnections [ci=%s]\n",
+ent->mConnInfo->HashKey().get()));
+while (ent->mIdleConns.Length()) {
+nsHttpConnection *conn = ent->mIdleConns[0];
+ent->mIdleConns.RemoveElementAt(0);
+mNumIdleConns--;
+conn->Close(NS_ERROR_ABORT);
+NS_RELEASE(conn);
+}
+int32_t activeCount = ent->mActiveConns.Length();
+for (int32_t i=0; i < activeCount; i++)
+ent->mActiveConns[i]->DontReuse();
+}
+PLDHashOperator
+nsHttpConnectionMgr::ClosePersistentConnectionsCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = static_cast<nsHttpConnectionMgr *>(closure);
+self->ClosePersistentConnections(ent);
+return PL_DHASH_NEXT;
+}
+bool
+nsHttpConnectionMgr::RestrictConnections(nsConnectionEntry *ent,
+bool ignorePossibleSpdyConnections)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+// If this host is trying to negotiate a SPDY session right now,
+// don't create any new ssl connections until the result of the
+// negotiation is known.
+bool doRestrict = ent->mConnInfo->UsingSSL() &&
+gHttpHandler->IsSpdyEnabled() &&
+((!ent->mTestedSpdy && !ignorePossibleSpdyConnections) ||
+ent->mUsingSpdy) &&
+(ent->mHalfOpens.Length() || ent->mActiveConns.Length());
+// If there are no restrictions, we are done
+if (!doRestrict)
+return false;
+// If the restriction is based on a tcp handshake in progress
+// let that connect and then see if it was SPDY or not
+if (ent->UnconnectedHalfOpens() && !ignorePossibleSpdyConnections)
+return true;
+// There is a concern that a host is using a mix of HTTP/1 and SPDY.
+// In that case we don't want to restrict connections just because
+// there is a single active HTTP/1 session in use.
+if (ent->mUsingSpdy && ent->mActiveConns.Length()) {
+bool confirmedRestrict = false;
+for (uint32_t index = 0; index < ent->mActiveConns.Length(); ++index) {
+nsHttpConnection *conn = ent->mActiveConns[index];
+if (!conn->ReportedNPN() || conn->CanDirectlyActivate()) {
+confirmedRestrict = true;
+break;
+}
+}
+doRestrict = confirmedRestrict;
+if (!confirmedRestrict) {
+LOG(("nsHttpConnectionMgr spdy connection restriction to "
+"%s bypassed.\n", ent->mConnInfo->Host()));
+}
+}
+return doRestrict;
+}
+// returns NS_OK if a connection was started
+// return NS_ERROR_NOT_AVAILABLE if a new connection cannot be made due to
+//        ephemeral limits
+// returns other NS_ERROR on hard failure conditions
+nsresult
+nsHttpConnectionMgr::MakeNewConnection(nsConnectionEntry *ent,
+nsHttpTransaction *trans)
+{
+LOG(("nsHttpConnectionMgr::MakeNewConnection %p ent=%p trans=%p",
+this, ent, trans));
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+uint32_t halfOpenLength = ent->mHalfOpens.Length();
+for (uint32_t i = 0; i < halfOpenLength; i++) {
+if (ent->mHalfOpens[i]->IsSpeculative()) {
+// We've found a speculative connection in the half
+// open list. Remove the speculative bit from it and that
+// connection can later be used for this transaction
+// (or another one in the pending queue) - we don't
+// need to open a new connection here.
+LOG(("nsHttpConnectionMgr::MakeNewConnection [ci = %s]\n"
+"Found a speculative half open connection\n",
+ent->mConnInfo->HashKey().get()));
+ent->mHalfOpens[i]->SetSpeculative(false);
+// return OK because we have essentially opened a new connection
+// by converting a speculative half-open to general use
+return NS_OK;
+}
+}
+// If this host is trying to negotiate a SPDY session right now,
+// don't create any new connections until the result of the
+// negotiation is known.
+if (!(trans->Caps() & NS_HTTP_DISALLOW_SPDY) &&
+(trans->Caps() & NS_HTTP_ALLOW_KEEPALIVE) &&
+RestrictConnections(ent)) {
+LOG(("nsHttpConnectionMgr::MakeNewConnection [ci = %s] "
+"Not Available Due to RestrictConnections()\n",
+ent->mConnInfo->HashKey().get()));
+return NS_ERROR_NOT_AVAILABLE;
+}
+// We need to make a new connection. If that is going to exceed the
+// global connection limit then try and free up some room by closing
+// an idle connection to another host. We know it won't select "ent"
+// beacuse we have already determined there are no idle connections
+// to our destination
+if ((mNumIdleConns + mNumActiveConns + 1 >= mMaxConns) && mNumIdleConns)
+mCT.Enumerate(PurgeExcessIdleConnectionsCB, this);
+if ((mNumIdleConns + mNumActiveConns + 1 >= mMaxConns) &&
+mNumActiveConns && gHttpHandler->IsSpdyEnabled())
+mCT.Enumerate(PurgeExcessSpdyConnectionsCB, this);
+if (AtActiveConnectionLimit(ent, trans->Caps()))
+return NS_ERROR_NOT_AVAILABLE;
+#ifdef WTF_DEBUG
+fprintf(stderr, "WTF: MakeNewConnection() is creating a transport (pipelines %d) for host %s\n",
+ent->SupportsPipelining(), ent->mConnInfo->Host());
+#endif
+nsresult rv = CreateTransport(ent, trans, trans->Caps(), false);
+if (NS_FAILED(rv)) {
+/* hard failure */
+LOG(("nsHttpConnectionMgr::MakeNewConnection [ci = %s trans = %p] "
+"CreateTransport() hard failure.\n",
+ent->mConnInfo->HashKey().get(), trans));
+trans->Close(rv);
+if (rv == NS_ERROR_NOT_AVAILABLE)
+rv = NS_ERROR_FAILURE;
+return rv;
+}
+return NS_OK;
+}
+bool
+nsHttpConnectionMgr::AddToBestPipeline(nsConnectionEntry *ent,
+nsHttpTransaction *trans,
+nsHttpTransaction::Classifier classification,
+uint16_t depthLimit)
+{
+if (classification == nsAHttpTransaction::CLASS_SOLO)
+return false;
+uint32_t maxdepth = ent->MaxPipelineDepth(classification);
+if (maxdepth == 0) {
+ent->CreditPenalty();
+maxdepth = ent->MaxPipelineDepth(classification);
+}
+if (ent->PipelineState() == PS_RED)
+return false;
+if (ent->PipelineState() == PS_YELLOW && ent->mYellowConnection)
+return false;
+// The maximum depth of a pipeline in yellow is 1 pipeline of
+// depth 2 for entire CI. When that transaction completes successfully
+// we transition to green and that expands the allowed depth
+// to any number of pipelines of up to depth 4.  When a transaction
+// queued at position 3 or deeper succeeds we open it all the way
+// up to depths limited only by configuration. The staggered start
+// in green is simply because a successful yellow test of depth=2
+// might really just be a race condition (i.e. depth=1 from the
+// server's point of view), while depth=3 is a stronger indicator -
+// keeping the pipelines to a modest depth during that period limits
+// the damage if something is going to go wrong.
+maxdepth = std::min<uint32_t>(maxdepth, depthLimit);
+if (maxdepth < 2)
+return false;
+// Find out how many requests of this class we have
+uint32_t sameClass = 0;
+uint32_t allClasses = ent->mPendingQ.Length();
+for (uint32_t i = 0; i < allClasses; ++i) {
+if (trans != ent->mPendingQ[i] &&
+classification == ent->mPendingQ[i]->Classification()) {
+sameClass++;
+}
+}
+nsAHttpTransaction *activeTrans;
+nsHttpPipeline *pipeline;
+nsHttpConnection *bestConn = nullptr;
+uint32_t activeCount = ent->mActiveConns.Length();
+uint32_t pipelineDepth;
+uint32_t requestLen;
+uint32_t totalDepth = 0;
+// Now, try to find the best pipeline
+nsTArray<nsHttpConnection *> validConns;
+nsTArray<nsHttpConnection *> betterConns;
+nsTArray<nsHttpConnection *> bestConns;
+uint32_t numPipelines = 0;
+for (uint32_t i = 0; i < activeCount; ++i) {
+nsHttpConnection *conn = ent->mActiveConns[i];
+if (!conn->SupportsPipelining())
+continue;
+activeTrans = conn->Transaction();
+if (!activeTrans ||
+activeTrans->IsDone() ||
+NS_FAILED(activeTrans->Status()))
+continue;
+pipeline = activeTrans->QueryPipeline();
+if (!pipeline)
+continue;
+numPipelines++;
+pipelineDepth = activeTrans->PipelineDepth();
+requestLen = pipeline->RequestDepth();
+totalDepth += pipelineDepth;
+// If we're within striking distance of our pipeline
+// packaging goal, give a little slack on the depth
+// limit to allow us to try to get there. Don't give
+// too much slack, though, or we'll tend to have
+// request packages of the same size when we have
+// many content elements appear at once.
+if (maxdepth +
+PR_MIN(mMaxOptimisticPipelinedRequests,
+requestLen + allClasses)
+<= pipelineDepth)
+continue;
+validConns.AppendElement(conn);
+// Prefer a pipeline that either has at least two requests
+// queued already, or for which we can add multiple requests
+if (requestLen + allClasses < mMaxOptimisticPipelinedRequests)
+continue;
+betterConns.AppendElement(conn);
+// Prefer a pipeline with the same classification if
+// our current classes will put it over the line
+if (conn->Classification() != classification)
+continue;
+if (requestLen + sameClass < mMaxOptimisticPipelinedRequests)
+continue;
+bestConns.AppendElement(conn);
+}
+const char *type;
+if (bestConns.Length()) {
+type = "best";
+bestConn = bestConns[rand()%bestConns.Length()];
+} else if (betterConns.Length()) {
+type = "better";
+bestConn = betterConns[rand()%betterConns.Length()];
+} else if (validConns.Length() && totalDepth == 0) {
+// We only use valid conns if it's a last resort
+// (No other requests are pending or in flight)
+type = "valid";
+bestConn = validConns[rand()%validConns.Length()];
+} else {
+return false;
+}
+activeTrans = bestConn->Transaction();
+nsresult rv = activeTrans->AddTransaction(trans);
+if (NS_FAILED(rv))
+return false;
+LOG(("   scheduling trans %p on pipeline at position %d, type %s\n",
+trans, trans->PipelinePosition(), type));
+#ifdef WTF_DEBUG
+pipeline = activeTrans->QueryPipeline();
+fprintf(stderr,
+"WTF-depth: Added trans to %s of %d/%d/%d/%d pipelines. Request len %d/%d/%d for %s\n",
+type, bestConns.Length(), betterConns.Length(), validConns.Length(),
+numPipelines, pipeline->RequestDepth(), activeTrans->PipelineDepth(),
+maxdepth, ent->mConnInfo->Host());
+#endif
+if ((ent->PipelineState() == PS_YELLOW) && (trans->PipelinePosition() > 1))
+ent->SetYellowConnection(bestConn);
+if (!trans->GetPendingTime().IsNull()) {
+if (trans->UsesPipelining())
+AccumulateTimeDelta(
+Telemetry::TRANSACTION_WAIT_TIME_HTTP_PIPELINES,
+trans->GetPendingTime(), TimeStamp::Now());
+else
+AccumulateTimeDelta(
+Telemetry::TRANSACTION_WAIT_TIME_HTTP,
+trans->GetPendingTime(), TimeStamp::Now());
+trans->SetPendingTime(false);
+}
+return true;
+}
+bool
+nsHttpConnectionMgr::IsUnderPressure(nsConnectionEntry *ent,
+nsHttpTransaction::Classifier classification)
+{
+// A connection entry is declared to be "under pressure" if most of the
+// allowed parallel connections are already used up. In that case we want to
+// favor existing pipelines over more parallelism so as to reserve any
+// unused parallel connections for types that don't have existing pipelines.
+//
+// The definition of connection pressure is a pretty liberal one here - that
+// is why we are using the more restrictive maxPersist* counters.
+//
+// Pipelines are also favored when the requested classification is already
+// using 3 or more of the connections. Failure to do this could result in
+// one class (e.g. images) establishing self replenishing queues on all the
+// connections that would starve the other transaction types.
+int32_t currentConns = ent->mActiveConns.Length();
+int32_t maxConns =
+(ent->mConnInfo->UsingHttpProxy() && !ent->mConnInfo->UsingConnect()) ?
+mMaxPersistConnsPerProxy : mMaxPersistConnsPerHost;
+// Leave room for at least 3 distinct types to operate concurrently,
+// this satisfies the typical {html, js/css, img} page.
+if (currentConns >= (maxConns - 2))
+return true;                           /* prefer pipeline */
+int32_t sameClass = 0;
+for (int32_t i = 0; i < currentConns; ++i)
+if (classification == ent->mActiveConns[i]->Classification())
+if (++sameClass == 3)
+return true;                   /* prefer pipeline */
+return false;                              /* normal behavior */
+}
+// returns OK if a connection is found for the transaction
+//   and the transaction is started.
+// returns ERROR_NOT_AVAILABLE if no connection can be found and it
+//   should be queued until circumstances change
+// returns other ERROR when transaction has a hard failure and should
+//   not remain in the pending queue
+nsresult
+nsHttpConnectionMgr::TryDispatchTransaction(nsConnectionEntry *ent,
+bool onlyReusedConnection,
+nsHttpTransaction *trans)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::TryDispatchTransaction without conn "
+"[ci=%s caps=%x]\n",
+ent->mConnInfo->HashKey().get(), uint32_t(trans->Caps())));
+nsHttpTransaction::Classifier classification = trans->Classification();
+uint32_t caps = trans->Caps();
+bool allowNewPipelines = true;
+// no keep-alive means no pipelines either
+if (!(caps & NS_HTTP_ALLOW_KEEPALIVE))
+caps = caps & ~NS_HTTP_ALLOW_PIPELINING;
+nsRefPtr<nsHttpConnection> unusedSpdyPersistentConnection;
+// step 0
+// look for existing spdy connection - that's always best because it is
+// essentially pipelining without head of line blocking
+if (!(caps & NS_HTTP_DISALLOW_SPDY) && gHttpHandler->IsSpdyEnabled()) {
+nsRefPtr<nsHttpConnection> conn = GetSpdyPreferredConn(ent);
+if (conn) {
+if ((caps & NS_HTTP_ALLOW_KEEPALIVE) || !conn->IsExperienced()) {
+LOG(("   dispatch to spdy: [conn=%x]\n", conn.get()));
+trans->RemoveDispatchedAsBlocking();  /* just in case */
+DispatchTransaction(ent, trans, conn);
+return NS_OK;
+}
+unusedSpdyPersistentConnection = conn;
+}
+}
+// If this is not a blocking transaction and the loadgroup for it is
+// currently processing one or more blocking transactions then we
+// need to just leave it in the queue until those are complete unless it is
+// explicitly marked as unblocked.
+if (!(caps & NS_HTTP_LOAD_AS_BLOCKING)) {
+if (!(caps & NS_HTTP_LOAD_UNBLOCKED)) {
+nsILoadGroupConnectionInfo *loadGroupCI = trans->LoadGroupConnectionInfo();
+if (loadGroupCI) {
+uint32_t blockers = 0;
+if (NS_SUCCEEDED(loadGroupCI->GetBlockingTransactionCount(&blockers)) &&
+blockers) {
+// need to wait for blockers to clear
+LOG(("   blocked by load group: [blockers=%d]\n", blockers));
+return NS_ERROR_NOT_AVAILABLE;
+}
+}
+}
+}
+else {
+// Mark the transaction and its load group as blocking right now to prevent
+// other transactions from being reordered in the queue due to slow syns.
+trans->DispatchedAsBlocking();
+}
+// step 1: Try a pipeline
+if (caps & NS_HTTP_ALLOW_PIPELINING &&
+AddToBestPipeline(ent, trans, classification,
+mMaxPipelinedRequests)) {
+return NS_OK;
+}
+// XXX: Kill this block? It's new.. but it may be needed for SPDY
+// Subject most transactions at high parallelism to rate pacing.
+// It will only be actually submitted to the
+// token bucket once, and if possible it is granted admission synchronously.
+// It is important to leave a transaction in the pending queue when blocked by
+// pacing so it can be found on cancel if necessary.
+// Transactions that cause blocking or bypass it (e.g. js/css) are not rate
+// limited.
+if (gHttpHandler->UseRequestTokenBucket() &&
+(mNumActiveConns >= mNumSpdyActiveConns) && // just check for robustness sake
+((mNumActiveConns - mNumSpdyActiveConns) >= gHttpHandler->RequestTokenBucketMinParallelism()) &&
+!(caps & (NS_HTTP_LOAD_AS_BLOCKING | NS_HTTP_LOAD_UNBLOCKED))) {
+if (!trans->TryToRunPacedRequest()) {
+LOG(("   blocked due to rate pacing\n"));
+return NS_ERROR_NOT_AVAILABLE;
+}
+}
+// Step 2: Decide if we should forbid new pipeline creation.
+//
+// FIXME: We repurposed mMaxOptimisticPipelinedRequests here to mean:
+// "Don't make a new pipeline until you have this many requests pending and
+// no potential connections to put them on". It might be nice to give this
+// its own pref..
+if (HasPipelines(ent) &&
+ent->mPendingQ.Length() < mMaxOptimisticPipelinedRequests &&
+trans->Classification() != nsAHttpTransaction::CLASS_SOLO &&
+caps & NS_HTTP_ALLOW_PIPELINING)
+allowNewPipelines = false;
+// step 3: consider an idle persistent connection
+if (allowNewPipelines && (caps & NS_HTTP_ALLOW_KEEPALIVE)) {
+nsRefPtr<nsHttpConnection> conn;
+while (!conn && (ent->mIdleConns.Length() > 0)) {
+conn = ent->mIdleConns[0];
+ent->mIdleConns.RemoveElementAt(0);
+mNumIdleConns--;
+nsHttpConnection *temp = conn;
+NS_RELEASE(temp);
+// we check if the connection can be reused before even checking if
+// it is a "matching" connection.
+if (!conn->CanReuse()) {
+LOG(("   dropping stale connection: [conn=%x]\n", conn.get()));
+conn->Close(NS_ERROR_ABORT);
+conn = nullptr;
+}
+else {
+LOG(("   reusing connection [conn=%x]\n", conn.get()));
+conn->EndIdleMonitoring();
+}
+// If there are no idle connections left at all, we need to make
+// sure that we are not pruning dead connections anymore.
+ConditionallyStopPruneDeadConnectionsTimer();
+}
+if (conn) {
+// This will update the class of the connection to be the class of
+// the transaction dispatched on it.
+AddActiveConn(conn, ent);
+DispatchTransaction(ent, trans, conn);
+return NS_OK;
+}
+}
+// step 4: Maybe make a connection?
+if (!onlyReusedConnection && allowNewPipelines) {
+nsresult rv = MakeNewConnection(ent, trans);
+if (NS_SUCCEEDED(rv)) {
+// this function returns NOT_AVAILABLE for asynchronous connects
+return NS_ERROR_NOT_AVAILABLE;
+}
+if (rv != NS_ERROR_NOT_AVAILABLE) {
+// not available return codes should try next step as they are
+// not hard errors. Other codes should stop now
+return rv;
+}
+}
+// step 5
+if (unusedSpdyPersistentConnection) {
+// to avoid deadlocks, we need to throw away this perfectly valid SPDY
+// connection to make room for a new one that can service a no KEEPALIVE
+// request
+unusedSpdyPersistentConnection->DontReuse();
+}
+// XXX: We dequeue and queue the same url here sometimes..
+#ifdef WTF_DEBUG
+nsHttpRequestHead *head = trans->RequestHead();
+fprintf(stderr, "WTF: Queuing url %s%s\n",
+ent->mConnInfo->Host(),
+head ? head->RequestURI().BeginReading() : "<unknown?>");
+#endif
+return NS_ERROR_NOT_AVAILABLE;                /* queue it */
+}
+nsresult
+nsHttpConnectionMgr::DispatchTransaction(nsConnectionEntry *ent,
+nsHttpTransaction *trans,
+nsHttpConnection *conn)
+{
+uint32_t caps = trans->Caps();
+int32_t priority = trans->Priority();
+nsresult rv;
+LOG(("nsHttpConnectionMgr::DispatchTransaction "
+"[ci=%s trans=%x caps=%x conn=%x priority=%d]\n",
+ent->mConnInfo->HashKey().get(), trans, caps, conn, priority));
+// It is possible for a rate-paced transaction to be dispatched independent
+// of the token bucket when the amount of parallelization has changed or
+// when a muxed connection (e.g. spdy or pipelines) becomes available.
+trans->CancelPacing(NS_OK);
+if (conn->UsingSpdy()) {
+LOG(("Spdy Dispatch Transaction via Activate(). Transaction host = %s,"
+"Connection host = %s\n",
+trans->ConnectionInfo()->Host(),
+conn->ConnectionInfo()->Host()));
+rv = conn->Activate(trans, caps, priority);
+MOZ_ASSERT(NS_SUCCEEDED(rv), "SPDY Cannot Fail Dispatch");
+if (NS_SUCCEEDED(rv) && !trans->GetPendingTime().IsNull()) {
+AccumulateTimeDelta(Telemetry::TRANSACTION_WAIT_TIME_SPDY,
+trans->GetPendingTime(), TimeStamp::Now());
+trans->SetPendingTime(false);
+}
+return rv;
+}
+MOZ_ASSERT(conn && !conn->Transaction(),
+"DispatchTranaction() on non spdy active connection");
+if (!(caps & NS_HTTP_ALLOW_PIPELINING))
+conn->Classify(nsAHttpTransaction::CLASS_SOLO);
+else
+conn->Classify(trans->Classification());
+rv = DispatchAbstractTransaction(ent, trans, caps, conn, priority);
+if (NS_SUCCEEDED(rv) && !trans->GetPendingTime().IsNull()) {
+if (trans->UsesPipelining())
+AccumulateTimeDelta(Telemetry::TRANSACTION_WAIT_TIME_HTTP_PIPELINES,
+trans->GetPendingTime(), TimeStamp::Now());
+else
+AccumulateTimeDelta(Telemetry::TRANSACTION_WAIT_TIME_HTTP,
+trans->GetPendingTime(), TimeStamp::Now());
+trans->SetPendingTime(false);
+}
+return rv;
+}
+// Use this method for dispatching nsAHttpTransction's. It can only safely be
+// used upon first use of a connection when NPN has not negotiated SPDY vs
+// HTTP/1 yet as multiplexing onto an existing SPDY session requires a
+// concrete nsHttpTransaction
+nsresult
+nsHttpConnectionMgr::DispatchAbstractTransaction(nsConnectionEntry *ent,
+nsAHttpTransaction *aTrans,
+uint32_t caps,
+nsHttpConnection *conn,
+int32_t priority)
+{
+MOZ_ASSERT(!conn->UsingSpdy(),
+"Spdy Must Not Use DispatchAbstractTransaction");
+LOG(("nsHttpConnectionMgr::DispatchAbstractTransaction "
+"[ci=%s trans=%x caps=%x conn=%x]\n",
+ent->mConnInfo->HashKey().get(), aTrans, caps, conn));
+/* Use pipeline datastructure even if connection does not currently qualify
+to pipeline this transaction because a different pipeline-eligible
+transaction might be placed on the active connection. Make an exception
+for CLASS_SOLO as that connection will never pipeline until it goes
+quiescent */
+nsRefPtr<nsAHttpTransaction> transaction;
+nsresult rv;
+if (conn->Classification() != nsAHttpTransaction::CLASS_SOLO) {
+LOG(("   using pipeline datastructure.\n"));
+nsRefPtr<nsHttpPipeline> pipeline;
+rv = BuildPipeline(ent, aTrans, getter_AddRefs(pipeline));
+if (!NS_SUCCEEDED(rv))
+return rv;
+transaction = pipeline;
+#ifdef WTF_DEBUG
+if (HasPipelines(ent) &&
+ent->mPendingQ.Length()+1 < mMaxOptimisticPipelinedRequests) {
+fprintf(stderr, "WTF-new-bug: New pipeline created from %d idle conns for host %s with %d/%d pending\n",
+ent->mIdleConns.Length(), ent->mConnInfo->Host(), ent->mPendingQ.Length(),
+mMaxOptimisticPipelinedRequests);
+} else {
+fprintf(stderr, "WTF-new: New pipeline created from %d idle conns for host %s with %d/%d pending\n",
+ent->mIdleConns.Length(), ent->mConnInfo->Host(), ent->mPendingQ.Length(),
+mMaxOptimisticPipelinedRequests);
+}
+#endif
+}
+else {
+LOG(("   not using pipeline datastructure due to class solo.\n"));
+transaction = aTrans;
+#ifdef WTF_TEST
+nsHttpRequestHead *head = transaction->RequestHead();
+fprintf(stderr, "WTF-order: Pipeline forbidden for url %s%s\n",
+ent->mConnInfo->Host(),
+head ? head->RequestURI().BeginReading() : "<unknown?>");
+#endif
+}
+nsRefPtr<nsConnectionHandle> handle = new nsConnectionHandle(conn);
+// give the transaction the indirect reference to the connection.
+transaction->SetConnection(handle);
+rv = conn->Activate(transaction, caps, priority);
+if (NS_FAILED(rv)) {
+LOG(("  conn->Activate failed [rv=%x]\n", rv));
+ent->mActiveConns.RemoveElement(conn);
+if (conn == ent->mYellowConnection)
+ent->OnYellowComplete();
+DecrementActiveConnCount(conn);
+ConditionallyStopTimeoutTick();
+// sever back references to connection, and do so without triggering
+// a call to ReclaimConnection ;-)
+transaction->SetConnection(nullptr);
+NS_RELEASE(handle->mConn);
+// destroy the connection
+NS_RELEASE(conn);
+}
+// As transaction goes out of scope it will drop the last refernece to the
+// pipeline if activation failed, in which case this will destroy
+// the pipeline, which will cause each the transactions owned by the
+// pipeline to be restarted.
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::BuildPipeline(nsConnectionEntry *ent,
+nsAHttpTransaction *firstTrans,
+nsHttpPipeline **result)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+/* form a pipeline here even if nothing is pending so that we
+can stream-feed it as new transactions arrive */
+/* the first transaction can go in unconditionally - 1 transaction
+on a nsHttpPipeline object is not a real HTTP pipeline */
+nsRefPtr<nsHttpPipeline> pipeline = new nsHttpPipeline();
+pipeline->AddTransaction(firstTrans);
+NS_ADDREF(*result = pipeline);
+return NS_OK;
+}
+void
+nsHttpConnectionMgr::ReportProxyTelemetry(nsConnectionEntry *ent)
+{
+enum { PROXY_NONE = 1, PROXY_HTTP = 2, PROXY_SOCKS = 3 };
+if (!ent->mConnInfo->UsingProxy())
+Telemetry::Accumulate(Telemetry::HTTP_PROXY_TYPE, PROXY_NONE);
+else if (ent->mConnInfo->UsingHttpProxy())
+Telemetry::Accumulate(Telemetry::HTTP_PROXY_TYPE, PROXY_HTTP);
+else
+Telemetry::Accumulate(Telemetry::HTTP_PROXY_TYPE, PROXY_SOCKS);
+}
+nsresult
+nsHttpConnectionMgr::ProcessNewTransaction(nsHttpTransaction *trans)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+// since "adds" and "cancels" are processed asynchronously and because
+// various events might trigger an "add" directly on the socket thread,
+// we must take care to avoid dispatching a transaction that has already
+// been canceled (see bug 190001).
+if (NS_FAILED(trans->Status())) {
+LOG(("  transaction was canceled... dropping event!\n"));
+return NS_OK;
+}
+trans->SetPendingTime();
+nsresult rv = NS_OK;
+nsHttpConnectionInfo *ci = trans->ConnectionInfo();
+MOZ_ASSERT(ci);
+nsConnectionEntry *ent = GetOrCreateConnectionEntry(ci);
+// SPDY coalescing of hostnames means we might redirect from this
+// connection entry onto the preferred one.
+nsConnectionEntry *preferredEntry = GetSpdyPreferredEnt(ent);
+if (preferredEntry && (preferredEntry != ent)) {
+LOG(("nsHttpConnectionMgr::ProcessNewTransaction trans=%p "
+"redirected via coalescing from %s to %s\n", trans,
+ent->mConnInfo->Host(), preferredEntry->mConnInfo->Host()));
+ent = preferredEntry;
+}
+ReportProxyTelemetry(ent);
+// Check if the transaction already has a sticky reference to a connection.
+// If so, then we can just use it directly by transferring its reference
+// to the new connection variable instead of searching for a new one
+nsAHttpConnection *wrappedConnection = trans->Connection();
+nsRefPtr<nsHttpConnection> conn;
+if (wrappedConnection)
+conn = dont_AddRef(wrappedConnection->TakeHttpConnection());
+if (conn) {
+MOZ_ASSERT(trans->Caps() & NS_HTTP_STICKY_CONNECTION);
+MOZ_ASSERT(((int32_t)ent->mActiveConns.IndexOf(conn)) != -1,
+"Sticky Connection Not In Active List");
+LOG(("nsHttpConnectionMgr::ProcessNewTransaction trans=%p "
+"sticky connection=%p\n", trans, conn.get()));
+trans->SetConnection(nullptr);
+#ifdef WTF_TEST
+fprintf(stderr, "WTF-bad: Sticky connection status on 1 transaction to host %s\n",
+ent->mConnInfo->Host());
+#endif
+rv = DispatchTransaction(ent, trans, conn);
+return rv;
+} else {
+// XXX: maybe check the queue first and directly call TryDispatch?
+InsertTransactionSorted(ent->mPendingQ, trans);
+NS_ADDREF(trans);
+ProcessPendingQForEntry(ent, true);
+return NS_OK;
+}
+}
+void
+nsHttpConnectionMgr::AddActiveConn(nsHttpConnection *conn,
+nsConnectionEntry *ent)
+{
+NS_ADDREF(conn);
+ent->mActiveConns.AppendElement(conn);
+mNumActiveConns++;
+ActivateTimeoutTick();
+}
+void
+nsHttpConnectionMgr::DecrementActiveConnCount(nsHttpConnection *conn)
+{
+mNumActiveConns--;
+if (conn->EverUsedSpdy())
+mNumSpdyActiveConns--;
+}
+void
+nsHttpConnectionMgr::StartedConnect()
+{
+mNumActiveConns++;
+ActivateTimeoutTick(); // likely disabled by RecvdConnect()
+}
+void
+nsHttpConnectionMgr::RecvdConnect()
+{
+mNumActiveConns--;
+ConditionallyStopTimeoutTick();
+}
+nsresult
+nsHttpConnectionMgr::CreateTransport(nsConnectionEntry *ent,
+nsAHttpTransaction *trans,
+uint32_t caps,
+bool speculative)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsRefPtr<nsHalfOpenSocket> sock = new nsHalfOpenSocket(ent, trans, caps);
+if (speculative)
+sock->SetSpeculative(true);
+nsresult rv = sock->SetupPrimaryStreams();
+NS_ENSURE_SUCCESS(rv, rv);
+ent->mHalfOpens.AppendElement(sock);
+mNumHalfOpenConns++;
+return NS_OK;
+}
+// This function tries to dispatch the pending spdy transactions on
+// the connection entry sent in as an argument. It will do so on the
+// active spdy connection either in that same entry or in the
+// redirected 'preferred' entry for the same coalescing hash key if
+// coalescing is enabled.
+void
+nsHttpConnectionMgr::ProcessSpdyPendingQ(nsConnectionEntry *ent)
+{
+nsHttpConnection *conn = GetSpdyPreferredConn(ent);
+if (!conn || !conn->CanDirectlyActivate())
+return;
+nsTArray<nsHttpTransaction*> leftovers;
+uint32_t index;
+// Dispatch all the transactions we can
+for (index = 0;
+index < ent->mPendingQ.Length() && conn->CanDirectlyActivate();
+++index) {
+nsHttpTransaction *trans = ent->mPendingQ[index];
+if (!(trans->Caps() & NS_HTTP_ALLOW_KEEPALIVE) ||
+trans->Caps() & NS_HTTP_DISALLOW_SPDY) {
+leftovers.AppendElement(trans);
+continue;
+}
+nsresult rv = DispatchTransaction(ent, trans, conn);
+if (NS_FAILED(rv)) {
+// this cannot happen, but if due to some bug it does then
+// close the transaction
+MOZ_ASSERT(false, "Dispatch SPDY Transaction");
+LOG(("ProcessSpdyPendingQ Dispatch Transaction failed trans=%p\n",
+trans));
+trans->Close(rv);
+}
+NS_RELEASE(trans);
+}
+// Slurp up the rest of the pending queue into our leftovers bucket (we
+// might have some left if conn->CanDirectlyActivate returned false)
+for (; index < ent->mPendingQ.Length(); ++index) {
+nsHttpTransaction *trans = ent->mPendingQ[index];
+leftovers.AppendElement(trans);
+}
+// Put the leftovers back in the pending queue and get rid of the
+// transactions we dispatched
+leftovers.SwapElements(ent->mPendingQ);
+leftovers.Clear();
+}
+PLDHashOperator
+nsHttpConnectionMgr::ProcessSpdyPendingQCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+self->ProcessSpdyPendingQ(ent);
+return PL_DHASH_NEXT;
+}
+void
+nsHttpConnectionMgr::OnMsgProcessAllSpdyPendingQ(int32_t, void *)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::OnMsgProcessAllSpdyPendingQ\n"));
+mCT.Enumerate(ProcessSpdyPendingQCB, this);
+}
+nsHttpConnection *
+nsHttpConnectionMgr::GetSpdyPreferredConn(nsConnectionEntry *ent)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+MOZ_ASSERT(ent);
+nsConnectionEntry *preferred = GetSpdyPreferredEnt(ent);
+// this entry is spdy-enabled if it is involved in a redirect
+if (preferred)
+// all new connections for this entry will use spdy too
+ent->mUsingSpdy = true;
+else
+preferred = ent;
+nsHttpConnection *conn = nullptr;
+if (preferred->mUsingSpdy) {
+for (uint32_t index = 0;
+index < preferred->mActiveConns.Length();
+++index) {
+if (preferred->mActiveConns[index]->CanDirectlyActivate()) {
+conn = preferred->mActiveConns[index];
+break;
+}
+}
+}
+return conn;
+}
+//-----------------------------------------------------------------------------
+void
+nsHttpConnectionMgr::OnMsgShutdown(int32_t, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::OnMsgShutdown\n"));
+mCT.Enumerate(ShutdownPassCB, this);
+if (mTimeoutTick) {
+mTimeoutTick->Cancel();
+mTimeoutTick = nullptr;
+mTimeoutTickArmed = false;
+}
+if (mTimer) {
+mTimer->Cancel();
+mTimer = nullptr;
+}
+// signal shutdown complete
+nsRefPtr<nsIRunnable> runnable =
+new nsConnEvent(this, &nsHttpConnectionMgr::OnMsgShutdownConfirm,
+0, param);
+NS_DispatchToMainThread(runnable);
+}
+void
+nsHttpConnectionMgr::OnMsgShutdownConfirm(int32_t priority, void *param)
+{
+MOZ_ASSERT(NS_IsMainThread());
+LOG(("nsHttpConnectionMgr::OnMsgShutdownConfirm\n"));
+bool *shutdown = static_cast<bool*>(param);
+*shutdown = true;
+}
+void
+nsHttpConnectionMgr::OnMsgNewTransaction(int32_t priority, void *param)
+{
+LOG(("nsHttpConnectionMgr::OnMsgNewTransaction [trans=%p]\n", param));
+nsHttpTransaction *trans = (nsHttpTransaction *) param;
+trans->SetPriority(priority);
+nsresult rv = ProcessNewTransaction(trans);
+if (NS_FAILED(rv))
+trans->Close(rv); // for whatever its worth
+NS_RELEASE(trans);
+}
+void
+nsHttpConnectionMgr::OnMsgReschedTransaction(int32_t priority, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::OnMsgReschedTransaction [trans=%p]\n", param));
+nsHttpTransaction *trans = (nsHttpTransaction *) param;
+trans->SetPriority(priority);
+nsConnectionEntry *ent = LookupConnectionEntry(trans->ConnectionInfo(),
+nullptr, trans);
+if (ent) {
+int32_t index = ent->mPendingQ.IndexOf(trans);
+if (index >= 0) {
+ent->mPendingQ.RemoveElementAt(index);
+InsertTransactionSorted(ent->mPendingQ, trans);
+}
+}
+NS_RELEASE(trans);
+}
+void
+nsHttpConnectionMgr::OnMsgCancelTransaction(int32_t reason, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::OnMsgCancelTransaction [trans=%p]\n", param));
+nsresult closeCode = static_cast<nsresult>(reason);
+nsHttpTransaction *trans = (nsHttpTransaction *) param;
+//
+// if the transaction owns a connection and the transaction is not done,
+// then ask the connection to close the transaction.  otherwise, close the
+// transaction directly (removing it from the pending queue first).
+//
+nsAHttpConnection *conn = trans->Connection();
+if (conn && !trans->IsDone()) {
+conn->CloseTransaction(trans, closeCode);
+} else {
+nsConnectionEntry *ent =
+LookupConnectionEntry(trans->ConnectionInfo(), nullptr, trans);
+if (ent) {
+int32_t index = ent->mPendingQ.IndexOf(trans);
+if (index >= 0) {
+LOG(("nsHttpConnectionMgr::OnMsgCancelTransaction [trans=%p]"
+" found in pending queue\n", trans));
+ent->mPendingQ.RemoveElementAt(index);
+nsHttpTransaction *temp = trans;
+NS_RELEASE(temp); // b/c NS_RELEASE nulls its argument!
+}
+}
+trans->Close(closeCode);
+// Cancel is a pretty strong signal that things might be hanging
+// so we want to cancel any null transactions related to this connection
+// entry. They are just optimizations, but they aren't hooked up to
+// anything that might get canceled from the rest of gecko, so best
+// to assume that's what was meant by the cancel we did receive if
+// it only applied to something in the queue.
+for (uint32_t index = 0;
+ent && (index < ent->mActiveConns.Length());
+++index) {
+nsHttpConnection *activeConn = ent->mActiveConns[index];
+nsAHttpTransaction *liveTransaction = activeConn->Transaction();
+if (liveTransaction && liveTransaction->IsNullTransaction()) {
+LOG(("nsHttpConnectionMgr::OnMsgCancelTransaction [trans=%p] "
+"also canceling Null Transaction %p on conn %p\n",
+trans, liveTransaction, activeConn));
+activeConn->CloseTransaction(liveTransaction, closeCode);
+}
+}
+}
+NS_RELEASE(trans);
+}
+void
+nsHttpConnectionMgr::OnMsgProcessPendingQ(int32_t, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsHttpConnectionInfo *ci = (nsHttpConnectionInfo *) param;
+if (!ci) {
+LOG(("nsHttpConnectionMgr::OnMsgProcessPendingQ [ci=nullptr]\n"));
+// Try and dispatch everything
+mCT.Enumerate(ProcessAllTransactionsCB, this);
+return;
+}
+LOG(("nsHttpConnectionMgr::OnMsgProcessPendingQ [ci=%s]\n",
+ci->HashKey().get()));
+// start by processing the queue identified by the given connection info.
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (!(ent && ProcessPendingQForEntry(ent, false))) {
+// if we reach here, it means that we couldn't dispatch a transaction
+// for the specified connection info.  walk the connection table...
+mCT.Enumerate(ProcessOneTransactionCB, this);
+}
+NS_RELEASE(ci);
+}
+void
+nsHttpConnectionMgr::OnMsgPruneDeadConnections(int32_t, void *)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::OnMsgPruneDeadConnections\n"));
+// Reset mTimeOfNextWakeUp so that we can find a new shortest value.
+mTimeOfNextWakeUp = UINT64_MAX;
+// check canreuse() for all idle connections plus any active connections on
+// connection entries that are using spdy.
+if (mNumIdleConns || (mNumActiveConns && gHttpHandler->IsSpdyEnabled()))
+mCT.Enumerate(PruneDeadConnectionsCB, this);
+}
+void
+nsHttpConnectionMgr::OnMsgDoShiftReloadConnectionCleanup(int32_t, void *param)
+{
+LOG(("nsHttpConnectionMgr::OnMsgDoShiftReloadConnectionCleanup\n"));
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsRefPtr<nsHttpConnectionInfo> ci =
+dont_AddRef(static_cast<nsHttpConnectionInfo *>(param));
+mCT.Enumerate(ClosePersistentConnectionsCB, this);
+if (ci)
+ResetIPFamilyPreference(ci);
+}
+void
+nsHttpConnectionMgr::OnMsgReclaimConnection(int32_t, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::OnMsgReclaimConnection [conn=%p]\n", param));
+nsHttpConnection *conn = (nsHttpConnection *) param;
+//
+// 1) remove the connection from the active list
+// 2) if keep-alive, add connection to idle list
+// 3) post event to process the pending transaction queue
+//
+nsConnectionEntry *ent = LookupConnectionEntry(conn->ConnectionInfo(),
+conn, nullptr);
+nsHttpConnectionInfo *ci = nullptr;
+if (!ent) {
+// this should never happen
+LOG(("nsHttpConnectionMgr::OnMsgReclaimConnection ent == null\n"));
+MOZ_ASSERT(false, "no connection entry");
+NS_ADDREF(ci = conn->ConnectionInfo());
+}
+else {
+NS_ADDREF(ci = ent->mConnInfo);
+// If the connection is in the active list, remove that entry
+// and the reference held by the mActiveConns list.
+// This is never the final reference on conn as the event context
+// is also holding one that is released at the end of this function.
+if (ent->mUsingSpdy) {
+// Spdy connections aren't reused in the traditional HTTP way in
+// the idleconns list, they are actively multplexed as active
+// conns. Even when they have 0 transactions on them they are
+// considered active connections. So when one is reclaimed it
+// is really complete and is meant to be shut down and not
+// reused.
+conn->DontReuse();
+}
+if (ent->mActiveConns.RemoveElement(conn)) {
+if (conn == ent->mYellowConnection)
+ent->OnYellowComplete();
+nsHttpConnection *temp = conn;
+NS_RELEASE(temp);
+DecrementActiveConnCount(conn);
+ConditionallyStopTimeoutTick();
+}
+if (conn->CanReuse()) {
+LOG(("  adding connection to idle list\n"));
+// Keep The idle connection list sorted with the connections that
+// have moved the largest data pipelines at the front because these
+// connections have the largest cwnds on the server.
+// The linear search is ok here because the number of idleconns
+// in a single entry is generally limited to a small number (i.e. 6)
+uint32_t idx;
+for (idx = 0; idx < ent->mIdleConns.Length(); idx++) {
+nsHttpConnection *idleConn = ent->mIdleConns[idx];
+if (idleConn->MaxBytesRead() < conn->MaxBytesRead())
+break;
+}
+NS_ADDREF(conn);
+ent->mIdleConns.InsertElementAt(idx, conn);
+mNumIdleConns++;
+conn->BeginIdleMonitoring();
+// If the added connection was first idle connection or has shortest
+// time to live among the watched connections, pruning dead
+// connections needs to be done when it can't be reused anymore.
+uint32_t timeToLive = conn->TimeToLive();
+if(!mTimer || NowInSeconds() + timeToLive < mTimeOfNextWakeUp)
+PruneDeadConnectionsAfter(timeToLive);
+}
+else {
+LOG(("  connection cannot be reused; closing connection\n"));
+conn->Close(NS_ERROR_ABORT);
+}
+}
+OnMsgProcessPendingQ(0, ci); // releases |ci|
+NS_RELEASE(conn);
+}
+void
+nsHttpConnectionMgr::OnMsgCompleteUpgrade(int32_t, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsCompleteUpgradeData *data = (nsCompleteUpgradeData *) param;
+LOG(("nsHttpConnectionMgr::OnMsgCompleteUpgrade "
+"this=%p conn=%p listener=%p\n", this, data->mConn.get(),
+data->mUpgradeListener.get()));
+nsCOMPtr<nsISocketTransport> socketTransport;
+nsCOMPtr<nsIAsyncInputStream> socketIn;
+nsCOMPtr<nsIAsyncOutputStream> socketOut;
+nsresult rv;
+rv = data->mConn->TakeTransport(getter_AddRefs(socketTransport),
+getter_AddRefs(socketIn),
+getter_AddRefs(socketOut));
+if (NS_SUCCEEDED(rv))
+data->mUpgradeListener->OnTransportAvailable(socketTransport,
+socketIn,
+socketOut);
+delete data;
+}
+void
+nsHttpConnectionMgr::OnMsgUpdateParam(int32_t, void *param)
+{
+uint16_t name  = (NS_PTR_TO_INT32(param) & 0xFFFF0000) >> 16;
+uint16_t value =  NS_PTR_TO_INT32(param) & 0x0000FFFF;
+switch (name) {
+case MAX_CONNECTIONS:
+mMaxConns = value;
+break;
+case MAX_PERSISTENT_CONNECTIONS_PER_HOST:
+mMaxPersistConnsPerHost = value;
+break;
+case MAX_PERSISTENT_CONNECTIONS_PER_PROXY:
+mMaxPersistConnsPerProxy = value;
+break;
+case MAX_REQUEST_DELAY:
+mMaxRequestDelay = value;
+break;
+case MAX_PIPELINED_REQUESTS:
+mMaxPipelinedRequests = value;
+break;
+case MAX_OPTIMISTIC_PIPELINED_REQUESTS:
+mMaxOptimisticPipelinedRequests = value;
+break;
+default:
+NS_NOTREACHED("unexpected parameter name");
+}
+}
+// nsHttpConnectionMgr::nsConnectionEntry
+nsHttpConnectionMgr::nsConnectionEntry::~nsConnectionEntry()
+{
+if (mSpdyPreferred)
+gHttpHandler->ConnMgr()->RemoveSpdyPreferredEnt(mCoalescingKey);
+NS_RELEASE(mConnInfo);
+}
+void
+nsHttpConnectionMgr::OnMsgProcessFeedback(int32_t, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsHttpPipelineFeedback *fb = (nsHttpPipelineFeedback *)param;
+PipelineFeedbackInfo(fb->mConnInfo, fb->mInfo, fb->mConn, fb->mData);
+delete fb;
+}
+// Read Timeout Tick handlers
+void
+nsHttpConnectionMgr::ActivateTimeoutTick()
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+LOG(("nsHttpConnectionMgr::ActivateTimeoutTick() "
+"this=%p mTimeoutTick=%p\n"));
+// The timer tick should be enabled if it is not already pending.
+// Upon running the tick will rearm itself if there are active
+// connections available.
+if (mTimeoutTick && mTimeoutTickArmed) {
+// make sure we get one iteration on a quick tick
+if (mTimeoutTickNext > 1) {
+mTimeoutTickNext = 1;
+mTimeoutTick->SetDelay(1000);
+}
+return;
+}
+if (!mTimeoutTick) {
+mTimeoutTick = do_CreateInstance(NS_TIMER_CONTRACTID);
+if (!mTimeoutTick) {
+NS_WARNING("failed to create timer for http timeout management");
+return;
+}
+mTimeoutTick->SetTarget(mSocketThreadTarget);
+}
+MOZ_ASSERT(!mTimeoutTickArmed, "timer tick armed");
+mTimeoutTickArmed = true;
+mTimeoutTick->Init(this, 1000, nsITimer::TYPE_REPEATING_SLACK);
+}
+void
+nsHttpConnectionMgr::TimeoutTick()
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+MOZ_ASSERT(mTimeoutTick, "no readtimeout tick");
+LOG(("nsHttpConnectionMgr::TimeoutTick active=%d\n", mNumActiveConns));
+// The next tick will be between 1 second and 1 hr
+// Set it to the max value here, and the TimeoutTickCB()s can
+// reduce it to their local needs.
+mTimeoutTickNext = 3600; // 1hr
+mCT.Enumerate(TimeoutTickCB, this);
+if (mTimeoutTick) {
+mTimeoutTickNext = std::max(mTimeoutTickNext, 1U);
+mTimeoutTick->SetDelay(mTimeoutTickNext * 1000);
+}
+}
+PLDHashOperator
+nsHttpConnectionMgr::TimeoutTickCB(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *closure)
+{
+nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
+LOG(("nsHttpConnectionMgr::TimeoutTickCB() this=%p host=%s "
+"idle=%d active=%d half-len=%d pending=%d\n",
+self, ent->mConnInfo->Host(), ent->mIdleConns.Length(),
+ent->mActiveConns.Length(), ent->mHalfOpens.Length(),
+ent->mPendingQ.Length()));
+// first call the tick handler for each active connection
+PRIntervalTime now = PR_IntervalNow();
+for (uint32_t index = 0; index < ent->mActiveConns.Length(); ++index) {
+uint32_t connNextTimeout =  ent->mActiveConns[index]->ReadTimeoutTick(now);
+self->mTimeoutTickNext = std::min(self->mTimeoutTickNext, connNextTimeout);
+}
+// now check for any stalled half open sockets
+if (ent->mHalfOpens.Length()) {
+TimeStamp now = TimeStamp::Now();
+double maxConnectTime = gHttpHandler->ConnectTimeout();  /* in milliseconds */
+for (uint32_t index = ent->mHalfOpens.Length(); index > 0; ) {
+index--;
+nsHalfOpenSocket *half = ent->mHalfOpens[index];
+double delta = half->Duration(now);
+// If the socket has timed out, close it so the waiting transaction
+// will get the proper signal
+if (delta > maxConnectTime) {
+LOG(("Force timeout of half open to %s after %.2fms.\n",
+ent->mConnInfo->HashKey().get(), delta));
+if (half->SocketTransport())
+half->SocketTransport()->Close(NS_ERROR_ABORT);
+if (half->BackupTransport())
+half->BackupTransport()->Close(NS_ERROR_ABORT);
+}
+// If this half open hangs around for 5 seconds after we've closed() it
+// then just abandon the socket.
+if (delta > maxConnectTime + 5000) {
+LOG(("Abandon half open to %s after %.2fms.\n",
+ent->mConnInfo->HashKey().get(), delta));
+half->Abandon();
+}
+}
+}
+if (ent->mHalfOpens.Length()) {
+self->mTimeoutTickNext = 1;
+}
+return PL_DHASH_NEXT;
+}
+//-----------------------------------------------------------------------------
+// nsHttpConnectionMgr::nsConnectionHandle
+nsHttpConnectionMgr::nsConnectionHandle::~nsConnectionHandle()
+{
+if (mConn) {
+gHttpHandler->ReclaimConnection(mConn);
+NS_RELEASE(mConn);
+}
+}
+NS_IMPL_ISUPPORTS0(nsHttpConnectionMgr::nsConnectionHandle)
+nsHttpConnectionMgr::nsConnectionEntry *
+nsHttpConnectionMgr::GetOrCreateConnectionEntry(nsHttpConnectionInfo *ci)
+{
+nsConnectionEntry *ent = mCT.Get(ci->HashKey());
+if (ent)
+return ent;
+nsHttpConnectionInfo *clone = ci->Clone();
+ent = new nsConnectionEntry(clone);
+mCT.Put(ci->HashKey(), ent);
+return ent;
+}
+nsresult
+nsHttpConnectionMgr::nsConnectionHandle::OnHeadersAvailable(nsAHttpTransaction *trans,
+nsHttpRequestHead *req,
+nsHttpResponseHead *resp,
+bool *reset)
+{
+return mConn->OnHeadersAvailable(trans, req, resp, reset);
+}
+void
+nsHttpConnectionMgr::nsConnectionHandle::CloseTransaction(nsAHttpTransaction *trans, nsresult reason)
+{
+mConn->CloseTransaction(trans, reason);
+}
+nsresult
+nsHttpConnectionMgr::
+nsConnectionHandle::TakeTransport(nsISocketTransport  **aTransport,
+nsIAsyncInputStream **aInputStream,
+nsIAsyncOutputStream **aOutputStream)
+{
+return mConn->TakeTransport(aTransport, aInputStream, aOutputStream);
+}
+void
+nsHttpConnectionMgr::OnMsgSpeculativeConnect(int32_t, void *param)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsRefPtr<SpeculativeConnectArgs> args =
+dont_AddRef(static_cast<SpeculativeConnectArgs *>(param));
+LOG(("nsHttpConnectionMgr::OnMsgSpeculativeConnect [ci=%s]\n",
+args->mTrans->ConnectionInfo()->HashKey().get()));
+nsConnectionEntry *ent =
+GetOrCreateConnectionEntry(args->mTrans->ConnectionInfo());
+// If spdy has previously made a preferred entry for this host via
+// the ip pooling rules. If so, connect to the preferred host instead of
+// the one directly passed in here.
+nsConnectionEntry *preferredEntry = GetSpdyPreferredEnt(ent);
+if (preferredEntry)
+ent = preferredEntry;
+uint32_t parallelSpeculativeConnectLimit =
+gHttpHandler->ParallelSpeculativeConnectLimit();
+bool ignorePossibleSpdyConnections = false;
+bool ignoreIdle = false;
+if (args->mOverridesOK) {
+parallelSpeculativeConnectLimit = args->mParallelSpeculativeConnectLimit;
+ignorePossibleSpdyConnections = args->mIgnorePossibleSpdyConnections;
+ignoreIdle = args->mIgnoreIdle;
+}
+if (ent->SupportsPipelining()) {
+/* Only speculative connect if we're not pipelining and have no other pending
+* unconnected half-opens.. */
+if (ent->UnconnectedHalfOpens() == 0 && ent->mIdleConns.Length() == 0
+&& !RestrictConnections(ent) && !HasPipelines(ent)
+&& !AtActiveConnectionLimit(ent, args->mTrans->Caps())) {
+#ifdef WTF_DEBUG
+fprintf(stderr, "WTF: Creating speculative connection because we have no pipelines\n");
+#endif
+CreateTransport(ent, args->mTrans, args->mTrans->Caps(), true);
+}
+} else if (mNumHalfOpenConns < parallelSpeculativeConnectLimit &&
+((ignoreIdle && (ent->mIdleConns.Length() < parallelSpeculativeConnectLimit)) ||
+!ent->mIdleConns.Length()) &&
+!RestrictConnections(ent, ignorePossibleSpdyConnections) &&
+!AtActiveConnectionLimit(ent, args->mTrans->Caps())) {
+#ifdef WTF_DEBUG
+fprintf(stderr, "WTF: Creating speculative connection because we can't pipeline\n");
+#endif
+CreateTransport(ent, args->mTrans, args->mTrans->Caps(), true);
+} else {
+LOG(("  Transport not created due to existing connection count\n"));
+}
+}
+bool
+nsHttpConnectionMgr::HasPipelines(nsConnectionEntry *ent)
+{
+uint32_t activeCount = ent->mActiveConns.Length();
+if (!ent->SupportsPipelining()) {
+return false;
+}
+for (uint32_t i = 0; i < activeCount; ++i) {
+nsHttpConnection *conn = ent->mActiveConns[i];
+if (!conn->SupportsPipelining())
+continue;
+nsAHttpTransaction *activeTrans = conn->Transaction();
+if (activeTrans && !activeTrans->IsDone() &&
+!NS_FAILED(activeTrans->Status()))
+return true;
+}
+return false;
+}
+bool
+nsHttpConnectionMgr::nsConnectionHandle::IsPersistent()
+{
+return mConn->IsPersistent();
+}
+bool
+nsHttpConnectionMgr::nsConnectionHandle::IsReused()
+{
+return mConn->IsReused();
+}
+void
+nsHttpConnectionMgr::nsConnectionHandle::DontReuse()
+{
+mConn->DontReuse();
+}
+nsresult
+nsHttpConnectionMgr::nsConnectionHandle::PushBack(const char *buf, uint32_t bufLen)
+{
+return mConn->PushBack(buf, bufLen);
+}
+//////////////////////// nsHalfOpenSocket
+NS_IMPL_ISUPPORTS(nsHttpConnectionMgr::nsHalfOpenSocket,
+nsIOutputStreamCallback,
+nsITransportEventSink,
+nsIInterfaceRequestor,
+nsITimerCallback)
+nsHttpConnectionMgr::
+nsHalfOpenSocket::nsHalfOpenSocket(nsConnectionEntry *ent,
+nsAHttpTransaction *trans,
+uint32_t caps)
+: mEnt(ent),
+mTransaction(trans),
+mCaps(caps),
+mSpeculative(false),
+mHasConnected(false)
+{
+MOZ_ASSERT(ent && trans, "constructor with null arguments");
+LOG(("Creating nsHalfOpenSocket [this=%p trans=%p ent=%s]\n",
+this, trans, ent->mConnInfo->Host()));
+}
+nsHttpConnectionMgr::nsHalfOpenSocket::~nsHalfOpenSocket()
+{
+MOZ_ASSERT(!mStreamOut);
+MOZ_ASSERT(!mBackupStreamOut);
+MOZ_ASSERT(!mSynTimer);
+LOG(("Destroying nsHalfOpenSocket [this=%p]\n", this));
+if (mEnt)
+mEnt->RemoveHalfOpen(this);
+}
+nsresult
+nsHttpConnectionMgr::
+nsHalfOpenSocket::SetupStreams(nsISocketTransport **transport,
+nsIAsyncInputStream **instream,
+nsIAsyncOutputStream **outstream,
+bool isBackup)
+{
+nsresult rv;
+const char* types[1];
+types[0] = (mEnt->mConnInfo->UsingSSL()) ?
+"ssl" : gHttpHandler->DefaultSocketType();
+uint32_t typeCount = (types[0] != nullptr);
+nsCOMPtr<nsISocketTransport> socketTransport;
+nsCOMPtr<nsISocketTransportService> sts;
+sts = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = sts->CreateTransport(types, typeCount,
+nsDependentCString(mEnt->mConnInfo->Host()),
+mEnt->mConnInfo->Port(),
+mEnt->mConnInfo->ProxyInfo(),
+getter_AddRefs(socketTransport));
+NS_ENSURE_SUCCESS(rv, rv);
+uint32_t tmpFlags = 0;
+if (mCaps & NS_HTTP_REFRESH_DNS)
+tmpFlags = nsISocketTransport::BYPASS_CACHE;
+if (mCaps & NS_HTTP_LOAD_ANONYMOUS)
+tmpFlags |= nsISocketTransport::ANONYMOUS_CONNECT;
+if (mEnt->mConnInfo->GetPrivate())
+tmpFlags |= nsISocketTransport::NO_PERMANENT_STORAGE;
+// For backup connections, we disable IPv6. That's because some users have
+// broken IPv6 connectivity (leading to very long timeouts), and disabling
+// IPv6 on the backup connection gives them a much better user experience
+// with dual-stack hosts, though they still pay the 250ms delay for each new
+// connection. This strategy is also known as "happy eyeballs".
+if (mEnt->mPreferIPv6) {
+tmpFlags |= nsISocketTransport::DISABLE_IPV4;
+}
+else if (mEnt->mPreferIPv4 ||
+(isBackup && gHttpHandler->FastFallbackToIPv4())) {
+tmpFlags |= nsISocketTransport::DISABLE_IPV6;
+}
+if (IsSpeculative()) {
+tmpFlags |= nsISocketTransport::DISABLE_RFC1918;
+}
+socketTransport->SetConnectionFlags(tmpFlags);
+socketTransport->SetQoSBits(gHttpHandler->GetQoSBits());
+rv = socketTransport->SetEventSink(this, nullptr);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = socketTransport->SetSecurityCallbacks(this);
+NS_ENSURE_SUCCESS(rv, rv);
+nsCOMPtr<nsIOutputStream> sout;
+rv = socketTransport->OpenOutputStream(nsITransport::OPEN_UNBUFFERED,
+0, 0,
+getter_AddRefs(sout));
+NS_ENSURE_SUCCESS(rv, rv);
+nsCOMPtr<nsIInputStream> sin;
+rv = socketTransport->OpenInputStream(nsITransport::OPEN_UNBUFFERED,
+0, 0,
+getter_AddRefs(sin));
+NS_ENSURE_SUCCESS(rv, rv);
+socketTransport.forget(transport);
+CallQueryInterface(sin, instream);
+CallQueryInterface(sout, outstream);
+rv = (*outstream)->AsyncWait(this, 0, 0, nullptr);
+if (NS_SUCCEEDED(rv))
+gHttpHandler->ConnMgr()->StartedConnect();
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::nsHalfOpenSocket::SetupPrimaryStreams()
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsresult rv;
+mPrimarySynStarted = TimeStamp::Now();
+rv = SetupStreams(getter_AddRefs(mSocketTransport),
+getter_AddRefs(mStreamIn),
+getter_AddRefs(mStreamOut),
+false);
+LOG(("nsHalfOpenSocket::SetupPrimaryStream [this=%p ent=%s rv=%x]",
+this, mEnt->mConnInfo->Host(), rv));
+if (NS_FAILED(rv)) {
+if (mStreamOut)
+mStreamOut->AsyncWait(nullptr, 0, 0, nullptr);
+mStreamOut = nullptr;
+mStreamIn = nullptr;
+mSocketTransport = nullptr;
+}
+return rv;
+}
+nsresult
+nsHttpConnectionMgr::nsHalfOpenSocket::SetupBackupStreams()
+{
+mBackupSynStarted = TimeStamp::Now();
+nsresult rv = SetupStreams(getter_AddRefs(mBackupTransport),
+getter_AddRefs(mBackupStreamIn),
+getter_AddRefs(mBackupStreamOut),
+true);
+LOG(("nsHalfOpenSocket::SetupBackupStream [this=%p ent=%s rv=%x]",
+this, mEnt->mConnInfo->Host(), rv));
+if (NS_FAILED(rv)) {
+if (mBackupStreamOut)
+mBackupStreamOut->AsyncWait(nullptr, 0, 0, nullptr);
+mBackupStreamOut = nullptr;
+mBackupStreamIn = nullptr;
+mBackupTransport = nullptr;
+}
+return rv;
+}
+void
+nsHttpConnectionMgr::nsHalfOpenSocket::SetupBackupTimer()
+{
+uint16_t timeout = gHttpHandler->GetIdleSynTimeout();
+MOZ_ASSERT(!mSynTimer, "timer already initd");
+if (timeout && !mTransaction->IsDone()) {
+// Setup the timer that will establish a backup socket
+// if we do not get a writable event on the main one.
+// We do this because a lost SYN takes a very long time
+// to repair at the TCP level.
+//
+// Failure to setup the timer is something we can live with,
+// so don't return an error in that case.
+nsresult rv;
+mSynTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
+if (NS_SUCCEEDED(rv)) {
+mSynTimer->InitWithCallback(this, timeout, nsITimer::TYPE_ONE_SHOT);
+LOG(("nsHalfOpenSocket::SetupBackupTimer() [this=%p]", this));
+}
+}
+else if (timeout) {
+LOG(("nsHalfOpenSocket::SetupBackupTimer() [this=%p],"
+" transaction already done!", this));
+}
+}
+void
+nsHttpConnectionMgr::nsHalfOpenSocket::CancelBackupTimer()
+{
+// If the syntimer is still armed, we can cancel it because no backup
+// socket should be formed at this point
+if (!mSynTimer)
+return;
+LOG(("nsHalfOpenSocket::CancelBackupTimer()"));
+mSynTimer->Cancel();
+mSynTimer = nullptr;
+}
+void
+nsHttpConnectionMgr::nsHalfOpenSocket::Abandon()
+{
+LOG(("nsHalfOpenSocket::Abandon [this=%p ent=%s]",
+this, mEnt->mConnInfo->Host()));
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsRefPtr<nsHalfOpenSocket> deleteProtector(this);
+// Tell socket (and backup socket) to forget the half open socket.
+if (mSocketTransport) {
+mSocketTransport->SetEventSink(nullptr, nullptr);
+mSocketTransport->SetSecurityCallbacks(nullptr);
+mSocketTransport = nullptr;
+}
+if (mBackupTransport) {
+mBackupTransport->SetEventSink(nullptr, nullptr);
+mBackupTransport->SetSecurityCallbacks(nullptr);
+mBackupTransport = nullptr;
+}
+// Tell output stream (and backup) to forget the half open socket.
+if (mStreamOut) {
+gHttpHandler->ConnMgr()->RecvdConnect();
+mStreamOut->AsyncWait(nullptr, 0, 0, nullptr);
+mStreamOut = nullptr;
+}
+if (mBackupStreamOut) {
+gHttpHandler->ConnMgr()->RecvdConnect();
+mBackupStreamOut->AsyncWait(nullptr, 0, 0, nullptr);
+mBackupStreamOut = nullptr;
+}
+// Lose references to input stream (and backup).
+mStreamIn = mBackupStreamIn = nullptr;
+// Stop the timer - we don't want any new backups.
+CancelBackupTimer();
+// Remove the half open from the connection entry.
+if (mEnt)
+mEnt->RemoveHalfOpen(this);
+mEnt = nullptr;
+}
+double
+nsHttpConnectionMgr::nsHalfOpenSocket::Duration(TimeStamp epoch)
+{
+if (mPrimarySynStarted.IsNull())
+return 0;
+return (epoch - mPrimarySynStarted).ToMilliseconds();
+}
+NS_IMETHODIMP // method for nsITimerCallback
+nsHttpConnectionMgr::nsHalfOpenSocket::Notify(nsITimer *timer)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+MOZ_ASSERT(timer == mSynTimer, "wrong timer");
+SetupBackupStreams();
+mSynTimer = nullptr;
+return NS_OK;
+}
+// method for nsIAsyncOutputStreamCallback
+NS_IMETHODIMP
+nsHttpConnectionMgr::
+nsHalfOpenSocket::OnOutputStreamReady(nsIAsyncOutputStream *out)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+MOZ_ASSERT(out == mStreamOut || out == mBackupStreamOut,
+"stream mismatch");
+LOG(("nsHalfOpenSocket::OnOutputStreamReady [this=%p ent=%s %s]\n",
+this, mEnt->mConnInfo->Host(),
+out == mStreamOut ? "primary" : "backup"));
+int32_t index;
+nsresult rv;
+gHttpHandler->ConnMgr()->RecvdConnect();
+CancelBackupTimer();
+// assign the new socket to the http connection
+nsRefPtr<nsHttpConnection> conn = new nsHttpConnection();
+LOG(("nsHalfOpenSocket::OnOutputStreamReady "
+"Created new nshttpconnection %p\n", conn.get()));
+// Some capabilities are needed before a transaciton actually gets
+// scheduled (e.g. how to negotiate false start)
+conn->SetTransactionCaps(mTransaction->Caps());
+NetAddr peeraddr;
+nsCOMPtr<nsIInterfaceRequestor> callbacks;
+mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks));
+if (out == mStreamOut) {
+TimeDuration rtt = TimeStamp::Now() - mPrimarySynStarted;
+rv = conn->Init(mEnt->mConnInfo,
+gHttpHandler->ConnMgr()->mMaxRequestDelay,
+mSocketTransport, mStreamIn, mStreamOut,
+callbacks,
+PR_MillisecondsToInterval(
+static_cast<uint32_t>(rtt.ToMilliseconds())));
+if (NS_SUCCEEDED(mSocketTransport->GetPeerAddr(&peeraddr)))
+mEnt->RecordIPFamilyPreference(peeraddr.raw.family);
+// The nsHttpConnection object now owns these streams and sockets
+mStreamOut = nullptr;
+mStreamIn = nullptr;
+mSocketTransport = nullptr;
+}
+else {
+TimeDuration rtt = TimeStamp::Now() - mBackupSynStarted;
+rv = conn->Init(mEnt->mConnInfo,
+gHttpHandler->ConnMgr()->mMaxRequestDelay,
+mBackupTransport, mBackupStreamIn, mBackupStreamOut,
+callbacks,
+PR_MillisecondsToInterval(
+static_cast<uint32_t>(rtt.ToMilliseconds())));
+if (NS_SUCCEEDED(mBackupTransport->GetPeerAddr(&peeraddr)))
+mEnt->RecordIPFamilyPreference(peeraddr.raw.family);
+// The nsHttpConnection object now owns these streams and sockets
+mBackupStreamOut = nullptr;
+mBackupStreamIn = nullptr;
+mBackupTransport = nullptr;
+}
+if (NS_FAILED(rv)) {
+LOG(("nsHalfOpenSocket::OnOutputStreamReady "
+"conn->init (%p) failed %x\n", conn.get(), rv));
+return rv;
+}
+// This half-open socket has created a connection.  This flag excludes it
+// from counter of actual connections used for checking limits.
+mHasConnected = true;
+// if this is still in the pending list, remove it and dispatch it
+index = mEnt->mPendingQ.IndexOf(mTransaction);
+if (index != -1) {
+MOZ_ASSERT(!mSpeculative,
+"Speculative Half Open found mTranscation");
+nsRefPtr<nsHttpTransaction> temp = dont_AddRef(mEnt->mPendingQ[index]);
+mEnt->mPendingQ.RemoveElementAt(index);
+gHttpHandler->ConnMgr()->AddActiveConn(conn, mEnt);
+#ifdef WTF_DEBUG
+fprintf(stderr, "WTF: Speculative half-opened connection is now ready for %s (pipelines %d)\n",
+mEnt->mConnInfo->Host(), mEnt->SupportsPipelining());
+#endif
+rv = gHttpHandler->ConnMgr()->DispatchTransaction(mEnt, temp, conn);
+}
+else {
+// this transaction was dispatched off the pending q before all the
+// sockets established themselves.
+// After about 1 second allow for the possibility of restarting a
+// transaction due to server close. Keep at sub 1 second as that is the
+// minimum granularity we can expect a server to be timing out with.
+conn->SetIsReusedAfter(950);
+// if we are using ssl and no other transactions are waiting right now,
+// then form a null transaction to drive the SSL handshake to
+// completion. Afterwards the connection will be 100% ready for the next
+// transaction to use it. Make an exception for SSL over HTTP proxy as the
+// NullHttpTransaction does not know how to drive CONNECT.
+if (mEnt->mConnInfo->UsingSSL() && !mEnt->mPendingQ.Length() &&
+!mEnt->mConnInfo->UsingHttpProxy()) {
+LOG(("nsHalfOpenSocket::OnOutputStreamReady null transaction will "
+"be used to finish SSL handshake on conn %p\n", conn.get()));
+nsRefPtr<NullHttpTransaction>  trans =
+new NullHttpTransaction(mEnt->mConnInfo,
+callbacks,
+mCaps & ~NS_HTTP_ALLOW_PIPELINING);
+gHttpHandler->ConnMgr()->AddActiveConn(conn, mEnt);
+conn->Classify(nsAHttpTransaction::CLASS_SOLO);
+rv = gHttpHandler->ConnMgr()->
+DispatchAbstractTransaction(mEnt, trans, mCaps, conn, 0);
+}
+else {
+// otherwise just put this in the persistent connection pool
+LOG(("nsHalfOpenSocket::OnOutputStreamReady no transaction match "
+"returning conn %p to pool\n", conn.get()));
+nsRefPtr<nsHttpConnection> copy(conn);
+// forget() to effectively addref because onmsg*() will drop a ref
+gHttpHandler->ConnMgr()->OnMsgReclaimConnection(
+0, conn.forget().take());
+}
+}
+return rv;
+}
+// method for nsITransportEventSink
+NS_IMETHODIMP
+nsHttpConnectionMgr::nsHalfOpenSocket::OnTransportStatus(nsITransport *trans,
+nsresult status,
+uint64_t progress,
+uint64_t progressMax)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+if (mTransaction)
+mTransaction->OnTransportStatus(trans, status, progress);
+if (trans != mSocketTransport)
+return NS_OK;
+// if we are doing spdy coalescing and haven't recorded the ip address
+// for this entry before then make the hash key if our dns lookup
+// just completed. We can't do coalescing if using a proxy because the
+// ip addresses are not available to the client.
+if (status == NS_NET_STATUS_CONNECTED_TO &&
+gHttpHandler->IsSpdyEnabled() &&
+gHttpHandler->CoalesceSpdy() &&
+mEnt && mEnt->mConnInfo && mEnt->mConnInfo->UsingSSL() &&
+!mEnt->mConnInfo->UsingProxy() &&
+mEnt->mCoalescingKey.IsEmpty()) {
+NetAddr addr;
+nsresult rv = mSocketTransport->GetPeerAddr(&addr);
+if (NS_SUCCEEDED(rv)) {
+mEnt->mCoalescingKey.SetCapacity(kIPv6CStrBufSize + 26);
+NetAddrToString(&addr, mEnt->mCoalescingKey.BeginWriting(), kIPv6CStrBufSize);
+mEnt->mCoalescingKey.SetLength(
+strlen(mEnt->mCoalescingKey.BeginReading()));
+if (mEnt->mConnInfo->GetAnonymous())
+mEnt->mCoalescingKey.AppendLiteral("~A:");
+else
+mEnt->mCoalescingKey.AppendLiteral("~.:");
+mEnt->mCoalescingKey.AppendInt(mEnt->mConnInfo->Port());
+LOG(("nsHttpConnectionMgr::nsHalfOpenSocket::OnTransportStatus "
+"STATUS_CONNECTED_TO Established New Coalescing Key for host "
+"%s [%s]", mEnt->mConnInfo->Host(),
+mEnt->mCoalescingKey.get()));
+gHttpHandler->ConnMgr()->ProcessSpdyPendingQ(mEnt);
+}
+}
+switch (status) {
+case NS_NET_STATUS_CONNECTING_TO:
+// Passed DNS resolution, now trying to connect, start the backup timer
+// only prevent creating another backup transport.
+// We also check for mEnt presence to not instantiate the timer after
+// this half open socket has already been abandoned.  It may happen
+// when we get this notification right between main-thread calls to
+// nsHttpConnectionMgr::Shutdown and nsSocketTransportService::Shutdown
+// where the first abandones all half open socket instances and only
+// after that the second stops the socket thread.
+if (mEnt && !mBackupTransport && !mSynTimer)
+SetupBackupTimer();
+break;
+case NS_NET_STATUS_CONNECTED_TO:
+// TCP connection's up, now transfer or SSL negotiantion starts,
+// no need for backup socket
+CancelBackupTimer();
+break;
+default:
+break;
+}
+return NS_OK;
+}
+// method for nsIInterfaceRequestor
+NS_IMETHODIMP
+nsHttpConnectionMgr::nsHalfOpenSocket::GetInterface(const nsIID &iid,
+void **result)
+{
+if (mTransaction) {
+nsCOMPtr<nsIInterfaceRequestor> callbacks;
+mTransaction->GetSecurityCallbacks(getter_AddRefs(callbacks));
+if (callbacks)
+return callbacks->GetInterface(iid, result);
+}
+return NS_ERROR_NO_INTERFACE;
+}
+nsHttpConnection *
+nsHttpConnectionMgr::nsConnectionHandle::TakeHttpConnection()
+{
+// return our connection object to the caller and clear it internally
+// do not drop our reference - the caller now owns it.
+MOZ_ASSERT(mConn);
+nsHttpConnection *conn = mConn;
+mConn = nullptr;
+return conn;
+}
+uint32_t
+nsHttpConnectionMgr::nsConnectionHandle::CancelPipeline(nsresult reason)
+{
+// no pipeline to cancel
+return 0;
+}
+nsAHttpTransaction::Classifier
+nsHttpConnectionMgr::nsConnectionHandle::Classification()
+{
+if (mConn)
+return mConn->Classification();
+LOG(("nsConnectionHandle::Classification this=%p "
+"has null mConn using CLASS_SOLO default", this));
+return nsAHttpTransaction::CLASS_SOLO;
+}
+// nsConnectionEntry
+nsHttpConnectionMgr::
+nsConnectionEntry::nsConnectionEntry(nsHttpConnectionInfo *ci)
+: mConnInfo(ci)
+, mPipelineState(PS_YELLOW)
+, mYellowGoodEvents(0)
+, mYellowBadEvents(0)
+, mYellowConnection(nullptr)
+, mGreenDepth(kPipelineOpen)
+, mPipeliningPenalty(0)
+, mSpdyCWND(0)
+, mUsingSpdy(false)
+, mTestedSpdy(false)
+, mSpdyPreferred(false)
+, mPreferIPv4(false)
+, mPreferIPv6(false)
+{
+NS_ADDREF(mConnInfo);
+// Randomize the pipeline depth (3..12)
+mGreenDepth = gHttpHandler->GetMaxOptimisticPipelinedRequests()
++ rand() % (gHttpHandler->GetMaxPipelinedRequests()
+- gHttpHandler->GetMaxOptimisticPipelinedRequests());
+if (gHttpHandler->GetPipelineAggressive()) {
+mPipelineState = PS_GREEN;
+}
+mInitialGreenDepth = mGreenDepth;
+memset(mPipeliningClassPenalty, 0, sizeof(int16_t) * nsAHttpTransaction::CLASS_MAX);
+}
+bool
+nsHttpConnectionMgr::nsConnectionEntry::SupportsPipelining()
+{
+return mPipelineState != nsHttpConnectionMgr::PS_RED;
+}
+nsHttpConnectionMgr::PipeliningState
+nsHttpConnectionMgr::nsConnectionEntry::PipelineState()
+{
+return mPipelineState;
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::OnPipelineFeedbackInfo(
+nsHttpConnectionMgr::PipelineFeedbackInfoType info,
+nsHttpConnection *conn,
+uint32_t data)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+if (mPipelineState == PS_YELLOW) {
+if (info & kPipelineInfoTypeBad)
+mYellowBadEvents++;
+else if (info & (kPipelineInfoTypeNeutral | kPipelineInfoTypeGood))
+mYellowGoodEvents++;
+}
+if (mPipelineState == PS_GREEN && info == GoodCompletedOK) {
+int32_t depth = data;
+LOG(("Transaction completed at pipeline depth of %d. Host = %s\n",
+depth, mConnInfo->Host()));
+// Don't set this. We want to keep our initial random value..
+//if (depth >= 3)
+//    mGreenDepth = kPipelineUnlimited;
+}
+nsAHttpTransaction::Classifier classification;
+if (conn)
+classification = conn->Classification();
+else if (info == BadInsufficientFraming ||
+info == BadUnexpectedLarge)
+classification = (nsAHttpTransaction::Classifier) data;
+else
+classification = nsAHttpTransaction::CLASS_SOLO;
+if (gHttpHandler->GetPipelineAggressive() &&
+info & kPipelineInfoTypeBad &&
+info != BadExplicitClose &&
+info != RedVersionTooLow &&
+info != RedBannedServer &&
+info != RedCorruptedContent &&
+info != BadInsufficientFraming) {
+LOG(("minor negative feedback ignored "
+"because of pipeline aggressive mode"));
+}
+else if (info & kPipelineInfoTypeBad) {
+if ((info & kPipelineInfoTypeRed) && (mPipelineState != PS_RED)) {
+LOG(("transition to red from %d. Host = %s.\n",
+mPipelineState, mConnInfo->Host()));
+mPipelineState = PS_RED;
+mPipeliningPenalty = 0;
+#ifdef WTF_TEST
+fprintf(stderr, "WTF-bad: Red pipeline status disabled host %s\n",
+mConnInfo->Host());
+#endif
+}
+if (mLastCreditTime.IsNull())
+mLastCreditTime = TimeStamp::Now();
+// Red* events impact the host globally via mPipeliningPenalty, while
+// Bad* events impact the per class penalty.
+// The individual penalties should be < 16bit-signed-maxint - 25000
+// (approx 7500). Penalties are paid-off either when something promising
+// happens (a successful transaction, or promising headers) or when
+// time goes by at a rate of 1 penalty point every 16 seconds.
+switch (info) {
+case RedVersionTooLow:
+mPipeliningPenalty += 1000;
+break;
+case RedBannedServer:
+mPipeliningPenalty += 7000;
+break;
+case RedCorruptedContent:
+mPipeliningPenalty += 7000;
+break;
+case RedCanceledPipeline:
+mPipeliningPenalty += 60;
+break;
+case BadExplicitClose:
+mPipeliningClassPenalty[classification] += 250;
+break;
+case BadSlowReadMinor:
+mPipeliningClassPenalty[classification] += 5;
+break;
+case BadSlowReadMajor:
+mPipeliningClassPenalty[classification] += 25;
+break;
+case BadInsufficientFraming:
+mPipeliningClassPenalty[classification] += 7000;
+break;
+case BadUnexpectedLarge:
+mPipeliningClassPenalty[classification] += 120;
+break;
+default:
+MOZ_ASSERT(false, "Unknown Bad/Red Pipeline Feedback Event");
+}
+const int16_t kPenalty = 25000;
+mPipeliningPenalty = std::min(mPipeliningPenalty, kPenalty);
+mPipeliningClassPenalty[classification] =
+std::min(mPipeliningClassPenalty[classification], kPenalty);
+LOG(("Assessing red penalty to %s class %d for event %d. "
+"Penalty now %d, throttle[%d] = %d\n", mConnInfo->Host(),
+classification, info, mPipeliningPenalty, classification,
+mPipeliningClassPenalty[classification]));
+}
+else {
+// hand out credits for neutral and good events such as
+// "headers look ok" events
+mPipeliningPenalty = std::max(mPipeliningPenalty - 1, 0);
+mPipeliningClassPenalty[classification] = std::max(mPipeliningClassPenalty[classification] - 1, 0);
+}
+if (mPipelineState == PS_RED && !mPipeliningPenalty)
+{
+LOG(("transition %s to yellow\n", mConnInfo->Host()));
+mPipelineState = PS_YELLOW;
+mYellowConnection = nullptr;
+}
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::SetYellowConnection(nsHttpConnection *conn)
+{
+MOZ_ASSERT(!mYellowConnection && mPipelineState == PS_YELLOW,
+"yellow connection already set or state is not yellow");
+mYellowConnection = conn;
+mYellowGoodEvents = mYellowBadEvents = 0;
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::OnYellowComplete()
+{
+if (mPipelineState == PS_YELLOW) {
+if (mYellowGoodEvents && !mYellowBadEvents) {
+LOG(("transition %s to green\n", mConnInfo->Host()));
+mPipelineState = PS_GREEN;
+mGreenDepth = mInitialGreenDepth;
+}
+else {
+// The purpose of the yellow state is to witness at least
+// one successful pipelined transaction without seeing any
+// kind of negative feedback before opening the flood gates.
+// If we haven't confirmed that, then transfer back to red.
+LOG(("transition %s to red from yellow return\n",
+mConnInfo->Host()));
+mPipelineState = PS_RED;
+}
+}
+mYellowConnection = nullptr;
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::CreditPenalty()
+{
+if (mLastCreditTime.IsNull())
+return;
+// Decrease penalty values by 1 for every 16 seconds
+// (i.e 3.7 per minute, or 1000 every 4h20m)
+TimeStamp now = TimeStamp::Now();
+TimeDuration elapsedTime = now - mLastCreditTime;
+uint32_t creditsEarned =
+static_cast<uint32_t>(elapsedTime.ToSeconds()) >> 4;
+bool failed = false;
+if (creditsEarned > 0) {
+mPipeliningPenalty =
+std::max(int32_t(mPipeliningPenalty - creditsEarned), 0);
+if (mPipeliningPenalty > 0)
+failed = true;
+for (int32_t i = 0; i < nsAHttpTransaction::CLASS_MAX; ++i) {
+mPipeliningClassPenalty[i]  =
+std::max(int32_t(mPipeliningClassPenalty[i] - creditsEarned), 0);
+failed = failed || (mPipeliningClassPenalty[i] > 0);
+}
+// update last credit mark to reflect elapsed time
+mLastCreditTime += TimeDuration::FromSeconds(creditsEarned << 4);
+}
+else {
+failed = true;                         /* just assume this */
+}
+// If we are no longer red then clear the credit counter - you only
+// get credits for time spent in the red state
+if (!failed)
+mLastCreditTime = TimeStamp();    /* reset to null timestamp */
+if (mPipelineState == PS_RED && !mPipeliningPenalty)
+{
+LOG(("transition %s to yellow based on time credit\n",
+mConnInfo->Host()));
+mPipelineState = PS_YELLOW;
+mYellowConnection = nullptr;
+}
+}
+uint32_t
+nsHttpConnectionMgr::
+nsConnectionEntry::MaxPipelineDepth(nsAHttpTransaction::Classifier aClass)
+{
+// Still subject to configuration limit no matter return value
+if ((mPipelineState == PS_RED) || (mPipeliningClassPenalty[aClass] > 0))
+return 0;
+if (mPipelineState == PS_YELLOW)
+return kPipelineRestricted;
+return mGreenDepth;
+}
+PLDHashOperator
+nsHttpConnectionMgr::ReadConnectionEntry(const nsACString &key,
+nsAutoPtr<nsConnectionEntry> &ent,
+void *aArg)
+{
+if (ent->mConnInfo->GetPrivate())
+return PL_DHASH_NEXT;
+nsTArray<HttpRetParams> *args = static_cast<nsTArray<HttpRetParams> *> (aArg);
+HttpRetParams data;
+data.host = ent->mConnInfo->Host();
+data.port = ent->mConnInfo->Port();
+for (uint32_t i = 0; i < ent->mActiveConns.Length(); i++) {
+HttpConnInfo info;
+info.ttl = ent->mActiveConns[i]->TimeToLive();
+info.rtt = ent->mActiveConns[i]->Rtt();
+if (ent->mActiveConns[i]->UsingSpdy())
+info.SetHTTP2ProtocolVersion(ent->mActiveConns[i]->GetSpdyVersion());
+else
+info.SetHTTP1ProtocolVersion(ent->mActiveConns[i]->GetLastHttpResponseVersion());
+data.active.AppendElement(info);
+}
+for (uint32_t i = 0; i < ent->mIdleConns.Length(); i++) {
+HttpConnInfo info;
+info.ttl = ent->mIdleConns[i]->TimeToLive();
+info.rtt = ent->mIdleConns[i]->Rtt();
+info.SetHTTP1ProtocolVersion(ent->mIdleConns[i]->GetLastHttpResponseVersion());
+data.idle.AppendElement(info);
+}
+for(uint32_t i = 0; i < ent->mHalfOpens.Length(); i++) {
+HalfOpenSockets hSocket;
+hSocket.speculative = ent->mHalfOpens[i]->IsSpeculative();
+data.halfOpens.AppendElement(hSocket);
+}
+data.spdy = ent->mUsingSpdy;
+data.ssl = ent->mConnInfo->UsingSSL();
+args->AppendElement(data);
+return PL_DHASH_NEXT;
+}
+bool
+nsHttpConnectionMgr::GetConnectionData(nsTArray<HttpRetParams> *aArg)
+{
+mCT.Enumerate(ReadConnectionEntry, aArg);
+return true;
+}
+void
+nsHttpConnectionMgr::ResetIPFamilyPreference(nsHttpConnectionInfo *ci)
+{
+MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
+nsConnectionEntry *ent = LookupConnectionEntry(ci, nullptr, nullptr);
+if (ent)
+ent->ResetIPFamilyPreference();
+}
+uint32_t
+nsHttpConnectionMgr::
+nsConnectionEntry::UnconnectedHalfOpens()
+{
+uint32_t unconnectedHalfOpens = 0;
+for (uint32_t i = 0; i < mHalfOpens.Length(); ++i) {
+if (!mHalfOpens[i]->HasConnected())
+++unconnectedHalfOpens;
+}
+return unconnectedHalfOpens;
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::RemoveHalfOpen(nsHalfOpenSocket *halfOpen)
+{
+// A failure to create the transport object at all
+// will result in it not being present in the halfopen table
+// so ignore failures of RemoveElement()
+mHalfOpens.RemoveElement(halfOpen);
+gHttpHandler->ConnMgr()->mNumHalfOpenConns--;
+if (!UnconnectedHalfOpens())
+// perhaps this reverted RestrictConnections()
+// use the PostEvent version of processpendingq to avoid
+// altering the pending q vector from an arbitrary stack
+gHttpHandler->ConnMgr()->ProcessPendingQ(mConnInfo);
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::RecordIPFamilyPreference(uint16_t family)
+{
+if (family == PR_AF_INET && !mPreferIPv6)
+mPreferIPv4 = true;
+if (family == PR_AF_INET6 && !mPreferIPv4)
+mPreferIPv6 = true;
+}
+void
+nsHttpConnectionMgr::
+nsConnectionEntry::ResetIPFamilyPreference()
+{
+mPreferIPv4 = false;
+mPreferIPv6 = false;
+}
+} // namespace mozilla::net
+} // namespace mozilla

The Tor Browser / file comparison

comparison: netwerk/protocol/http/nsHttpConnectionMgr.cpp

netwerk/protocol/http/nsHttpConnectionMgr.cpp