bug 378637 part 3 - fix http style: comments, whitespace, formatters r=hurley
authorPatrick McManus <mcmanus@ducksong.com>
Thu, 17 Apr 2014 19:55:04 -0400
changeset 183598 25c7d263eb6e
parent 183597 856b2a9e1428
child 183599 ec87f45db49e
push id26799
push userphilringnalda@gmail.com
push date2014-05-18 00:55 +0000
treeherdermozilla-central@00ef3a7d7aa7 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewershurley
bugs378637
milestone32.0a1
bug 378637 part 3 - fix http style: comments, whitespace, formatters r=hurley
netwerk/protocol/http/Http2Session.cpp
netwerk/protocol/http/Http2Stream.cpp
netwerk/protocol/http/SpdySession3.cpp
netwerk/protocol/http/SpdySession31.cpp
netwerk/protocol/http/SpdySession31.h
netwerk/protocol/http/SpdyStream3.cpp
netwerk/protocol/http/SpdyStream31.cpp
netwerk/protocol/http/nsHttpConnection.cpp
netwerk/protocol/http/nsHttpConnection.h
netwerk/protocol/http/nsHttpConnectionMgr.cpp
--- 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 */