--- a/netwerk/protocol/http/Http2Session.cpp
+++ b/netwerk/protocol/http/Http2Session.cpp
@@ -61,49 +61,49 @@ const uint8_t Http2Session::kMagicHello[
do { \
(o)->mGoAwayReason = (x); \
return NS_ERROR_ILLEGAL_VALUE; \
} while (0)
Http2Session::Http2Session(nsAHttpTransaction *aHttpTransaction,
nsISocketTransport *aSocketTransport,
int32_t firstPriority)
- : mSocketTransport(aSocketTransport),
- mSegmentReader(nullptr),
- mSegmentWriter(nullptr),
- mNextStreamID(3), // 1 is reserved for Updgrade handshakes
- mConcurrentHighWater(0),
- mDownstreamState(BUFFERING_OPENING_SETTINGS),
- mInputFrameBufferSize(kDefaultBufferSize),
- mInputFrameBufferUsed(0),
- mInputFrameFinal(false),
- mInputFrameDataStream(nullptr),
- mNeedsCleanup(nullptr),
- mDownstreamRstReason(NO_HTTP_ERROR),
- mExpectedHeaderID(0),
- mExpectedPushPromiseID(0),
- mContinuedPromiseStream(0),
- mShouldGoAway(false),
- mClosed(false),
- mCleanShutdown(false),
- mTLSProfileConfirmed(false),
- mGoAwayReason(NO_HTTP_ERROR),
- mGoAwayID(0),
- mOutgoingGoAwayID(0),
- mMaxConcurrent(kDefaultMaxConcurrent),
- mConcurrent(0),
- mServerPushedResources(0),
- mServerInitialStreamWindow(kDefaultRwin),
- mLocalSessionWindow(kDefaultRwin),
- mServerSessionWindow(kDefaultRwin),
- mOutputQueueSize(kDefaultQueueSize),
- mOutputQueueUsed(0),
- mOutputQueueSent(0),
- mLastReadEpoch(PR_IntervalNow()),
- mPingSentEpoch(0)
+ : mSocketTransport(aSocketTransport)
+ , mSegmentReader(nullptr)
+ , mSegmentWriter(nullptr)
+ , mNextStreamID(3) // 1 is reserved for Updgrade handshakes
+ , mConcurrentHighWater(0)
+ , mDownstreamState(BUFFERING_OPENING_SETTINGS)
+ , mInputFrameBufferSize(kDefaultBufferSize)
+ , mInputFrameBufferUsed(0)
+ , mInputFrameFinal(false)
+ , mInputFrameDataStream(nullptr)
+ , mNeedsCleanup(nullptr)
+ , mDownstreamRstReason(NO_HTTP_ERROR)
+ , mExpectedHeaderID(0)
+ , mExpectedPushPromiseID(0)
+ , mContinuedPromiseStream(0)
+ , mShouldGoAway(false)
+ , mClosed(false)
+ , mCleanShutdown(false)
+ , mTLSProfileConfirmed(false)
+ , mGoAwayReason(NO_HTTP_ERROR)
+ , mGoAwayID(0)
+ , mOutgoingGoAwayID(0)
+ , mMaxConcurrent(kDefaultMaxConcurrent)
+ , mConcurrent(0)
+ , mServerPushedResources(0)
+ , mServerInitialStreamWindow(kDefaultRwin)
+ , mLocalSessionWindow(kDefaultRwin)
+ , mServerSessionWindow(kDefaultRwin)
+ , mOutputQueueSize(kDefaultQueueSize)
+ , mOutputQueueUsed(0)
+ , mOutputQueueSent(0)
+ , mLastReadEpoch(PR_IntervalNow())
+ , mPingSentEpoch(0)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
static uint64_t sSerial;
mSerial = ++sSerial;
LOG3(("Http2Session::Http2Session %p transaction 1 = %p serial=0x%X\n",
this, aHttpTransaction, mSerial));
@@ -547,27 +547,27 @@ Http2Session::GetWriteQueueSize()
return mReadyForWrite.GetSize();
}
void
Http2Session::ChangeDownstreamState(enum internalStateType newState)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
- LOG3(("Http2Stream::ChangeDownstreamState() %p from %X to %X",
+ LOG3(("Http2Session::ChangeDownstreamState() %p from %X to %X",
this, mDownstreamState, newState));
mDownstreamState = newState;
}
void
Http2Session::ResetDownstreamState()
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
- LOG3(("Http2Stream::ResetDownstreamState() %p", this));
+ LOG3(("Http2Session::ResetDownstreamState() %p", this));
ChangeDownstreamState(BUFFERING_FRAME_HEADER);
if (mInputFrameFinal && mInputFrameDataStream) {
mInputFrameFinal = false;
LOG3((" SetRecvdFin id=0x%x\n", mInputFrameDataStream->StreamID()));
mInputFrameDataStream->SetRecvdFin(true);
MaybeDecrementConcurrent(mInputFrameDataStream);
}
--- a/netwerk/protocol/http/Http2Stream.cpp
+++ b/netwerk/protocol/http/Http2Stream.cpp
@@ -34,44 +34,44 @@ extern PRThread *gSocketThread;
#endif
namespace mozilla {
namespace net {
Http2Stream::Http2Stream(nsAHttpTransaction *httpTransaction,
Http2Session *session,
int32_t priority)
- : mStreamID(0),
- mSession(session),
- mUpstreamState(GENERATING_HEADERS),
- mState(IDLE),
- mAllHeadersSent(0),
- mAllHeadersReceived(0),
- mTransaction(httpTransaction),
- mSocketTransport(session->SocketTransport()),
- mSegmentReader(nullptr),
- mSegmentWriter(nullptr),
- mChunkSize(session->SendingChunkSize()),
- mRequestBlockedOnRead(0),
- mRecvdFin(0),
- mRecvdReset(0),
- mSentReset(0),
- mCountAsActive(0),
- mSentFin(0),
- mSentWaitingFor(0),
- mSetTCPSocketBuffer(0),
- mTxInlineFrameSize(Http2Session::kDefaultBufferSize),
- mTxInlineFrameUsed(0),
- mTxStreamFrameSize(0),
- mRequestBodyLenRemaining(0),
- mLocalUnacked(0),
- mBlockedOnRwin(false),
- mTotalSent(0),
- mTotalRead(0),
- mPushSource(nullptr)
+ : mStreamID(0)
+ , mSession(session)
+ , mUpstreamState(GENERATING_HEADERS)
+ , mState(IDLE)
+ , mAllHeadersSent(0)
+ , mAllHeadersReceived(0)
+ , mTransaction(httpTransaction)
+ , mSocketTransport(session->SocketTransport())
+ , mSegmentReader(nullptr)
+ , mSegmentWriter(nullptr)
+ , mChunkSize(session->SendingChunkSize())
+ , mRequestBlockedOnRead(0)
+ , mRecvdFin(0)
+ , mRecvdReset(0)
+ , mSentReset(0)
+ , mCountAsActive(0)
+ , mSentFin(0)
+ , mSentWaitingFor(0)
+ , mSetTCPSocketBuffer(0)
+ , mTxInlineFrameSize(Http2Session::kDefaultBufferSize)
+ , mTxInlineFrameUsed(0)
+ , mTxStreamFrameSize(0)
+ , mRequestBodyLenRemaining(0)
+ , mLocalUnacked(0)
+ , mBlockedOnRwin(false)
+ , mTotalSent(0)
+ , mTotalRead(0)
+ , mPushSource(nullptr)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
LOG3(("Http2Stream::Http2Stream %p", this));
mServerReceiveWindow = session->GetServerInitialStreamWindow();
mClientReceiveWindow = session->PushAllowance();
--- a/netwerk/protocol/http/SpdySession3.cpp
+++ b/netwerk/protocol/http/SpdySession3.cpp
@@ -40,44 +40,44 @@ namespace net {
// implements some of the same abstract classes.
NS_IMPL_ADDREF(SpdySession3)
NS_IMPL_RELEASE(SpdySession3)
NS_INTERFACE_MAP_BEGIN(SpdySession3)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
NS_INTERFACE_MAP_END
SpdySession3::SpdySession3(nsAHttpTransaction *aHttpTransaction,
- nsISocketTransport *aSocketTransport,
- int32_t firstPriority)
- : mSocketTransport(aSocketTransport),
- mSegmentReader(nullptr),
- mSegmentWriter(nullptr),
- mNextStreamID(1),
- mConcurrentHighWater(0),
- mDownstreamState(BUFFERING_FRAME_HEADER),
- mInputFrameBufferSize(kDefaultBufferSize),
- mInputFrameBufferUsed(0),
- mInputFrameDataLast(false),
- mInputFrameDataStream(nullptr),
- mNeedsCleanup(nullptr),
- mShouldGoAway(false),
- mClosed(false),
- mCleanShutdown(false),
- mDataPending(false),
- mGoAwayID(0),
- mMaxConcurrent(kDefaultMaxConcurrent),
- mConcurrent(0),
- mServerPushedResources(0),
- mServerInitialWindow(kDefaultServerRwin),
- mOutputQueueSize(kDefaultQueueSize),
- mOutputQueueUsed(0),
- mOutputQueueSent(0),
- mLastReadEpoch(PR_IntervalNow()),
- mPingSentEpoch(0),
- mNextPingID(1)
+ nsISocketTransport *aSocketTransport,
+ int32_t firstPriority)
+ : mSocketTransport(aSocketTransport)
+ , mSegmentReader(nullptr)
+ , mSegmentWriter(nullptr)
+ , mNextStreamID(1)
+ , mConcurrentHighWater(0)
+ , mDownstreamState(BUFFERING_FRAME_HEADER)
+ , mInputFrameBufferSize(kDefaultBufferSize)
+ , mInputFrameBufferUsed(0)
+ , mInputFrameDataLast(false)
+ , mInputFrameDataStream(nullptr)
+ , mNeedsCleanup(nullptr)
+ , mShouldGoAway(false)
+ , mClosed(false)
+ , mCleanShutdown(false)
+ , mDataPending(false)
+ , mGoAwayID(0)
+ , mMaxConcurrent(kDefaultMaxConcurrent)
+ , mConcurrent(0)
+ , mServerPushedResources(0)
+ , mServerInitialWindow(kDefaultServerRwin)
+ , mOutputQueueSize(kDefaultQueueSize)
+ , mOutputQueueUsed(0)
+ , mOutputQueueSent(0)
+ , mLastReadEpoch(PR_IntervalNow())
+ , mPingSentEpoch(0)
+ , mNextPingID(1)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
static uint64_t sSerial;
mSerial = ++sSerial;
LOG3(("SpdySession3::SpdySession3 %p transaction 1 = %p serial=0x%X\n",
this, aHttpTransaction, mSerial));
@@ -95,18 +95,18 @@ SpdySession3::SpdySession3(nsAHttpTransa
AddStream(aHttpTransaction, firstPriority);
mLastDataReadEpoch = mLastReadEpoch;
mPingThreshold = gHttpHandler->SpdyPingThreshold();
}
PLDHashOperator
SpdySession3::ShutdownEnumerator(nsAHttpTransaction *key,
- nsAutoPtr<SpdyStream3> &stream,
- void *closure)
+ nsAutoPtr<SpdyStream3> &stream,
+ void *closure)
{
SpdySession3 *self = static_cast<SpdySession3 *>(closure);
// On a clean server hangup the server sets the GoAwayID to be the ID of
// the last transaction it processed. If the ID of stream in the
// local stream is greater than that it can safely be restarted because the
// server guarantees it was not partially processed. Streams that have not
// registered an ID haven't actually been sent yet so they can always be
@@ -151,17 +151,17 @@ SpdySession3::~SpdySession3()
Telemetry::Accumulate(Telemetry::SPDY_PARALLEL_STREAMS, mConcurrentHighWater);
Telemetry::Accumulate(Telemetry::SPDY_REQUEST_PER_CONN, (mNextStreamID - 1) / 2);
Telemetry::Accumulate(Telemetry::SPDY_SERVER_INITIATED_STREAMS,
mServerPushedResources);
}
void
SpdySession3::LogIO(SpdySession3 *self, SpdyStream3 *stream, const char *label,
- const char *data, uint32_t datalen)
+ const char *data, uint32_t datalen)
{
if (!LOG4_ENABLED())
return;
LOG4(("SpdySession3::LogIO %p stream=%p id=0x%X [%s]",
self, stream, stream ? stream->StreamID() : 0, label));
// Max line is (16 * 3) + 10(prefix) + newline + null
@@ -335,17 +335,17 @@ SpdySession3::RegisterStreamID(SpdyStrea
}
mStreamIDHash.Put(aNewID, stream);
return aNewID;
}
bool
SpdySession3::AddStream(nsAHttpTransaction *aHttpTransaction,
- int32_t aPriority)
+ int32_t aPriority)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
// integrity check
if (mStreamTransactionHash.Get(aHttpTransaction)) {
LOG3((" New transaction already present\n"));
MOZ_ASSERT(false, "AddStream duplicate transaction pointer");
return false;
@@ -415,17 +415,17 @@ SpdySession3::ProcessPending()
LOG3(("SpdySession3::ProcessPending %p stream %p activated from queue.",
this, stream));
ActivateStream(stream);
}
}
nsresult
SpdySession3::NetworkRead(nsAHttpSegmentWriter *writer, char *buf,
- uint32_t count, uint32_t *countWritten)
+ uint32_t count, uint32_t *countWritten)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
if (!count) {
*countWritten = 0;
return NS_OK;
}
@@ -505,27 +505,27 @@ SpdySession3::GetWriteQueueSize()
return mReadyForWrite.GetSize();
}
void
SpdySession3::ChangeDownstreamState(enum stateType newState)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
- LOG3(("SpdyStream3::ChangeDownstreamState() %p from %X to %X",
+ LOG3(("SpdySession3::ChangeDownstreamState() %p from %X to %X",
this, mDownstreamState, newState));
mDownstreamState = newState;
}
void
SpdySession3::ResetDownstreamState()
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
- LOG3(("SpdyStream3::ResetDownstreamState() %p", this));
+ LOG3(("SpdySession3::ResetDownstreamState() %p", this));
ChangeDownstreamState(BUFFERING_FRAME_HEADER);
if (mInputFrameDataLast && mInputFrameDataStream) {
mInputFrameDataLast = false;
if (!mInputFrameDataStream->RecvdFin()) {
LOG3((" SetRecvdFin id=0x%x\n", mInputFrameDataStream->StreamID()));
mInputFrameDataStream->SetRecvdFin(true);
DecrementConcurrent(mInputFrameDataStream);
@@ -839,17 +839,17 @@ SpdySession3::VerifyStream(SpdyStream3 *
aOptionalID, aStream->Transaction(), test));
MOZ_ASSERT(false, "VerifyStream");
return false;
}
void
SpdySession3::CleanupStream(SpdyStream3 *aStream, nsresult aResult,
- rstReason aResetCode)
+ rstReason aResetCode)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
LOG3(("SpdySession3::CleanupStream %p %p 0x%X %X\n",
this, aStream, aStream ? aStream->StreamID() : 0, aResult));
if (!aStream) {
return;
}
@@ -1635,18 +1635,18 @@ SpdySession3::HandleCredential(SpdySessi
//-----------------------------------------------------------------------------
// nsAHttpTransaction. It is expected that nsHttpConnection is the caller
// of these methods
//-----------------------------------------------------------------------------
void
SpdySession3::OnTransportStatus(nsITransport* aTransport,
- nsresult aStatus,
- uint64_t aProgress)
+ nsresult aStatus,
+ uint64_t aProgress)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
switch (aStatus) {
// These should appear only once, deliver to the first
// transaction on the session.
case NS_NET_STATUS_RESOLVING_HOST:
case NS_NET_STATUS_RESOLVED_HOST:
@@ -1691,18 +1691,18 @@ SpdySession3::OnTransportStatus(nsITrans
// ReadSegments() is used to write data to the network. Generally, HTTP
// request data is pulled from the approriate transaction and
// converted to SPDY data. Sometimes control data like window-update are
// generated instead.
nsresult
SpdySession3::ReadSegments(nsAHttpSegmentReader *reader,
- uint32_t count,
- uint32_t *countRead)
+ uint32_t count,
+ uint32_t *countRead)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
MOZ_ASSERT(!mSegmentReader || !reader || (mSegmentReader == reader),
"Inconsistent Write Function Callback");
if (reader)
mSegmentReader = reader;
@@ -1797,18 +1797,18 @@ SpdySession3::ReadSegments(nsAHttpSegmen
// we call writer->OnWriteSegment via NetworkRead() to get a spdy header..
// and decide if it is data or control.. if it is control, just deal with it.
// if it is data, identify the spdy stream
// call stream->WriteSegments which can call this::OnWriteSegment to get the
// data. It always gets full frames if they are part of the stream
nsresult
SpdySession3::WriteSegments(nsAHttpSegmentWriter *writer,
- uint32_t count,
- uint32_t *countWritten)
+ uint32_t count,
+ uint32_t *countWritten)
{
typedef nsresult (*Control_FX) (SpdySession3 *self);
static const Control_FX sControlFunctions[] =
{
nullptr,
SpdySession3::HandleSynStream,
SpdySession3::HandleSynReply,
SpdySession3::HandleRstStream,
@@ -2235,17 +2235,17 @@ SpdySession3::Close(nsresult aReason)
GenerateGoAway(goAwayReason);
mConnection = nullptr;
mSegmentReader = nullptr;
mSegmentWriter = nullptr;
}
void
SpdySession3::CloseTransaction(nsAHttpTransaction *aTransaction,
- nsresult aResult)
+ nsresult aResult)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
LOG3(("SpdySession3::CloseTransaction %p %p %x", this, aTransaction, aResult));
// Generally this arrives as a cancel event from the connection manager.
// need to find the stream and call CleanupStream() on it.
SpdyStream3 *stream = mStreamTransactionHash.Get(aTransaction);
@@ -2263,18 +2263,18 @@ SpdySession3::CloseTransaction(nsAHttpTr
//-----------------------------------------------------------------------------
// nsAHttpSegmentReader
//-----------------------------------------------------------------------------
nsresult
SpdySession3::OnReadSegment(const char *buf,
- uint32_t count,
- uint32_t *countRead)
+ uint32_t count,
+ uint32_t *countRead)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
nsresult rv;
// If we can release old queued data then we can try and write the new
// data directly to the network without using the output queue at all
if (mOutputQueueUsed)
@@ -2360,18 +2360,18 @@ SpdySession3::CommitToSegmentSize(uint32
}
//-----------------------------------------------------------------------------
// nsAHttpSegmentWriter
//-----------------------------------------------------------------------------
nsresult
SpdySession3::OnWriteSegment(char *buf,
- uint32_t count,
- uint32_t *countWritten)
+ uint32_t count,
+ uint32_t *countWritten)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
nsresult rv;
if (!mSegmentWriter) {
// the only way this could happen would be if Close() were called on the
// stack with WriteSegments()
return NS_ERROR_FAILURE;
@@ -2504,18 +2504,18 @@ SpdySession3::TransactionHasDataToWrite(
bool
SpdySession3::IsPersistent()
{
return true;
}
nsresult
SpdySession3::TakeTransport(nsISocketTransport **,
- nsIAsyncInputStream **,
- nsIAsyncOutputStream **)
+ nsIAsyncInputStream **,
+ nsIAsyncOutputStream **)
{
MOZ_ASSERT(false, "TakeTransport of SpdySession3");
return NS_ERROR_UNEXPECTED;
}
nsHttpConnection *
SpdySession3::TakeHttpConnection()
{
@@ -2690,19 +2690,19 @@ nsAHttpConnection *
SpdySession3::Connection()
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
return mConnection;
}
nsresult
SpdySession3::OnHeadersAvailable(nsAHttpTransaction *transaction,
- nsHttpRequestHead *requestHead,
- nsHttpResponseHead *responseHead,
- bool *reset)
+ nsHttpRequestHead *requestHead,
+ nsHttpResponseHead *responseHead,
+ bool *reset)
{
return mConnection->OnHeadersAvailable(transaction,
requestHead,
responseHead,
reset);
}
bool
--- a/netwerk/protocol/http/SpdySession31.cpp
+++ b/netwerk/protocol/http/SpdySession31.cpp
@@ -43,44 +43,44 @@ NS_IMPL_ADDREF(SpdySession31)
NS_IMPL_RELEASE(SpdySession31)
NS_INTERFACE_MAP_BEGIN(SpdySession31)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsAHttpConnection)
NS_INTERFACE_MAP_END
SpdySession31::SpdySession31(nsAHttpTransaction *aHttpTransaction,
nsISocketTransport *aSocketTransport,
int32_t firstPriority)
- : mSocketTransport(aSocketTransport),
- mSegmentReader(nullptr),
- mSegmentWriter(nullptr),
- mNextStreamID(1),
- mConcurrentHighWater(0),
- mDownstreamState(BUFFERING_FRAME_HEADER),
- mInputFrameBufferSize(kDefaultBufferSize),
- mInputFrameBufferUsed(0),
- mInputFrameDataLast(false),
- mInputFrameDataStream(nullptr),
- mNeedsCleanup(nullptr),
- mShouldGoAway(false),
- mClosed(false),
- mCleanShutdown(false),
- mDataPending(false),
- mGoAwayID(0),
- mMaxConcurrent(kDefaultMaxConcurrent),
- mConcurrent(0),
- mServerPushedResources(0),
- mServerInitialStreamWindow(kDefaultRwin),
- mLocalSessionWindow(kDefaultRwin),
- mRemoteSessionWindow(kDefaultRwin),
- mOutputQueueSize(kDefaultQueueSize),
- mOutputQueueUsed(0),
- mOutputQueueSent(0),
- mLastReadEpoch(PR_IntervalNow()),
- mPingSentEpoch(0),
- mNextPingID(1)
+ : mSocketTransport(aSocketTransport)
+ , mSegmentReader(nullptr)
+ , mSegmentWriter(nullptr)
+ , mNextStreamID(1)
+ , mConcurrentHighWater(0)
+ , mDownstreamState(BUFFERING_FRAME_HEADER)
+ , mInputFrameBufferSize(kDefaultBufferSize)
+ , mInputFrameBufferUsed(0)
+ , mInputFrameDataLast(false)
+ , mInputFrameDataStream(nullptr)
+ , mNeedsCleanup(nullptr)
+ , mShouldGoAway(false)
+ , mClosed(false)
+ , mCleanShutdown(false)
+ , mDataPending(false)
+ , mGoAwayID(0)
+ , mMaxConcurrent(kDefaultMaxConcurrent)
+ , mConcurrent(0)
+ , mServerPushedResources(0)
+ , mServerInitialStreamWindow(kDefaultRwin)
+ , mLocalSessionWindow(kDefaultRwin)
+ , mRemoteSessionWindow(kDefaultRwin)
+ , mOutputQueueSize(kDefaultQueueSize)
+ , mOutputQueueUsed(0)
+ , mOutputQueueSent(0)
+ , mLastReadEpoch(PR_IntervalNow())
+ , mPingSentEpoch(0)
+ , mNextPingID(1)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
static uint64_t sSerial;
mSerial = ++sSerial;
LOG3(("SpdySession31::SpdySession31 %p transaction 1 = %p serial=0x%X\n",
this, aHttpTransaction, mSerial));
@@ -98,19 +98,19 @@ SpdySession31::SpdySession31(nsAHttpTran
if (!aHttpTransaction->IsNullTransaction())
AddStream(aHttpTransaction, firstPriority);
mLastDataReadEpoch = mLastReadEpoch;
mPingThreshold = gHttpHandler->SpdyPingThreshold();
}
PLDHashOperator
- SpdySession31::ShutdownEnumerator(nsAHttpTransaction *key,
- nsAutoPtr<SpdyStream31> &stream,
- void *closure)
+SpdySession31::ShutdownEnumerator(nsAHttpTransaction *key,
+ nsAutoPtr<SpdyStream31> &stream,
+ void *closure)
{
SpdySession31 *self = static_cast<SpdySession31 *>(closure);
// On a clean server hangup the server sets the GoAwayID to be the ID of
// the last transaction it processed. If the ID of stream in the
// local stream is greater than that it can safely be restarted because the
// server guarantees it was not partially processed. Streams that have not
// registered an ID haven't actually been sent yet so they can always be
@@ -510,27 +510,27 @@ SpdySession31::GetWriteQueueSize()
return mReadyForWrite.GetSize();
}
void
SpdySession31::ChangeDownstreamState(enum stateType newState)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
- LOG3(("SpdyStream31::ChangeDownstreamState() %p from %X to %X",
+ LOG3(("SpdySession31::ChangeDownstreamState() %p from %X to %X",
this, mDownstreamState, newState));
mDownstreamState = newState;
}
void
SpdySession31::ResetDownstreamState()
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
- LOG3(("SpdyStream31::ResetDownstreamState() %p", this));
+ LOG3(("SpdySession31::ResetDownstreamState() %p", this));
ChangeDownstreamState(BUFFERING_FRAME_HEADER);
if (mInputFrameDataLast && mInputFrameDataStream) {
mInputFrameDataLast = false;
if (!mInputFrameDataStream->RecvdFin()) {
LOG3((" SetRecvdFin id=0x%x\n", mInputFrameDataStream->StreamID()));
mInputFrameDataStream->SetRecvdFin(true);
DecrementConcurrent(mInputFrameDataStream);
--- a/netwerk/protocol/http/SpdySession31.h
+++ b/netwerk/protocol/http/SpdySession31.h
@@ -20,19 +20,19 @@
class nsISocketTransport;
namespace mozilla { namespace net {
class SpdyPushedStream31;
class SpdyStream31;
class SpdySession31 MOZ_FINAL : public ASpdySession
- , public nsAHttpConnection
- , public nsAHttpSegmentReader
- , public nsAHttpSegmentWriter
+ , public nsAHttpConnection
+ , public nsAHttpSegmentReader
+ , public nsAHttpSegmentWriter
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSAHTTPCONNECTION(mConnection)
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
--- a/netwerk/protocol/http/SpdyStream3.cpp
+++ b/netwerk/protocol/http/SpdyStream3.cpp
@@ -33,48 +33,48 @@
// defined by the socket transport service while active
extern PRThread *gSocketThread;
#endif
namespace mozilla {
namespace net {
SpdyStream3::SpdyStream3(nsAHttpTransaction *httpTransaction,
- SpdySession3 *spdySession,
- int32_t priority)
- : mStreamID(0),
- mSession(spdySession),
- mUpstreamState(GENERATING_SYN_STREAM),
- mSynFrameComplete(0),
- mSentFinOnData(0),
- mTransaction(httpTransaction),
- mSocketTransport(spdySession->SocketTransport()),
- mSegmentReader(nullptr),
- mSegmentWriter(nullptr),
- mChunkSize(spdySession->SendingChunkSize()),
- mRequestBlockedOnRead(0),
- mRecvdFin(0),
- mFullyOpen(0),
- mSentWaitingFor(0),
- mReceivedData(0),
- mSetTCPSocketBuffer(0),
- mTxInlineFrameSize(SpdySession3::kDefaultBufferSize),
- mTxInlineFrameUsed(0),
- mTxStreamFrameSize(0),
- mZlib(spdySession->UpstreamZlib()),
- mDecompressBufferSize(SpdySession3::kDefaultBufferSize),
- mDecompressBufferUsed(0),
- mDecompressedBytes(0),
- mRequestBodyLenRemaining(0),
- mPriority(priority),
- mLocalUnacked(0),
- mBlockedOnRwin(false),
- mTotalSent(0),
- mTotalRead(0),
- mPushSource(nullptr)
+ SpdySession3 *spdySession,
+ int32_t priority)
+ : mStreamID(0)
+ , mSession(spdySession)
+ , mUpstreamState(GENERATING_SYN_STREAM)
+ , mSynFrameComplete(0)
+ , mSentFinOnData(0)
+ , mTransaction(httpTransaction)
+ , mSocketTransport(spdySession->SocketTransport())
+ , mSegmentReader(nullptr)
+ , mSegmentWriter(nullptr)
+ , mChunkSize(spdySession->SendingChunkSize())
+ , mRequestBlockedOnRead(0)
+ , mRecvdFin(0)
+ , mFullyOpen(0)
+ , mSentWaitingFor(0)
+ , mReceivedData(0)
+ , mSetTCPSocketBuffer(0)
+ , mTxInlineFrameSize(SpdySession3::kDefaultBufferSize)
+ , mTxInlineFrameUsed(0)
+ , mTxStreamFrameSize(0)
+ , mZlib(spdySession->UpstreamZlib())
+ , mDecompressBufferSize(SpdySession3::kDefaultBufferSize)
+ , mDecompressBufferUsed(0)
+ , mDecompressedBytes(0)
+ , mRequestBodyLenRemaining(0)
+ , mPriority(priority)
+ , mLocalUnacked(0)
+ , mBlockedOnRwin(false)
+ , mTotalSent(0)
+ , mTotalRead(0)
+ , mPushSource(nullptr)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
LOG3(("SpdyStream3::SpdyStream3 %p", this));
mRemoteWindow = spdySession->GetServerInitialWindow();
mLocalWindow = spdySession->PushAllowance();
@@ -184,19 +184,18 @@ SpdyStream3::ReadSegments(nsAHttpSegment
MOZ_ASSERT(false, "SpdyStream3::ReadSegments unknown state");
break;
}
return rv;
}
// WriteSegments() is used to read data off the socket. Generally this is
-// just the SPDY frame header and from there the appropriate SPDYStream
-// is identified from the Stream-ID. The http transaction associated with
-// that read then pulls in the data directly.
+// just a call through to the associate nsHttpTransaciton for this stream
+// for the remaining data bytes indicated by the current DATA frame.
nsresult
SpdyStream3::WriteSegments(nsAHttpSegmentWriter *writer,
uint32_t count,
uint32_t *countWritten)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
MOZ_ASSERT(!mSegmentWriter, "segment writer in progress");
@@ -1338,18 +1337,18 @@ SpdyStream3::UpdateRemoteWindow(int32_t
}
//-----------------------------------------------------------------------------
// nsAHttpSegmentReader
//-----------------------------------------------------------------------------
nsresult
SpdyStream3::OnReadSegment(const char *buf,
- uint32_t count,
- uint32_t *countRead)
+ uint32_t count,
+ uint32_t *countRead)
{
LOG3(("SpdyStream3::OnReadSegment %p count=%d state=%x",
this, count, mUpstreamState));
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
MOZ_ASSERT(mSegmentReader, "OnReadSegment with null mSegmentReader");
nsresult rv = NS_ERROR_UNEXPECTED;
--- a/netwerk/protocol/http/SpdyStream31.cpp
+++ b/netwerk/protocol/http/SpdyStream31.cpp
@@ -33,46 +33,46 @@ extern PRThread *gSocketThread;
#endif
namespace mozilla {
namespace net {
SpdyStream31::SpdyStream31(nsAHttpTransaction *httpTransaction,
SpdySession31 *spdySession,
int32_t priority)
- : mStreamID(0),
- mSession(spdySession),
- mUpstreamState(GENERATING_SYN_STREAM),
- mSynFrameComplete(0),
- mSentFinOnData(0),
- mTransaction(httpTransaction),
- mSocketTransport(spdySession->SocketTransport()),
- mSegmentReader(nullptr),
- mSegmentWriter(nullptr),
- mChunkSize(spdySession->SendingChunkSize()),
- mRequestBlockedOnRead(0),
- mRecvdFin(0),
- mFullyOpen(0),
- mSentWaitingFor(0),
- mReceivedData(0),
- mSetTCPSocketBuffer(0),
- mTxInlineFrameSize(SpdySession31::kDefaultBufferSize),
- mTxInlineFrameUsed(0),
- mTxStreamFrameSize(0),
- mZlib(spdySession->UpstreamZlib()),
- mDecompressBufferSize(SpdySession31::kDefaultBufferSize),
- mDecompressBufferUsed(0),
- mDecompressedBytes(0),
- mRequestBodyLenRemaining(0),
- mPriority(priority),
- mLocalUnacked(0),
- mBlockedOnRwin(false),
- mTotalSent(0),
- mTotalRead(0),
- mPushSource(nullptr)
+ : mStreamID(0)
+ , mSession(spdySession)
+ , mUpstreamState(GENERATING_SYN_STREAM)
+ , mSynFrameComplete(0)
+ , mSentFinOnData(0)
+ , mTransaction(httpTransaction)
+ , mSocketTransport(spdySession->SocketTransport())
+ , mSegmentReader(nullptr)
+ , mSegmentWriter(nullptr)
+ , mChunkSize(spdySession->SendingChunkSize())
+ , mRequestBlockedOnRead(0)
+ , mRecvdFin(0)
+ , mFullyOpen(0)
+ , mSentWaitingFor(0)
+ , mReceivedData(0)
+ , mSetTCPSocketBuffer(0)
+ , mTxInlineFrameSize(SpdySession31::kDefaultBufferSize)
+ , mTxInlineFrameUsed(0)
+ , mTxStreamFrameSize(0)
+ , mZlib(spdySession->UpstreamZlib())
+ , mDecompressBufferSize(SpdySession31::kDefaultBufferSize)
+ , mDecompressBufferUsed(0)
+ , mDecompressedBytes(0)
+ , mRequestBodyLenRemaining(0)
+ , mPriority(priority)
+ , mLocalUnacked(0)
+ , mBlockedOnRwin(false)
+ , mTotalSent(0)
+ , mTotalRead(0)
+ , mPushSource(nullptr)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
LOG3(("SpdyStream31::SpdyStream31 %p", this));
mRemoteWindow = spdySession->GetServerInitialStreamWindow();
mLocalWindow = spdySession->PushAllowance();
@@ -189,19 +189,18 @@ SpdyStream31::ReadSegments(nsAHttpSegmen
MOZ_ASSERT(false, "SpdyStream31::ReadSegments unknown state");
break;
}
return rv;
}
// WriteSegments() is used to read data off the socket. Generally this is
-// just the SPDY frame header and from there the appropriate SPDYStream
-// is identified from the Stream-ID. The http transaction associated with
-// that read then pulls in the data directly.
+// just a call through to the associate nsHttpTransaciton for this stream
+// for the remaining data bytes indicated by the current DATA frame.
nsresult
SpdyStream31::WriteSegments(nsAHttpSegmentWriter *writer,
uint32_t count,
uint32_t *countWritten)
{
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
MOZ_ASSERT(!mSegmentWriter, "segment writer in progress");
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -73,28 +73,28 @@ nsHttpConnection::nsHttpConnection()
, mPriority(nsISupportsPriority::PRIORITY_NORMAL)
, mReportedSpdy(false)
, mEverUsedSpdy(false)
, mLastHttpResponseVersion(NS_HTTP_VERSION_1_1)
, mTransactionCaps(0)
, mResponseTimeoutEnabled(false)
, mTCPKeepaliveConfig(kTCPKeepaliveDisabled)
{
- LOG(("Creating nsHttpConnection @%x\n", this));
+ LOG(("Creating nsHttpConnection @%p\n", this));
// the default timeout is for when this connection has not yet processed a
// transaction
static const PRIntervalTime k5Sec = PR_SecondsToInterval(5);
mIdleTimeout =
(k5Sec < gHttpHandler->IdleTimeout()) ? k5Sec : gHttpHandler->IdleTimeout();
}
nsHttpConnection::~nsHttpConnection()
{
- LOG(("Destroying nsHttpConnection @%x\n", this));
+ LOG(("Destroying nsHttpConnection @%p\n", this));
if (!mEverUsedSpdy) {
LOG(("nsHttpConnection %p performed %d HTTP/1.x transactions\n",
this, mHttp1xTransactionCount));
Telemetry::Accumulate(Telemetry::HTTP_REQUEST_PER_CONN,
mHttp1xTransactionCount);
}
@@ -1242,17 +1242,17 @@ nsHttpConnection::EndIdleMonitoring()
//-----------------------------------------------------------------------------
// nsHttpConnection <private>
//-----------------------------------------------------------------------------
void
nsHttpConnection::CloseTransaction(nsAHttpTransaction *trans, nsresult reason)
{
- LOG(("nsHttpConnection::CloseTransaction[this=%p trans=%x reason=%x]\n",
+ LOG(("nsHttpConnection::CloseTransaction[this=%p trans=%p reason=%x]\n",
this, trans, reason));
MOZ_ASSERT(trans == mTransaction, "wrong transaction");
MOZ_ASSERT(PR_GetCurrentThread() == gSocketThread);
if (mCurrentBytesRead > mMaxBytesRead)
mMaxBytesRead = mCurrentBytesRead;
--- a/netwerk/protocol/http/nsHttpConnection.h
+++ b/netwerk/protocol/http/nsHttpConnection.h
@@ -68,38 +68,40 @@ public:
nsresult Activate(nsAHttpTransaction *, uint32_t caps, int32_t pri);
// Close the underlying socket transport.
void Close(nsresult reason);
//-------------------------------------------------------------------------
// XXX document when these are ok to call
- bool SupportsPipelining();
- bool IsKeepAlive() { return mUsingSpdyVersion ||
- (mKeepAliveMask && mKeepAlive); }
- bool CanReuse(); // can this connection be reused?
- bool CanDirectlyActivate();
+ bool SupportsPipelining();
+ bool IsKeepAlive()
+ {
+ return mUsingSpdyVersion || (mKeepAliveMask && mKeepAlive);
+ }
+ bool CanReuse(); // can this connection be reused?
+ bool CanDirectlyActivate();
// Returns time in seconds for how long connection can be reused.
uint32_t TimeToLive();
- void DontReuse();
+ void DontReuse();
- bool IsProxyConnectInProgress()
+ bool IsProxyConnectInProgress()
{
return mProxyConnectInProgress;
}
- bool LastTransactionExpectedNoContent()
+ bool LastTransactionExpectedNoContent()
{
return mLastTransactionExpectedNoContent;
}
- void SetLastTransactionExpectedNoContent(bool val)
+ void SetLastTransactionExpectedNoContent(bool val)
{
mLastTransactionExpectedNoContent = val;
}
nsISocketTransport *Transport() { return mSocketTransport; }
nsAHttpTransaction *Transaction() { return mTransaction; }
nsHttpConnectionInfo *ConnectionInfo() { return mConnInfo; }
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -81,22 +81,22 @@ nsHttpConnectionMgr::nsHttpConnectionMgr
, mNumActiveConns(0)
, mNumIdleConns(0)
, mNumSpdyActiveConns(0)
, mNumHalfOpenConns(0)
, mTimeOfNextWakeUp(UINT64_MAX)
, mTimeoutTickArmed(false)
, mTimeoutTickNext(1)
{
- LOG(("Creating nsHttpConnectionMgr @%x\n", this));
+ LOG(("Creating nsHttpConnectionMgr @%p\n", this));
}
nsHttpConnectionMgr::~nsHttpConnectionMgr()
{
- LOG(("Destroying nsHttpConnectionMgr @%x\n", this));
+ LOG(("Destroying nsHttpConnectionMgr @%p\n", this));
if (mTimeoutTick)
mTimeoutTick->Cancel();
}
nsresult
nsHttpConnectionMgr::EnsureSocketThreadTarget()
{
nsresult rv;
@@ -281,41 +281,41 @@ nsHttpConnectionMgr::Observe(nsISupports
}
//-----------------------------------------------------------------------------
nsresult
nsHttpConnectionMgr::AddTransaction(nsHttpTransaction *trans, int32_t priority)
{
- LOG(("nsHttpConnectionMgr::AddTransaction [trans=%x %d]\n", trans, priority));
+ LOG(("nsHttpConnectionMgr::AddTransaction [trans=%p %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));
+ LOG(("nsHttpConnectionMgr::RescheduleTransaction [trans=%p %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));
+ LOG(("nsHttpConnectionMgr::CancelTransaction [trans=%p 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;
}
@@ -421,17 +421,17 @@ nsHttpConnectionMgr::GetSocketThreadTarg
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
NS_IF_ADDREF(*target = mSocketThreadTarget);
return NS_OK;
}
nsresult
nsHttpConnectionMgr::ReclaimConnection(nsHttpConnection *conn)
{
- LOG(("nsHttpConnectionMgr::ReclaimConnection [conn=%x]\n", conn));
+ LOG(("nsHttpConnectionMgr::ReclaimConnection [conn=%p]\n", conn));
NS_ADDREF(conn);
nsresult rv = PostEvent(&nsHttpConnectionMgr::OnMsgReclaimConnection, 0, conn);
if (NS_FAILED(rv))
NS_RELEASE(conn);
return rv;
}
@@ -1596,17 +1596,17 @@ nsHttpConnectionMgr::TryDispatchTransact
// 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()));
+ LOG((" dispatch to spdy: [conn=%p]\n", conn.get()));
trans->RemoveDispatchedAsBlocking(); /* just in case */
DispatchTransaction(ent, trans, conn);
return NS_OK;
}
unusedSpdyPersistentConnection = conn;
}
}
@@ -1671,22 +1671,22 @@ nsHttpConnectionMgr::TryDispatchTransact
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()));
+ LOG((" dropping stale connection: [conn=%p]\n", conn.get()));
conn->Close(NS_ERROR_ABORT);
conn = nullptr;
}
else {
- LOG((" reusing connection [conn=%x]\n", conn.get()));
+ LOG((" reusing connection [conn=%p]\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) {
@@ -1751,17 +1751,17 @@ nsHttpConnectionMgr::DispatchTransaction
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",
+ "[ci=%s trans=%p caps=%x conn=%p 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()) {
@@ -1811,17 +1811,17 @@ nsHttpConnectionMgr::DispatchAbstractTra
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",
+ "[ci=%s trans=%p caps=%x conn=%p]\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 */
