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
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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 */